Qt.labs.sharedimage: Make plugin optional

This moves the sharedimage types into a new library and is meant to make
them availabe to the QML compiler at some point in the future.

Task-number: QTBUG-90487
Change-Id: If79425a43cb8c1831422631791d35c1f329c7e80
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>

7 files changed, 693 insertions, 0 deletions

diff --git a/src/labs/CMakeLists.txt b/src/labs/CMakeLists.txt
index 2680ae8d11..9a984ccfb9 100644
--- a/src/labs/CMakeLists.txt
+++ b/src/labs/CMakeLists.txt
@@ -12,3 +12,7 @@ endif()
 if(QT_FEATURE_quick_shadereffect AND TARGET Qt::Quick)
     add_subdirectory(wavefrontmesh)
 endif()
+
+if(QT_FEATURE_systemsemaphore AND TARGET Qt::Quick)
+    add_subdirectory(sharedimage)
+endif()
diff --git a/src/labs/sharedimage/CMakeLists.txt b/src/labs/sharedimage/CMakeLists.txt
new file mode 100644
index 0000000000..217f688599
--- /dev/null
+++ b/src/labs/sharedimage/CMakeLists.txt
@@ -0,0 +1,24 @@
+qt_internal_add_module(LabsSharedImage
+  GENERATE_METATYPES
+  SOURCES
+        qsharedimageloader.cpp qsharedimageloader_p.h
+        qsharedimageprovider.cpp qsharedimageprovider_p.h
+        qtlabssharedimageglobal_p.h
+  DEFINES
+        QT_BUILD_LABSSHAREDIMAGE_LIB
+  PUBLIC_LIBRARIES
+        Qt::CorePrivate
+        Qt::GuiPrivate
+        Qt::QuickPrivate
+)
+
+
+set_target_properties(LabsSharedImage PROPERTIES
+    QT_QML_MODULE_INSTALL_QMLTYPES TRUE
+    QT_QML_MODULE_VERSION ${CMAKE_PROJECT_VERSION}
+    QT_QML_MODULE_URI Qt.labs.sharedimage
+    QT_QMLTYPES_FILENAME plugins.qmltypes
+    QT_QML_MODULE_INSTALL_DIR "${INSTALL_QMLDIR}/Qt/labs/sharedimage"
+)
+
+qt6_qml_type_registration(LabsSharedImage)
diff --git a/src/labs/sharedimage/qsharedimageloader.cpp b/src/labs/sharedimage/qsharedimageloader.cpp
new file mode 100644
index 0000000000..c9e3ef3eb3
--- /dev/null
+++ b/src/labs/sharedimage/qsharedimageloader.cpp
@@ -0,0 +1,266 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsharedimageloader_p.h"
+#include <private/qobject_p.h>
+#include <private/qimage_p.h>
+#include <QSharedMemory>
+
+
+QT_BEGIN_NAMESPACE
+
+Q_LOGGING_CATEGORY(lcSharedImage, "qt.quick.sharedimage");
+
+struct SharedImageHeader {
+    quint8 magic;
+    quint8 version;
+    quint16 offset;
+    qint32 width;
+    qint32 height;
+    qint32 bpl;
+    QImage::Format format;
+};
+Q_STATIC_ASSERT(sizeof(SharedImageHeader) % 4 == 0);
+
+#if QT_CONFIG(sharedmemory)
+struct SharedImageInfo {
+    QString path;
+    QPointer<QSharedMemory> shmp;
+};
+
+void cleanupSharedImage(void *cleanupInfo)
+{
+    if (!cleanupInfo)
+        return;
+    SharedImageInfo *sii = static_cast<SharedImageInfo *>(cleanupInfo);
+    qCDebug(lcSharedImage) << "Cleanup called for" << sii->path;
+    if (sii->shmp.isNull()) {
+        qCDebug(lcSharedImage) << "shm is 0 for" << sii->path;
+        return;
+    }
+    QSharedMemory *shm = sii->shmp.data();
+    sii->shmp.clear();
+    delete shm;    // destructor detaches
+    delete sii;
+}
+#else
+void cleanupSharedImage(void *) {}
+#endif
+
+class QSharedImageLoaderPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QSharedImageLoader)
+
+public:
+    QSharedImageLoaderPrivate() {}
+
+    QImage load(const QString &path, QSharedImageLoader::ImageParameters *params);
+
+    void storeImageToMem(void *data, const QImage &img);
+
+    bool verifyMem(const void *data, int size);
+
+    QImage createImageFromMem(const void *data, void *cleanupInfo);
+
+};
+
+
+void QSharedImageLoaderPrivate::storeImageToMem(void *data, const QImage &img)
+{
+    Q_ASSERT(data && !img.isNull());
+
+    SharedImageHeader *h = static_cast<SharedImageHeader *>(data);
+    h->magic = 'Q';
+    h->version = 1;
+    h->offset = sizeof(SharedImageHeader);
+    h->width = img.width();
+    h->height = img.height();
+    h->bpl = img.bytesPerLine();
+    h->format = img.format();
+
+    uchar *p = static_cast<uchar *>(data) + sizeof(SharedImageHeader);
+    memcpy(p, img.constBits(), img.sizeInBytes());
+}
+
+
+bool QSharedImageLoaderPrivate::verifyMem(const void *data, int size)
+{
+    if (!data || size < int(sizeof(SharedImageHeader)))
+        return false;
+
+    const SharedImageHeader *h = static_cast<const SharedImageHeader *>(data);
+    if ((h->magic != 'Q')
+        || (h->version < 1)
+        || (h->offset < sizeof(SharedImageHeader))
+        || (h->width <= 0)
+        || (h->height <= 0)
+        || (h->bpl <= 0)
+        || (h->format <= QImage::Format_Invalid)
+        || (h->format >= QImage::NImageFormats)) {
+        return false;
+    }
+
+    int availSize = size - h->offset;
+    if (h->height * h->bpl > availSize)
+        return false;
+    if ((qt_depthForFormat(h->format) * h->width * h->height) > (8 * availSize))
+        return false;
+
+    return true;
+}
+
+
+QImage QSharedImageLoaderPrivate::createImageFromMem(const void *data, void *cleanupInfo)
+{
+    const SharedImageHeader *h = static_cast<const SharedImageHeader *>(data);
+    const uchar *p = static_cast<const uchar *>(data) + h->offset;
+
+    QImage img(p, h->width, h->height, h->bpl, h->format, cleanupSharedImage, cleanupInfo);
+    return img;
+}
+
+
+QImage QSharedImageLoaderPrivate::load(const QString &path, QSharedImageLoader::ImageParameters *params)
+{
+#if QT_CONFIG(sharedmemory)
+    Q_Q(QSharedImageLoader);
+
+    QImage nil;
+    if (path.isEmpty())
+        return nil;
+
+    QScopedPointer<QSharedMemory> shm(new QSharedMemory(q->key(path, params)));
+    bool locked = false;
+
+    if (!shm->attach(QSharedMemory::ReadOnly)) {
+        QImage img = q->loadFile(path, params);
+        if (img.isNull())
+            return nil;
+        size_t size = sizeof(SharedImageHeader) + img.sizeInBytes();
+        if (size > size_t(std::numeric_limits<int>::max())) {
+            qCDebug(lcSharedImage) << "Image" << path << "to large to load";
+            return nil;
+        } else if (shm->create(int(size))) {
+            qCDebug(lcSharedImage) << "Created new shm segment of size" << size << "for image" << path;
+            if (!shm->lock()) {
+                qCDebug(lcSharedImage) << "Lock1 failed!?" << shm->errorString();
+                return nil;
+            }
+            locked = true;
+            storeImageToMem(shm->data(), img);
+        } else if (shm->error() == QSharedMemory::AlreadyExists) {
+            // race handling: other process may have created the share while
+            // we loaded the image, so try again to just attach
+            if (!shm->attach(QSharedMemory::ReadOnly)) {
+                qCDebug(lcSharedImage) << "Attach to existing failed?" << shm->errorString();
+                return nil;
+            }
+        } else {
+            qCDebug(lcSharedImage) << "Create failed?" << shm->errorString();
+            return nil;
+        }
+    }
+
+    Q_ASSERT(shm->isAttached());
+
+    if (!locked) {
+        if (!shm->lock()) {
+            qCDebug(lcSharedImage) << "Lock2 failed!?" << shm->errorString();
+            return nil;
+        }
+        locked = true;
+    }
+
+    if (!verifyMem(shm->constData(), shm->size())) {
+        qCDebug(lcSharedImage) << "Verifymem failed!?";
+        shm->unlock();
+        return nil;
+    }
+
+    QSharedMemory *shmp = shm.take();
+    SharedImageInfo *sii = new SharedImageInfo;
+    sii->path = path;
+    sii->shmp = shmp;
+    QImage shImg = createImageFromMem(shmp->constData(), sii);
+
+    if (!shmp->unlock()) {
+        qCDebug(lcSharedImage) << "UnLock failed!?";
+    }
+
+    return shImg;
+#else
+    Q_UNUSED(path);
+    Q_UNUSED(params);
+    return QImage();
+#endif
+}
+
+
+QSharedImageLoader::QSharedImageLoader(QObject *parent)
+    : QObject(*new QSharedImageLoaderPrivate, parent)
+{
+}
+
+QSharedImageLoader::~QSharedImageLoader()
+{
+}
+
+QImage QSharedImageLoader::load(const QString &path, ImageParameters *params)
+{
+    Q_D(QSharedImageLoader);
+
+    return d->load(path, params);
+}
+
+QImage QSharedImageLoader::loadFile(const QString &path, ImageParameters *params)
+{
+    Q_UNUSED(params);
+
+    return QImage(path);
+}
+
+QString QSharedImageLoader::key(const QString &path, ImageParameters *params)
+{
+    Q_UNUSED(params);
+
+    return path;
+}
+
+
+QT_END_NAMESPACE
diff --git a/src/labs/sharedimage/qsharedimageloader_p.h b/src/labs/sharedimage/qsharedimageloader_p.h
new file mode 100644
index 0000000000..3c6dabc871
--- /dev/null
+++ b/src/labs/sharedimage/qsharedimageloader_p.h
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSHAREDIMAGELOADER_H
+#define QSHAREDIMAGELOADER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qtlabssharedimageglobal_p.h"
+
+#include <QImage>
+#include <QVariant>
+#include <QLoggingCategory>
+#include <qqml.h>
+
+QT_BEGIN_NAMESPACE
+
+Q_DECLARE_LOGGING_CATEGORY(lcSharedImage);
+
+class QSharedImageLoaderPrivate;
+
+class Q_LABSSHAREDIMAGE_PRIVATE_EXPORT QSharedImageLoader : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QSharedImageLoader)
+
+    // We need to provide some type, in order to mention the 1.0 version.
+    QML_ANONYMOUS
+    QML_ADDED_IN_VERSION(1, 0)
+
+public:
+    typedef QVector<QVariant> ImageParameters;
+
+    QSharedImageLoader(QObject *parent = nullptr);
+    ~QSharedImageLoader();
+
+    QImage load(const QString &path, ImageParameters *params = nullptr);
+
+protected:
+    virtual QImage loadFile(const QString &path, ImageParameters *params);
+    virtual QString key(const QString &path, ImageParameters *params);
+
+private:
+    Q_DISABLE_COPY(QSharedImageLoader)
+};
+
+QT_END_NAMESPACE
+
+#endif // QSHAREDIMAGELOADER_H
diff --git a/src/labs/sharedimage/qsharedimageprovider.cpp b/src/labs/sharedimage/qsharedimageprovider.cpp
new file mode 100644
index 0000000000..74822a4e87
--- /dev/null
+++ b/src/labs/sharedimage/qsharedimageprovider.cpp
@@ -0,0 +1,139 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qsharedimageprovider_p.h>
+#include <private/qquickpixmapcache_p.h>
+#include <private/qimage_p.h>
+#include <QImageReader>
+#include <QFileInfo>
+#include <QDir>
+
+Q_DECLARE_METATYPE(QQuickImageProviderOptions)
+
+
+QuickSharedImageLoader::QuickSharedImageLoader(QObject *parent) : QSharedImageLoader(parent) {}
+
+QImage QuickSharedImageLoader::loadFile(const QString &path, ImageParameters *params)
+{
+    QImageReader imgio(path);
+    QSize realSize = imgio.size();
+    QSize requestSize;
+    QQuickImageProviderOptions options;
+    if (params) {
+        requestSize = params->value(RequestedSize).toSize();
+        options = params->value(ProviderOptions).value<QQuickImageProviderOptions>();
+    }
+
+    QSize scSize = QQuickImageProviderWithOptions::loadSize(imgio.size(), requestSize, imgio.format(), options);
+
+    if (scSize.isValid())
+        imgio.setScaledSize(scSize);
+
+    QImage image;
+    if (imgio.read(&image)) {
+        if (realSize.isEmpty())
+            realSize = image.size();
+        // Make sure we have acceptable format for texture uploader, or it will convert & lose sharing
+        // This mimics the testing & conversion normally done by the quick pixmapcache & texturefactory
+        if (image.format() != QImage::Format_RGB32 && image.format() != QImage::Format_ARGB32_Premultiplied) {
+            QImage::Format newFmt = QImage::Format_RGB32;
+            if (image.hasAlphaChannel() && image.data_ptr()->checkForAlphaPixels())
+                newFmt = QImage::Format_ARGB32_Premultiplied;
+            qCDebug(lcSharedImage) << "Convert on load from format" << image.format() << "to" << newFmt;
+            image = image.convertToFormat(newFmt);
+        }
+    }
+
+    if (params && params->count() > OriginalSize)
+        params->replace(OriginalSize, realSize);
+
+    return image;
+}
+
+QString QuickSharedImageLoader::key(const QString &path, ImageParameters *params)
+{
+    QSize reqSz;
+    QQuickImageProviderOptions opts;
+    if (params) {
+        reqSz = params->value(RequestedSize).toSize();
+        opts = params->value(ProviderOptions).value<QQuickImageProviderOptions>();
+    }
+    if (!reqSz.isValid())
+        return path;
+    int aspect = opts.preserveAspectRatioCrop() || opts.preserveAspectRatioFit() ? 1 : 0;
+
+    QString key = path + QStringLiteral("_%1x%2_%3").arg(reqSz.width()).arg(reqSz.height()).arg(aspect);
+    qCDebug(lcSharedImage) << "KEY:" << key;
+    return key;
+}
+
+SharedImageProvider::SharedImageProvider()
+    : QQuickImageProviderWithOptions(QQuickImageProvider::Image), loader(new QuickSharedImageLoader)
+{
+}
+
+QImage SharedImageProvider::requestImage(const QString &id, QSize *size, const QSize &requestedSize, const QQuickImageProviderOptions &options)
+{
+    QFileInfo fi(QDir::root(), id);
+    QString path = fi.canonicalFilePath();
+    if (path.isEmpty())
+        return QImage();
+
+    QSharedImageLoader::ImageParameters params(QuickSharedImageLoader::NumImageParameters);
+    params[QuickSharedImageLoader::RequestedSize].setValue(requestedSize);
+    params[QuickSharedImageLoader::ProviderOptions].setValue(options);
+
+    QImage img = loader->load(path, &params);
+    if (img.isNull()) {
+        // May be sharing problem, fall back to normal local load
+        img = loader->loadFile(path, &params);
+        if (!img.isNull())
+            qCWarning(lcSharedImage) << "Sharing problem; loading" << id << "unshared";
+    }
+
+    //... QSize realSize = params.value(QSharedImageLoader::OriginalSize).toSize();
+    // quickpixmapcache's readImage() reports back the original size, prior to requestedSize scaling, in the *size
+    // parameter. That value is currently ignored by quick however, which only cares about the present size of the
+    // returned image. So handling and sharing of info on pre-scaled size is currently not implemented.
+    if (size) {
+        *size = img.size();
+    }
+
+    return img;
+}
diff --git a/src/labs/sharedimage/qsharedimageprovider_p.h b/src/labs/sharedimage/qsharedimageprovider_p.h
new file mode 100644
index 0000000000..f8bea9e784
--- /dev/null
+++ b/src/labs/sharedimage/qsharedimageprovider_p.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSHAREDIMAGEPROVIDER_H
+#define QSHAREDIMAGEPROVIDER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qtlabssharedimageglobal_p.h"
+
+#include <QQuickImageProvider>
+#include <private/qquickpixmapcache_p.h>
+#include <QScopedPointer>
+
+#include "qsharedimageloader_p.h"
+
+class SharedImageProvider;
+
+class QuickSharedImageLoader : public QSharedImageLoader
+{
+    Q_OBJECT
+    friend class SharedImageProvider;
+
+public:
+    enum ImageParameter {
+        OriginalSize = 0,
+        RequestedSize,
+        ProviderOptions,
+        NumImageParameters
+    };
+
+    QuickSharedImageLoader(QObject *parent = nullptr);
+protected:
+    QImage loadFile(const QString &path, ImageParameters *params) override;
+    QString key(const QString &path, ImageParameters *params) override;
+};
+
+class Q_LABSSHAREDIMAGE_PRIVATE_EXPORT SharedImageProvider : public QQuickImageProviderWithOptions
+{
+public:
+    SharedImageProvider();
+
+    QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize, const QQuickImageProviderOptions &options) override;
+
+protected:
+    QScopedPointer<QuickSharedImageLoader> loader;
+};
+#endif // QSHAREDIMAGEPROVIDER_H
diff --git a/src/labs/sharedimage/qtlabssharedimageglobal_p.h b/src/labs/sharedimage/qtlabssharedimageglobal_p.h
new file mode 100644
index 0000000000..c67be432dd
--- /dev/null
+++ b/src/labs/sharedimage/qtlabssharedimageglobal_p.h
@@ -0,0 +1,73 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTLABSSHAREDIMAGEGLOBAL_P_H
+#define QTLABSSHAREDIMAGEGLOBAL_P_H
+
+#include <QtCore/qglobal.h>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+#if !defined(QT_STATIC)
+#  if defined(QT_BUILD_LABSSHAREDIMAGE_LIB)
+#    define Q_LABSSHAREDIMAGE_EXPORT Q_DECL_EXPORT
+#  else
+#    define Q_LABSSHAREDIMAGE_EXPORT Q_DECL_IMPORT
+#  endif
+#else
+#  define Q_LABSSHAREDIMAGE_EXPORT
+#endif
+#define Q_LABSSHAREDIMAGE_PRIVATE_EXPORT Q_LABSSHAREDIMAGE_EXPORT
+
+QT_END_NAMESPACE
+
+void Q_LABSSHAREDIMAGE_PRIVATE_EXPORT qml_register_types_Qt_labs_sharedimage();
+
+#endif // QTLABSSHAREDIMAGEGLOBAL_P_H