Make QOpenGLTextureCache::bindTexture upload efficiently

Currently QOpenGLTextureCache::bindTexture always convert any uploaded
image to RGBA8888 before uploading. This is quite inefficient when
OpenGL natively supports uploading formats in the original format.

This patch adds support for uploading a few native QImage formats. This
also get the performance of QOpenGLTextureCache::bindTexture on par with
QGLContext::bindTexture.

The texture brush used by QOpenGLPaintEngine is also converted to QImage,
since bindTexture will convert it to QImage anyway, and going over QPixmap
may cause an unnecessary conversion.

[ChangeLog][QtGui][QOpenGLTextureCache] Support uploading common QImage
formats directly to OpenGL when supported.

Change-Id: I828a763126441a98e4547c32ef52dddf7c129a32
Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>

1 files changed, 118 insertions, 12 deletions

diff --git a/src/gui/opengl/qopengltexturecache.cpp b/src/gui/opengl/qopengltexturecache.cpp
index d8b44016b9..4a4a36d7e5 100644
--- a/src/gui/opengl/qopengltexturecache.cpp
+++ b/src/gui/opengl/qopengltexturecache.cpp
@@ -43,11 +43,24 @@
 #include <qmath.h>
 #include <qopenglfunctions.h>
 #include <private/qopenglcontext_p.h>
+#include <private/qopenglextensions_p.h>
 #include <private/qimagepixmapcleanuphooks_p.h>
 #include <qpa/qplatformpixmap.h>
 
 QT_BEGIN_NAMESPACE
 
+#ifndef GL_BGR
+#define GL_BGR 0x80E0
+#endif
+
+#ifndef GL_BGRA
+#define GL_BGRA 0x80E1
+#endif
+
+#ifndef GL_UNSIGNED_INT_8_8_8_8_REV
+#define GL_UNSIGNED_INT_8_8_8_8_REV       0x8367
+#endif
+
 class QOpenGLTextureCacheWrapper
 {
 public:
@@ -107,7 +120,7 @@ QOpenGLTextureCache::~QOpenGLTextureCache()
 {
 }
 
-GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, const QPixmap &pixmap)
+GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, const QPixmap &pixmap, BindOptions options)
 {
     if (pixmap.isNull())
         return 0;
@@ -117,20 +130,20 @@ GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, const QPixmap &
     // A QPainter is active on the image - take the safe route and replace the texture.
     if (!pixmap.paintingActive()) {
         QOpenGLCachedTexture *entry = m_cache.object(key);
-        if (entry) {
+        if (entry && entry->options() == options) {
             context->functions()->glBindTexture(GL_TEXTURE_2D, entry->id());
             return entry->id();
         }
     }
 
-    GLuint id = bindTexture(context, key, pixmap.toImage());
+    GLuint id = bindTexture(context, key, pixmap.toImage(), options);
     if (id > 0)
         QImagePixmapCleanupHooks::enableCleanupHooks(pixmap);
 
     return id;
 }
 
-GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, const QImage &image)
+GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, const QImage &image, BindOptions options)
 {
     if (image.isNull())
         return 0;
@@ -140,7 +153,7 @@ GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, const QImage &i
     // A QPainter is active on the image - take the safe route and replace the texture.
     if (!image.paintingActive()) {
         QOpenGLCachedTexture *entry = m_cache.object(key);
-        if (entry) {
+        if (entry && entry->options() == options) {
             context->functions()->glBindTexture(GL_TEXTURE_2D, entry->id());
             return entry->id();
         }
@@ -158,26 +171,119 @@ GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, const QImage &i
         }
     }
 
-    GLuint id = bindTexture(context, key, img);
+    GLuint id = bindTexture(context, key, img, options);
     if (id > 0)
         QImagePixmapCleanupHooks::enableCleanupHooks(image);
 
     return id;
 }
 
-GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, qint64 key, const QImage &image)
+GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, qint64 key, const QImage &image, BindOptions options)
 {
     GLuint id;
     QOpenGLFunctions *funcs = context->functions();
     funcs->glGenTextures(1, &id);
     funcs->glBindTexture(GL_TEXTURE_2D, id);
 
-    QImage tx = image.convertToFormat(QImage::Format_RGBA8888_Premultiplied);
+    QImage tx;
+    GLenum externalFormat;
+    GLenum internalFormat;
+    GLuint pixelType;
+    QImage::Format targetFormat = QImage::Format_Invalid;
+    const bool isOpenGL12orBetter = !context->isOpenGLES() && (context->format().majorVersion() >= 2 || context->format().minorVersion() >= 2);
+
+    switch (image.format()) {
+    case QImage::Format_RGB32:
+    case QImage::Format_ARGB32:
+    case QImage::Format_ARGB32_Premultiplied:
+        if (isOpenGL12orBetter) {
+            externalFormat = GL_BGRA;
+            internalFormat = GL_RGBA;
+            pixelType = GL_UNSIGNED_INT_8_8_8_8_REV;
+        } else  {
+#if Q_BYTE_ORDER == Q_BIG_ENDIAN
+            // Without GL_UNSIGNED_INT_8_8_8_8_REV, BGRA only matches ARGB on little endian.
+            break;
+#endif
+            if (static_cast<QOpenGLExtensions*>(context->functions())->hasOpenGLExtension(QOpenGLExtensions::BGRATextureFormat)) {
+                // GL_EXT_bgra or GL_EXT_texture_format_BGRA8888 extensions.
+                if (context->isOpenGLES()) {
+                    // The GL_EXT_texture_format_BGRA8888 extension requires the internal format to match the external.
+                    externalFormat = internalFormat = GL_BGRA;
+                } else {
+                    // OpenGL BGRA/BGR format is not allowed as an internal format
+                    externalFormat = GL_BGRA;
+                    internalFormat = GL_RGBA;
+                }
+                pixelType = GL_UNSIGNED_BYTE;
+            } else if (context->isOpenGLES() && context->hasExtension(QByteArrayLiteral("GL_APPLE_texture_format_BGRA8888"))) {
+                // Is only allowed as an external format like OpenGL.
+                externalFormat = GL_BGRA;
+                internalFormat = GL_RGBA;
+                pixelType = GL_UNSIGNED_BYTE;
+            } else {
+                // No support for direct ARGB32 upload.
+                break;
+            }
+        }
+        targetFormat = image.format();
+        break;
+    case QImage::Format_RGB444:
+    case QImage::Format_RGB555:
+    case QImage::Format_RGB16:
+        if (isOpenGL12orBetter || context->isOpenGLES()) {
+            externalFormat = internalFormat = GL_RGB;
+            pixelType = GL_UNSIGNED_SHORT_5_6_5;
+            targetFormat = QImage::Format_RGB16;
+        }
+        break;
+    case QImage::Format_RGB666:
+    case QImage::Format_RGB888:
+        externalFormat = internalFormat = GL_RGB;
+        pixelType = GL_UNSIGNED_BYTE;
+        targetFormat = QImage::Format_RGB888;
+        break;
+    case QImage::Format_RGBX8888:
+    case QImage::Format_RGBA8888:
+    case QImage::Format_RGBA8888_Premultiplied:
+        externalFormat = internalFormat = GL_RGBA;
+        pixelType = GL_UNSIGNED_BYTE;
+        targetFormat = image.format();
+        break;
+    default:
+        break;
+    }
+
+    if (targetFormat == QImage::Format_Invalid) {
+        externalFormat = internalFormat = GL_RGBA;
+        pixelType = GL_UNSIGNED_BYTE;
+        if (!image.hasAlphaChannel())
+            targetFormat = QImage::Format_RGBX8888;
+        else
+            targetFormat = QImage::Format_RGBA8888;
+    }
+
+    if (options & PremultipliedAlphaBindOption) {
+        if (targetFormat == QImage::Format_ARGB32)
+            targetFormat = QImage::Format_ARGB32_Premultiplied;
+        else if (targetFormat == QImage::Format_RGBA8888)
+            targetFormat = QImage::Format_RGBA8888_Premultiplied;
+    } else {
+        if (targetFormat == QImage::Format_ARGB32_Premultiplied)
+            targetFormat = QImage::Format_ARGB32;
+        else if (targetFormat == QImage::Format_RGBA8888_Premultiplied)
+            targetFormat = QImage::Format_RGBA8888;
+    }
+
+    if (image.format() != targetFormat)
+        tx = image.convertToFormat(targetFormat);
+    else
+        tx = image;
 
-    funcs->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tx.width(), tx.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, const_cast<const QImage &>(tx).bits());
+    funcs->glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, tx.width(), tx.height(), 0, externalFormat, pixelType, const_cast<const QImage &>(tx).bits());
 
-    int cost = tx.width() * tx.height() * 4 / 1024;
-    m_cache.insert(key, new QOpenGLCachedTexture(id, context), cost);
+    int cost = tx.width() * tx.height() * tx.depth() / (1024 * 8);
+    m_cache.insert(key, new QOpenGLCachedTexture(id, options, context), cost);
 
     return id;
 }
@@ -203,7 +309,7 @@ static void freeTexture(QOpenGLFunctions *funcs, GLuint id)
     funcs->glDeleteTextures(1, &id);
 }
 
-QOpenGLCachedTexture::QOpenGLCachedTexture(GLuint id, QOpenGLContext *context)
+QOpenGLCachedTexture::QOpenGLCachedTexture(GLuint id, int options, QOpenGLContext *context) : m_options(options)
 {
     m_resource = new QOpenGLSharedResourceGuard(context, id, freeTexture);
 }