EsoErik

That being the case, let's get started.

Whoa!  Not so fast; this may not be completely hopeless.  The Qt docs insist that the QML scene graph is very flexible.  We'll see...

Firstly, QQuickFramebufferObject has a lot of moving parts, and some non-moving parts.  QQuickFramebufferObject::textureProvider(), for example, as far as I can tell, is never called.  Instead, QQuickFramebufferObject::updatePaintNode(QSGNode *node, UpdatePaintNodeData *) is responsible for instantiating QSGFramebufferObjectNode, which is a private class defined in qt5/qtdeclarative/src/quick/items/qquickframebufferobject.cpp.  So, let's start with making a QML Item (QQuickItem, in C++ land) that does nothing fancy save for rendering to a 30-bit texture when the Item's layer.enabled property is true.

In other words, the following, contained in an ApplicationWindow, should be free of 8-bit banding:

ThirtyBitImageItem {

    id: thirtyBitImageItem

    objectName: "thirtyBitImageItem"

    anchors.horizontalCenter: parent.horizontalCenter

    anchors.top: parent.top

    anchors.bottom: parent.bottom

    width: (implicitWidth / implicitHeight) * height

    anchors.margins: 10

    layer.enabled: true

}

ThirtyBitImageItem's C++ declaration:

class ThirtyBitImageItem

  : public QQuickItem

{

    Q_OBJECT

    Q_PROPERTY(Image* image READ image WRITE setImage)

public:

    ThirtyBitImageItem(QQuickItem* parent=nullptr);

    Image* image();

    const Image* image() const;

    void setImage(Image* image);

signals:

public slots:

protected:

    Image* m_image;

    std::forward_list<QMetaObject::Connection> m_imageSignalConnections;

    QSGNode* updatePaintNode(QSGNode* oldNode, UpdatePaintNodeData* updatePaintNodeData) override;

    void onImageSizeChanged(QSize size);

};

ThirtyBitImageItem is to be our 30-bit capable version of the built-in QML type, Image (implemented as QQuickImage in C++).  QQuickImage::updatePaintNode's implementation can be seen in qt5/qtdeclarative/src/quick/items/qquickimage.cpp:

QSGNode *QQuickImage::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)

{

    Q_D(QQuickImage);

    QSGTexture *texture = d->sceneGraphRenderContext()->textureForFactory(d->pix.textureFactory(), window());

    // Copy over the current texture state into the texture provider...

    if (d->provider) {

        d->provider->m_smooth = d->smooth;

        d->provider->m_mipmap = d->mipmap;

        d->provider->updateTexture(texture);

    }

    if (!texture || width() <= 0 || height() <= 0) {

        delete oldNode;

        return 0;

    }

    QSGImageNode *node = static_cast<QSGImageNode *>(oldNode);

    if (!node) {

        d->pixmapChanged = true;

        node = d->sceneGraphContext()->createImageNode();

    }

    // ...

    return node;

}

There's a lot going on, here.  QQuickImage::updatePaintNode is more complex than our first pass implementation needs to be, but it does provide some hints.  Perhaps all we need is our own version of QSGImageNode that supports 30-bit color?