Revision control
Copy as Markdown
// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:critical reason:network-protocol
#include "qwltexturesharingextension_p.h"
#include <QWaylandSurface>
#include <QDebug>
#include <QQuickWindow>
#include <QPainter>
#include <QPen>
#include <QTimer>
#include <QtGui/private/qtexturefilereader_p.h>
#include <QtOpenGL/QOpenGLTexture>
#include <QtGui/QImageReader>
#include <QtQuick/QSGTexture>
#include <QQmlContext>
#include <QThread>
QT_BEGIN_NAMESPACE
class SharedTextureFactory : public QQuickTextureFactory
{
public:
SharedTextureFactory(const QtWayland::ServerBuffer *buffer)
: m_buffer(buffer)
{
}
~SharedTextureFactory() override
{
if (m_buffer && !QCoreApplication::closingDown())
const_cast<QtWayland::ServerBuffer*>(m_buffer)->releaseOpenGlTexture();
}
QSize textureSize() const override
{
return m_buffer ? m_buffer->size() : QSize();
}
int textureByteCount() const override
{
return m_buffer ? (m_buffer->size().width() * m_buffer->size().height() * 4) : 0;
}
QSGTexture *createTexture(QQuickWindow *window) const override
{
if (m_buffer != nullptr) {
QOpenGLTexture *texture = const_cast<QtWayland::ServerBuffer *>(m_buffer)->toOpenGlTexture();
return QNativeInterface::QSGOpenGLTexture::fromNative(texture->textureId(),
window,
m_buffer->size(),
QQuickWindow::TextureHasAlphaChannel);
}
return nullptr;
}
private:
const QtWayland::ServerBuffer *m_buffer = nullptr;
};
class SharedTextureImageResponse : public QQuickImageResponse
{
Q_OBJECT
public:
SharedTextureImageResponse(QWaylandTextureSharingExtension *extension, const QString &id)
: m_id(id)
{
if (extension)
doRequest(extension);
}
void doRequest(QWaylandTextureSharingExtension *extension)
{
m_extension = extension;
connect(extension, &QWaylandTextureSharingExtension::bufferResult, this, &SharedTextureImageResponse::doResponse);
QMetaObject::invokeMethod(extension, [this] { m_extension->requestBuffer(m_id); }, Qt::AutoConnection);
}
QQuickTextureFactory *textureFactory() const override
{
if (m_buffer) {
// qDebug() << "Creating shared buffer texture for" << m_id;
return new SharedTextureFactory(m_buffer);
}
// qDebug() << "Shared buffer NOT found for" << m_id;
m_errorString = QLatin1String("Shared buffer not found");
return nullptr;
}
QString errorString() const override
{
return m_errorString;
}
public Q_SLOTS:
void doResponse(const QString &key, QtWayland::ServerBuffer *buffer)
{
if (key != m_id)
return; //somebody else's texture
m_buffer = buffer;
if (m_extension)
disconnect(m_extension, &QWaylandTextureSharingExtension::bufferResult, this, &SharedTextureImageResponse::doResponse);
emit finished();
}
private:
QString m_id;
QWaylandTextureSharingExtension *m_extension = nullptr;
mutable QString m_errorString;
QtWayland::ServerBuffer *m_buffer = nullptr;
};
QWaylandSharedTextureProvider::QWaylandSharedTextureProvider()
{
}
QWaylandSharedTextureProvider::~QWaylandSharedTextureProvider()
{
}
QQuickImageResponse *QWaylandSharedTextureProvider::requestImageResponse(const QString &id, const QSize &requestedSize)
{
Q_UNUSED(requestedSize);
// qDebug() << "Provider: got request for" << id;
auto *extension = QWaylandTextureSharingExtension::self();
auto *response = new SharedTextureImageResponse(extension, id);
if (!extension)
m_pendingResponses << response;
return response;
}
void QWaylandSharedTextureProvider::setExtensionReady(QWaylandTextureSharingExtension *extension)
{
for (auto *response : std::as_const(m_pendingResponses))
response->doRequest(extension);
m_pendingResponses.clear();
m_pendingResponses.squeeze();
}
QWaylandTextureSharingExtension *QWaylandTextureSharingExtension::s_self = nullptr; // theoretical race conditions, but OK as long as we don't delete it while we are running
QWaylandTextureSharingExtension::QWaylandTextureSharingExtension()
{
s_self = this;
}
QWaylandTextureSharingExtension::QWaylandTextureSharingExtension(QWaylandCompositor *compositor)
:QWaylandCompositorExtensionTemplate(compositor)
{
s_self = this;
}
QWaylandTextureSharingExtension::~QWaylandTextureSharingExtension()
{
//qDebug() << Q_FUNC_INFO;
//dumpBufferInfo();
for (auto b : std::as_const(m_server_buffers))
delete b.buffer;
if (s_self == this)
s_self = nullptr;
}
void QWaylandTextureSharingExtension::setImageSearchPath(const QString &path)
{
m_image_dirs = path.split(QLatin1Char(';'));
for (auto it = m_image_dirs.begin(); it != m_image_dirs.end(); ++it)
if (!(*it).endsWith(QLatin1Char('/')))
(*it) += QLatin1Char('/');
}
void QWaylandTextureSharingExtension::initialize()
{
QWaylandCompositorExtensionTemplate::initialize();
QWaylandCompositor *compositor = static_cast<QWaylandCompositor *>(extensionContainer());
init(compositor->display(), 1);
QString image_search_path = qEnvironmentVariable("QT_WAYLAND_SHAREDTEXTURE_SEARCH_PATH");
if (!image_search_path.isEmpty())
setImageSearchPath(image_search_path);
if (m_image_dirs.isEmpty())
m_image_dirs << QLatin1String(":/") << QLatin1String("./");
auto suffixes = QTextureFileReader::supportedFileFormats();
suffixes.append(QImageReader::supportedImageFormats());
for (const auto &ext : std::as_const(suffixes))
m_image_suffixes << QLatin1Char('.') + QString::fromLatin1(ext);
//qDebug() << "m_image_suffixes" << m_image_suffixes << "m_image_dirs" << m_image_dirs;
auto *ctx = QQmlEngine::contextForObject(this);
if (ctx) {
QQmlEngine *engine = ctx->engine();
if (engine) {
auto *provider = static_cast<QWaylandSharedTextureProvider*>(engine->imageProvider(QLatin1String("wlshared")));
if (provider)
provider->setExtensionReady(this);
}
}
}
QString QWaylandTextureSharingExtension::getExistingFilePath(const QString &key) const
{
// The default search path blocks absolute pathnames, but this does not prevent relative
// paths containing '../'. We handle that here, at the price of also blocking directory
// names ending with two or more dots.
if (key.contains(QLatin1String("../")))
return QString();
for (auto dir : std::as_const(m_image_dirs)) {
QString path = dir + key;
if (QFileInfo::exists(path))
return path;
}
for (auto dir : std::as_const(m_image_dirs)) {
for (const auto &ext : m_image_suffixes) {
QString fp = dir + key + ext;
//qDebug() << "trying" << fp;
if (QFileInfo::exists(fp))
return fp;
}
}
return QString();
}
QtWayland::ServerBuffer *QWaylandTextureSharingExtension::getBuffer(const QString &key)
{
if (!initServerBufferIntegration())
return nullptr;
//qDebug() << "getBuffer" << key;
QtWayland::ServerBuffer *buffer = nullptr;
if ((buffer = m_server_buffers.value(key).buffer))
return buffer;
QByteArray pixelData;
QSize size;
uint glInternalFormat = GL_NONE;
if (customPixelData(key, &pixelData, &size, &glInternalFormat)) {
if (!pixelData.isEmpty()) {
buffer = m_server_buffer_integration->createServerBufferFromData(pixelData, size, glInternalFormat);
if (!buffer)
qWarning() << "QWaylandTextureSharingExtension: could not create buffer from custom data for key:" << key;
}
} else {
QString pathName = getExistingFilePath(key);
//qDebug() << "pathName" << pathName;
if (pathName.isEmpty())
return nullptr;
buffer = getCompressedBuffer(pathName);
//qDebug() << "getCompressedBuffer" << buffer;
if (!buffer) {
QImage img(pathName);
if (!img.isNull()) {
img = img.convertToFormat(QImage::Format_RGBA8888_Premultiplied);
buffer = m_server_buffer_integration->createServerBufferFromImage(img, QtWayland::ServerBuffer::RGBA32);
}
//qDebug() << "createServerBufferFromImage" << buffer;
}
}
if (buffer)
m_server_buffers.insert(key, BufferInfo(buffer));
//qDebug() << ">>>>" << key << buffer;
return buffer;
}
// Compositor requesting image for its own UI
void QWaylandTextureSharingExtension::requestBuffer(const QString &key)
{
//qDebug() << "requestBuffer" << key;
if (thread() != QThread::currentThread())
qWarning("QWaylandTextureSharingExtension::requestBuffer() called from outside main thread: possible race condition");
auto *buffer = getBuffer(key);
if (buffer)
m_server_buffers[key].usedLocally = true;
//dumpBufferInfo();
emit bufferResult(key, buffer);
}
void QWaylandTextureSharingExtension::zqt_texture_sharing_v1_request_image(Resource *resource, const QString &key)
{
//qDebug() << "texture_sharing_request_image" << key;
auto *buffer = getBuffer(key);
if (buffer) {
struct ::wl_client *client = resource->client();
struct ::wl_resource *buffer_resource = buffer->resourceForClient(client);
//qDebug() << " server_buffer resource" << buffer_resource;
if (buffer_resource)
send_provide_buffer(resource->handle, buffer_resource, key);
else
qWarning() << "QWaylandTextureSharingExtension: no buffer resource for client";
} else {
send_image_failed(resource->handle, key, QString());
}
//dumpBufferInfo();
}
void QWaylandTextureSharingExtension::zqt_texture_sharing_v1_abandon_image(Resource *resource, const QString &key)
{
Q_UNUSED(resource);
Q_UNUSED(key);
// qDebug() << Q_FUNC_INFO << resource << key;
QTimer::singleShot(100, this, &QWaylandTextureSharingExtension::cleanupBuffers);
}
// A client has disconnected
void QWaylandTextureSharingExtension::zqt_texture_sharing_v1_destroy_resource(Resource *resource)
{
Q_UNUSED(resource);
// qDebug() << "texture_sharing_destroy_resource" << resource->handle << resource->handle->object.id << "client" << resource->client();
// dumpBufferInfo();
QTimer::singleShot(1000, this, &QWaylandTextureSharingExtension::cleanupBuffers);
}
bool QWaylandTextureSharingExtension::initServerBufferIntegration()
{
if (!m_server_buffer_integration) {
QWaylandCompositor *compositor = static_cast<QWaylandCompositor *>(extensionContainer());
m_server_buffer_integration = QWaylandCompositorPrivate::get(compositor)->serverBufferIntegration();
if (!m_server_buffer_integration) {
qWarning("QWaylandTextureSharingExtension initialization failed: No Server Buffer Integration");
if (qEnvironmentVariableIsEmpty("QT_WAYLAND_SERVER_BUFFER_INTEGRATION"))
qWarning("Set the environment variable 'QT_WAYLAND_SERVER_BUFFER_INTEGRATION' to specify.");
return false;
}
}
return true;
}
QtWayland::ServerBuffer *QWaylandTextureSharingExtension::getCompressedBuffer(const QString &pathName)
{
QFile f(pathName);
if (!f.open(QIODevice::ReadOnly))
return nullptr;
QTextureFileReader r(&f, pathName);
if (!r.canRead())
return nullptr;
QTextureFileData td(r.read());
//qDebug() << "QWaylandTextureSharingExtension: reading compressed texture data" << td;
if (!td.isValid()) {
qWarning() << "VulkanServerBufferIntegration:" << pathName << "not valid compressed texture";
return nullptr;
}
return m_server_buffer_integration->createServerBufferFromData(td.getDataView(), td.size(),
td.glInternalFormat());
}
void QWaylandTextureSharingExtension::cleanupBuffers()
{
for (auto it = m_server_buffers.begin(); it != m_server_buffers.end(); ) {
auto *buffer = it.value().buffer;
if (!it.value().usedLocally && !buffer->bufferInUse()) {
//qDebug() << "deleting buffer for" << it.key();
it = m_server_buffers.erase(it);
delete buffer;
} else {
++it;
}
}
//dumpBufferInfo();
}
void QWaylandTextureSharingExtension::dumpBufferInfo()
{
qDebug() << "shared buffers:" << m_server_buffers.size();
for (auto it = m_server_buffers.cbegin(); it != m_server_buffers.cend(); ++it)
qDebug() << " " << it.key() << ":" << it.value().buffer << "in use" << it.value().buffer->bufferInUse() << "usedLocally" << it.value().usedLocally ;
}
QT_END_NAMESPACE
#include "moc_qwltexturesharingextension_p.cpp"
#include "qwltexturesharingextension.moc"