qt 4.6.0: backport a few patches from git, mainly QGL related

1 files changed, 771 insertions, 0 deletions

diff --git a/recipes/qt4/qt-4.6.0/0947-Compressed-texture-binding-for-QtOpenGL-ETC1-and-PVR.patch b/recipes/qt4/qt-4.6.0/0947-Compressed-texture-binding-for-QtOpenGL-ETC1-and-PVR.patch
new file mode 100644
index 0000000000..605a913cb7
--- /dev/null
+++ b/recipes/qt4/qt-4.6.0/0947-Compressed-texture-binding-for-QtOpenGL-ETC1-and-PVR.patch
@@ -0,0 +1,771 @@
+From 147195bccfdf90924a1525398e9c7b3119c1e278 Mon Sep 17 00:00:00 2001
+From: Rhys Weatherley <rhys.weatherley@nokia.com>
+Date: Thu, 3 Dec 2009 10:07:22 +1000
+Subject: [PATCH 0947/1244] Compressed texture binding for QtOpenGL: ETC1 and PVRTC
+
+The QGLContext::bindTexture(QString) function has been augmented
+with support for ETC1, PVRTC2, and PVRTC4 compressed textures,
+in addition to the existing DDS support.
+
+The QGLPixmapData class has also been modified to recognize
+compressed texture formats in fromFile() and fromData().
+
+This change also fixes a bug in bindTexture() that prevented
+the same compressed texture file from being bound in multiple
+contexts.  There is now a separate file cache for each context group.
+
+Task-number: QT-2547
+Reviewed-by: Trond
+---
+ src/opengl/qgl.cpp            |  485 +++++++++++++++++++++++++++++++----------
+ src/opengl/qgl_p.h            |   16 ++-
+ src/opengl/qglextensions_p.h  |   17 ++
+ src/opengl/qpixmapdata_gl.cpp |   57 +++++
+ src/opengl/qpixmapdata_gl_p.h |    4 +
+ 5 files changed, 461 insertions(+), 118 deletions(-)
+
+diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
+index 94b8aa5..b376901 100644
+--- a/src/opengl/qgl.cpp
++++ b/src/opengl/qgl.cpp
+@@ -127,18 +127,6 @@ Q_GLOBAL_STATIC(QGLDefaultOverlayFormat, defaultOverlayFormatInstance)
+ QGLExtensions::Extensions QGLExtensions::glExtensions = 0;
+ bool QGLExtensions::nvidiaFboNeedsFinish = false;
+ 
+-#ifndef APIENTRY
+-# define APIENTRY
+-#endif
+-typedef void (APIENTRY *pfn_glCompressedTexImage2DARB) (GLenum, GLint, GLenum, GLsizei,
+-                                                        GLsizei, GLint, GLsizei, const GLvoid *);
+-static pfn_glCompressedTexImage2DARB qt_glCompressedTexImage2DARB = 0;
+-
+-
+-#ifndef APIENTRY
+-#define APIENTRY
+-#endif
+-
+ Q_GLOBAL_STATIC(QGLSignalProxy, theSignalProxy)
+ QGLSignalProxy *QGLSignalProxy::instance()
+ {
+@@ -1887,118 +1875,42 @@ void QGLContextPrivate::cleanup()
+ {
+ }
+ 
+-typedef QHash<QString, GLuint> QGLDDSCache;
+-Q_GLOBAL_STATIC(QGLDDSCache, qgl_dds_cache)
+-
+ /*!
+     \overload
+ 
+-    Reads the DirectDrawSurface (DDS) compressed file \a fileName and
+-    generates a 2D GL texture from it.
++    Reads the compressed texture file \a fileName and generates a 2D GL
++    texture from it.
+ 
+-    Only the DXT1, DXT3 and DXT5 DDS formats are supported.
++    This function can load DirectDrawSurface (DDS) textures in the
++    DXT1, DXT3 and DXT5 DDS formats if the \c GL_ARB_texture_compression
++    and \c GL_EXT_texture_compression_s3tc extensions are supported.
+ 
+-    Note that this will only work if the implementation supports the
+-    \c GL_ARB_texture_compression and \c GL_EXT_texture_compression_s3tc
+-    extensions.
++    Since 4.6.1, textures in the ETC1 format can be loaded if the
++    \c GL_OES_compressed_ETC1_RGB8_texture extension is supported
++    and the ETC1 texture has been encapsulated in the PVR container format.
++    Also, textures in the PVRTC2 and PVRTC4 formats can be loaded
++    if the \c GL_IMG_texture_compression_pvrtc extension is supported.
+ 
+     \sa deleteTexture()
+ */
+ 
+ GLuint QGLContext::bindTexture(const QString &fileName)
+ {
+-    if (!qt_glCompressedTexImage2DARB) {
+-        qWarning("QGLContext::bindTexture(): The GL implementation does not support texture"
+-                 "compression extensions.");
+-        return 0;
+-    }
+-
+-    QGLDDSCache::const_iterator it = qgl_dds_cache()->constFind(fileName);
+-    if (it != qgl_dds_cache()->constEnd()) {
++    Q_D(QGLContext);
++    QGLDDSCache *dds_cache = &(d->group->m_dds_cache);
++    QGLDDSCache::const_iterator it = dds_cache->constFind(fileName);
++    if (it != dds_cache->constEnd()) {
+         glBindTexture(GL_TEXTURE_2D, it.value());
+         return it.value();
+     }
+ 
+-    QFile f(fileName);
+-    f.open(QIODevice::ReadOnly);
+-
+-    char tag[4];
+-    f.read(&tag[0], 4);
+-    if (strncmp(tag,"DDS ", 4) != 0) {
+-        qWarning("QGLContext::bindTexture(): not a DDS image file.");
+-        return 0;
+-    }
+-
+-    DDSFormat ddsHeader;
+-    f.read((char *) &ddsHeader, sizeof(DDSFormat));
+-
+-    if (!ddsHeader.dwLinearSize) {
+-        qWarning("QGLContext::bindTexture() DDS image size is not valid.");
+-        return 0;
+-    }
+-
+-    int factor = 4;
+-    int bufferSize = 0;
+-    int blockSize = 16;
+-    GLenum format;
+-
+-    switch(ddsHeader.ddsPixelFormat.dwFourCC) {
+-    case FOURCC_DXT1:
+-        format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+-        factor = 2;
+-        blockSize = 8;
+-        break;
+-    case FOURCC_DXT3:
+-        format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+-        break;
+-    case FOURCC_DXT5:
+-        format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+-        break;
+-    default:
+-        qWarning("QGLContext::bindTexture() DDS image format not supported.");
++    QGLTexture texture(this);
++    QSize size = texture.bindCompressedTexture(fileName);
++    if (!size.isValid())
+         return 0;
+-    }
+-
+-    if (ddsHeader.dwMipMapCount > 1)
+-        bufferSize = ddsHeader.dwLinearSize * factor;
+-    else
+-        bufferSize = ddsHeader.dwLinearSize;
+-
+-    GLubyte *pixels = (GLubyte *) malloc(bufferSize*sizeof(GLubyte));
+-    f.seek(ddsHeader.dwSize + 4);
+-    f.read((char *) pixels, bufferSize);
+-    f.close();
+-
+-    GLuint tx_id;
+-    glGenTextures(1, &tx_id);
+-    glBindTexture(GL_TEXTURE_2D, tx_id);
+-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+-
+-    int size;
+-    int offset = 0;
+-    int w = ddsHeader.dwWidth;
+-    int h = ddsHeader.dwHeight;
+ 
+-    // load mip-maps
+-    for(int i = 0; i < (int) ddsHeader.dwMipMapCount; ++i) {
+-        if (w == 0) w = 1;
+-        if (h == 0) h = 1;
+-
+-        size = ((w+3)/4) * ((h+3)/4) * blockSize;
+-        qt_glCompressedTexImage2DARB(GL_TEXTURE_2D, i, format, w, h, 0,
+-                                     size, pixels + offset);
+-        offset += size;
+-
+-        // half size for each mip-map level
+-        w = w/2;
+-        h = h/2;
+-    }
+-
+-    free(pixels);
+-
+-    qgl_dds_cache()->insert(fileName, tx_id);
+-    return tx_id;
++    dds_cache->insert(fileName, texture.id);
++    return texture.id;
+ }
+ 
+ static inline QRgb qt_gl_convertToGLFormatHelper(QRgb src_pixel, GLenum texture_format)
+@@ -2593,17 +2505,20 @@ GLuint QGLContext::bindTexture(const QPixmap &pixmap, QMacCompatGLenum target, Q
+ */
+ void QGLContext::deleteTexture(GLuint id)
+ {
++    Q_D(QGLContext);
++
+     if (QGLTextureCache::instance()->remove(this, id))
+         return;
+ 
+     // check the DDS cache if the texture wasn't found in the pixmap/image
+     // cache
+-    QList<QString> ddsKeys = qgl_dds_cache()->keys();
++    QGLDDSCache *dds_cache = &(d->group->m_dds_cache);
++    QList<QString> ddsKeys = dds_cache->keys();
+     for (int i = 0; i < ddsKeys.size(); ++i) {
+-        GLuint texture = qgl_dds_cache()->value(ddsKeys.at(i));
++        GLuint texture = dds_cache->value(ddsKeys.at(i));
+         if (id == texture) {
+             glDeleteTextures(1, &texture);
+-            qgl_dds_cache()->remove(ddsKeys.at(i));
++            dds_cache->remove(ddsKeys.at(i));
+             return;
+         }
+     }
+@@ -4907,8 +4822,14 @@ void QGLExtensions::init_extensions()
+         glExtensions |= SampleBuffers;
+     if (extensions.contains("GL_SGIS_generate_mipmap"))
+         glExtensions |= GenerateMipmap;
+-    if (extensions.contains("GL_EXT_texture_compression_s3tc"))
++    if (extensions.contains("GL_ARB_texture_compression"))
+         glExtensions |= TextureCompression;
++    if (extensions.contains("GL_EXT_texture_compression_s3tc"))
++        glExtensions |= DDSTextureCompression;
++    if (extensions.contains("GL_OES_compressed_ETC1_RGB8_texture"))
++        glExtensions |= ETC1TextureCompression;
++    if (extensions.contains("GL_IMG_texture_compression_pvrtc"))
++        glExtensions |= PVRTCTextureCompression;
+     if (extensions.contains("GL_ARB_fragment_program"))
+         glExtensions |= FragmentProgram;
+     if (extensions.contains("GL_ARB_texture_mirrored_repeat"))
+@@ -4951,12 +4872,6 @@ void QGLExtensions::init_extensions()
+ 
+     if (extensions.contains("GL_EXT_bgra"))
+         glExtensions |= BGRATextureFormat;
+-
+-
+-    QGLContext cx(QGLFormat::defaultFormat());
+-    if (glExtensions & TextureCompression) {
+-        qt_glCompressedTexImage2DARB = (pfn_glCompressedTexImage2DARB) cx.getProcAddress(QLatin1String("glCompressedTexImage2DARB"));
+-    }
+ }
+ 
+ /*
+@@ -5112,4 +5027,340 @@ void QGLSharedResourceGuard::setContext(const QGLContext *context)
+     }
+ }
+ 
++QSize QGLTexture::bindCompressedTexture
++    (const QString& fileName, const char *format)
++{
++    QFile file(fileName);
++    if (!file.open(QIODevice::ReadOnly))
++        return QSize();
++    QByteArray contents = file.readAll();
++    file.close();
++    return bindCompressedTexture
++        (contents.constData(), contents.size(), format);
++}
++
++// PVR header format for container files that store textures compressed
++// with the ETC1, PVRTC2, and PVRTC4 encodings.  Format information from the
++// PowerVR SDK at http://www.imgtec.com/powervr/insider/powervr-sdk.asp
++// "PVRTexTool Reference Manual, version 1.11f".
++struct PvrHeader
++{
++    quint32 headerSize;
++    quint32 height;
++    quint32 width;
++    quint32 mipMapCount;
++    quint32 flags;
++    quint32 dataSize;
++    quint32 bitsPerPixel;
++    quint32 redMask;
++    quint32 greenMask;
++    quint32 blueMask;
++    quint32 alphaMask;
++    quint32 magic;
++    quint32 surfaceCount;
++};
++
++#define PVR_MAGIC               0x21525650      // "PVR!" in little-endian
++
++#define PVR_FORMAT_MASK         0x000000FF
++#define PVR_FORMAT_PVRTC2       0x00000018
++#define PVR_FORMAT_PVRTC4       0x00000019
++#define PVR_FORMAT_ETC1         0x00000036
++
++#define PVR_HAS_MIPMAPS         0x00000100
++#define PVR_TWIDDLED            0x00000200
++#define PVR_NORMAL_MAP          0x00000400
++#define PVR_BORDER_ADDED        0x00000800
++#define PVR_CUBE_MAP            0x00001000
++#define PVR_FALSE_COLOR_MIPMAPS 0x00002000
++#define PVR_VOLUME_TEXTURE      0x00004000
++#define PVR_ALPHA_IN_TEXTURE    0x00008000
++#define PVR_VERTICAL_FLIP       0x00010000
++
++#ifndef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
++#define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG      0x8C00
++#define GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG      0x8C01
++#define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG     0x8C02
++#define GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG     0x8C03
++#endif
++
++#ifndef GL_ETC1_RGB8_OES
++#define GL_ETC1_RGB8_OES                        0x8D64
++#endif
++
++bool QGLTexture::canBindCompressedTexture
++    (const char *buf, int len, const char *format, bool *hasAlpha)
++{
++    if (QSysInfo::ByteOrder != QSysInfo::LittleEndian) {
++        // Compressed texture loading only supported on little-endian
++        // systems such as x86 and ARM at the moment.
++        return false;
++    }
++    if (!format) {
++        // Auto-detect the format from the header.
++        if (len >= 4 && !qstrncmp(buf, "DDS ", 4)) {
++            *hasAlpha = true;
++            return true;
++        } else if (len >= 52 && !qstrncmp(buf + 44, "PVR!", 4)) {
++            const PvrHeader *pvrHeader =
++                reinterpret_cast<const PvrHeader *>(buf);
++            *hasAlpha = (pvrHeader->alphaMask != 0);
++            return true;
++        }
++    } else {
++        // Validate the format against the header.
++        if (!qstricmp(format, "DDS")) {
++            if (len >= 4 && !qstrncmp(buf, "DDS ", 4)) {
++                *hasAlpha = true;
++                return true;
++            }
++        } else if (!qstricmp(format, "PVR") || !qstricmp(format, "ETC1")) {
++            if (len >= 52 && !qstrncmp(buf + 44, "PVR!", 4)) {
++                const PvrHeader *pvrHeader =
++                    reinterpret_cast<const PvrHeader *>(buf);
++                *hasAlpha = (pvrHeader->alphaMask != 0);
++                return true;
++            }
++        }
++    }
++    return false;
++}
++
++#define ctx QGLContext::currentContext()
++
++QSize QGLTexture::bindCompressedTexture
++    (const char *buf, int len, const char *format)
++{
++    if (QSysInfo::ByteOrder != QSysInfo::LittleEndian) {
++        // Compressed texture loading only supported on little-endian
++        // systems such as x86 and ARM at the moment.
++        return QSize();
++    }
++#if !defined(QT_OPENGL_ES)
++    if (!glCompressedTexImage2D) {
++        if (!(QGLExtensions::glExtensions & QGLExtensions::TextureCompression)) {
++            qWarning("QGLContext::bindTexture(): The GL implementation does "
++                     "not support texture compression extensions.");
++            return QSize();
++        }
++        glCompressedTexImage2D = (_glCompressedTexImage2DARB) ctx->getProcAddress(QLatin1String("glCompressedTexImage2DARB"));
++        if (!glCompressedTexImage2D) {
++            qWarning("QGLContext::bindTexture(): could not resolve "
++                     "glCompressedTexImage2DARB.");
++            return QSize();
++        }
++    }
++#endif
++    if (!format) {
++        // Auto-detect the format from the header.
++        if (len >= 4 && !qstrncmp(buf, "DDS ", 4))
++            return bindCompressedTextureDDS(buf, len);
++        else if (len >= 52 && !qstrncmp(buf + 44, "PVR!", 4))
++            return bindCompressedTexturePVR(buf, len);
++    } else {
++        // Validate the format against the header.
++        if (!qstricmp(format, "DDS")) {
++            if (len >= 4 && !qstrncmp(buf, "DDS ", 4))
++                return bindCompressedTextureDDS(buf, len);
++        } else if (!qstricmp(format, "PVR") || !qstricmp(format, "ETC1")) {
++            if (len >= 52 && !qstrncmp(buf + 44, "PVR!", 4))
++                return bindCompressedTexturePVR(buf, len);
++        }
++    }
++    return QSize();
++}
++
++QSize QGLTexture::bindCompressedTextureDDS(const char *buf, int len)
++{
++    // We only support 2D texture loading at present.
++    if (target != GL_TEXTURE_2D)
++        return QSize();
++
++    // Bail out if the necessary extension is not present.
++    if (!(QGLExtensions::glExtensions & QGLExtensions::DDSTextureCompression)) {
++        qWarning("QGLContext::bindTexture(): DDS texture compression is not supported.");
++        return QSize();
++    }
++
++    const DDSFormat *ddsHeader = reinterpret_cast<const DDSFormat *>(buf + 4);
++    if (!ddsHeader->dwLinearSize) {
++        qWarning("QGLContext::bindTexture(): DDS image size is not valid.");
++        return QSize();
++    }
++
++    int blockSize = 16;
++    GLenum format;
++
++    switch(ddsHeader->ddsPixelFormat.dwFourCC) {
++    case FOURCC_DXT1:
++        format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
++        blockSize = 8;
++        break;
++    case FOURCC_DXT3:
++        format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
++        break;
++    case FOURCC_DXT5:
++        format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
++        break;
++    default:
++        qWarning("QGLContext::bindTexture(): DDS image format not supported.");
++        return QSize();
++    }
++
++    const GLubyte *pixels =
++        reinterpret_cast<const GLubyte *>(buf + ddsHeader->dwSize + 4);
++
++    glGenTextures(1, &id);
++    glBindTexture(GL_TEXTURE_2D, id);
++    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
++
++    int size;
++    int offset = 0;
++    int available = len - int(ddsHeader->dwSize + 4);
++    int w = ddsHeader->dwWidth;
++    int h = ddsHeader->dwHeight;
++
++    // load mip-maps
++    for(int i = 0; i < (int) ddsHeader->dwMipMapCount; ++i) {
++        if (w == 0) w = 1;
++        if (h == 0) h = 1;
++
++        size = ((w+3)/4) * ((h+3)/4) * blockSize;
++        if (size > available)
++            break;
++        glCompressedTexImage2D(GL_TEXTURE_2D, i, format, w, h, 0,
++                               size, pixels + offset);
++        offset += size;
++        available -= size;
++
++        // half size for each mip-map level
++        w = w/2;
++        h = h/2;
++    }
++
++    // DDS images are not inverted.
++    options &= ~QGLContext::InvertedYBindOption;
++
++    return QSize(ddsHeader->dwWidth, ddsHeader->dwHeight);
++}
++
++QSize QGLTexture::bindCompressedTexturePVR(const char *buf, int len)
++{
++    // We only support 2D texture loading at present.  Cube maps later.
++    if (target != GL_TEXTURE_2D)
++        return QSize();
++
++    // Determine which texture format we will be loading.
++    const PvrHeader *pvrHeader = reinterpret_cast<const PvrHeader *>(buf);
++    GLenum textureFormat;
++    quint32 minWidth, minHeight;
++    switch (pvrHeader->flags & PVR_FORMAT_MASK) {
++    case PVR_FORMAT_PVRTC2:
++        if (pvrHeader->alphaMask)
++            textureFormat = GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
++        else
++            textureFormat = GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
++        minWidth = 16;
++        minHeight = 8;
++        break;
++
++    case PVR_FORMAT_PVRTC4:
++        if (pvrHeader->alphaMask)
++            textureFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
++        else
++            textureFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
++        minWidth = 8;
++        minHeight = 8;
++        break;
++
++    case PVR_FORMAT_ETC1:
++        textureFormat = GL_ETC1_RGB8_OES;
++        minWidth = 4;
++        minHeight = 4;
++        break;
++
++    default:
++        qWarning("QGLContext::bindTexture(): PVR image format 0x%x not supported.", int(pvrHeader->flags & PVR_FORMAT_MASK));
++        return QSize();
++    }
++
++    // Bail out if the necessary extension is not present.
++    if (textureFormat == GL_ETC1_RGB8_OES) {
++        if (!(QGLExtensions::glExtensions &
++                    QGLExtensions::ETC1TextureCompression)) {
++            qWarning("QGLContext::bindTexture(): ETC1 texture compression is not supported.");
++            return QSize();
++        }
++    } else {
++        if (!(QGLExtensions::glExtensions &
++                    QGLExtensions::PVRTCTextureCompression)) {
++            qWarning("QGLContext::bindTexture(): PVRTC texture compression is not supported.");
++            return QSize();
++        }
++    }
++
++    // Boundary check on the buffer size.
++    quint32 bufferSize = pvrHeader->headerSize + pvrHeader->dataSize;
++    if (bufferSize > quint32(len)) {
++        qWarning("QGLContext::bindTexture(): PVR image size is not valid.");
++        return QSize();
++    }
++
++    // Create the texture.
++    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
++    glGenTextures(1, &id);
++    glBindTexture(GL_TEXTURE_2D, id);
++    if (pvrHeader->mipMapCount) {
++        if ((options & QGLContext::LinearFilteringBindOption) != 0) {
++            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
++        } else {
++            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
++            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
++        }
++    } else if ((options & QGLContext::LinearFilteringBindOption) != 0) {
++        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
++    } else {
++        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
++        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
++    }
++
++    // Load the compressed mipmap levels.
++    const GLubyte *buffer =
++        reinterpret_cast<const GLubyte *>(buf + pvrHeader->headerSize);
++    bufferSize = pvrHeader->dataSize;
++    quint32 level = 0;
++    quint32 width = pvrHeader->width;
++    quint32 height = pvrHeader->height;
++    while (bufferSize > 0 && level < pvrHeader->mipMapCount) {
++        quint32 size =
++            (qMax(width, minWidth) * qMax(height, minHeight) *
++             pvrHeader->bitsPerPixel) / 8;
++        if (size > bufferSize)
++            break;
++        glCompressedTexImage2D(GL_TEXTURE_2D, GLint(level), textureFormat,
++                               GLsizei(width), GLsizei(height), 0,
++                               GLsizei(size), buffer);
++        width /= 2;
++        height /= 2;
++        buffer += size;
++        ++level;
++    }
++
++    // Restore the default pixel alignment for later texture uploads.
++    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
++
++    // Set the invert flag for the texture.
++    if ((pvrHeader->flags & PVR_VERTICAL_FLIP) != 0)
++        options |= QGLContext::InvertedYBindOption;
++    else
++        options &= ~QGLContext::InvertedYBindOption;
++
++    return QSize(pvrHeader->width, pvrHeader->height);
++}
++
++#undef ctx
++
+ QT_END_NAMESPACE
+diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h
+index b2407ba..0f785a5 100644
+--- a/src/opengl/qgl_p.h
++++ b/src/opengl/qgl_p.h
+@@ -222,6 +222,8 @@ public:
+ class QGLContextResource;
+ class QGLSharedResourceGuard;
+ 
++typedef QHash<QString, GLuint> QGLDDSCache;
++
+ // QGLContextPrivate has the responsibility of creating context groups.
+ // QGLContextPrivate and QGLShareRegister will both maintain the reference counter and destroy
+ // context groups when needed.
+@@ -246,6 +248,7 @@ private:
+     QHash<QGLContextResource *, void *> m_resources;
+     QGLSharedResourceGuard *m_guards; // double-linked list of active guards.
+     QAtomicInt m_refs;
++    QGLDDSCache m_dds_cache;
+ 
+     void cleanupResources(const QGLContext *ctx);
+ 
+@@ -377,7 +380,10 @@ public:
+         PixelBufferObject       = 0x00000800,
+         FramebufferBlit         = 0x00001000,
+         NPOTTextures            = 0x00002000,
+-        BGRATextureFormat       = 0x00004000
++        BGRATextureFormat       = 0x00004000,
++        DDSTextureCompression   = 0x00008000,
++        ETC1TextureCompression  = 0x00010000,
++        PVRTCTextureCompression = 0x00020000
+     };
+     Q_DECLARE_FLAGS(Extensions, Extension)
+ 
+@@ -482,6 +488,14 @@ public:
+     QPixmapData* boundPixmap;
+ #endif
+ 
++    bool canBindCompressedTexture
++        (const char *buf, int len, const char *format, bool *hasAlpha);
++    QSize bindCompressedTexture
++        (const QString& fileName, const char *format = 0);
++    QSize bindCompressedTexture
++        (const char *buf, int len, const char *format = 0);
++    QSize bindCompressedTextureDDS(const char *buf, int len);
++    QSize bindCompressedTexturePVR(const char *buf, int len);
+ };
+ 
+ class QGLTextureCache {
+diff --git a/src/opengl/qglextensions_p.h b/src/opengl/qglextensions_p.h
+index 3510765..62e216c 100644
+--- a/src/opengl/qglextensions_p.h
++++ b/src/opengl/qglextensions_p.h
+@@ -184,6 +184,10 @@ typedef void (APIENTRY *_glBlitFramebufferEXT) (int srcX0, int srcY0, int srcX1,
+ typedef void (APIENTRY *_glRenderbufferStorageMultisampleEXT) (GLenum target, GLsizei samples,
+                                                                GLenum internalformat, GLsizei width, GLsizei height);
+ 
++// ARB_texture_compression
++typedef void (APIENTRY *_glCompressedTexImage2DARB) (GLenum, GLint, GLenum, GLsizei,
++                                                     GLsizei, GLint, GLsizei, const GLvoid *);
++
+ QT_BEGIN_NAMESPACE
+ 
+ struct QGLExtensionFuncs
+@@ -289,6 +293,11 @@ struct QGLExtensionFuncs
+ #endif
+         qt_glMapBufferARB = 0;
+         qt_glUnmapBufferARB = 0;
++
++#if !defined(QT_OPENGL_ES)
++        // Texture compression
++        qt_glCompressedTexImage2DARB = 0;
++#endif
+     }
+ 
+ 
+@@ -397,6 +406,10 @@ struct QGLExtensionFuncs
+     _glMapBufferARB qt_glMapBufferARB;
+     _glUnmapBufferARB qt_glUnmapBufferARB;
+ 
++#if !defined(QT_OPENGL_ES)
++    // Texture compression
++    _glCompressedTexImage2DARB qt_glCompressedTexImage2DARB;
++#endif
+ };
+ 
+ 
+@@ -732,6 +745,10 @@ struct QGLExtensionFuncs
+ #define glClearDepth glClearDepthf
+ #endif
+ 
++#if !defined(QT_OPENGL_ES)
++#define glCompressedTexImage2D QGLContextPrivate::extensionFuncs(ctx).qt_glCompressedTexImage2DARB
++#endif
++
+ extern bool qt_resolve_framebufferobject_extensions(QGLContext *ctx);
+ bool qt_resolve_buffer_extensions(QGLContext *ctx);
+ 
+diff --git a/src/opengl/qpixmapdata_gl.cpp b/src/opengl/qpixmapdata_gl.cpp
+index ab17789..0299cea 100644
+--- a/src/opengl/qpixmapdata_gl.cpp
++++ b/src/opengl/qpixmapdata_gl.cpp
+@@ -53,6 +53,8 @@
+ #include <private/qpaintengineex_opengl2_p.h>
+ 
+ #include <qdesktopwidget.h>
++#include <qfile.h>
++#include <qimagereader.h>
+ 
+ QT_BEGIN_NAMESPACE
+ 
+@@ -407,6 +409,61 @@ void QGLPixmapData::fromImage(const QImage &image,
+     }
+ }
+ 
++bool QGLPixmapData::fromFile(const QString &filename, const char *format,
++                             Qt::ImageConversionFlags flags)
++{
++    if (pixelType() == QPixmapData::BitmapType)
++        return QPixmapData::fromFile(filename, format, flags);
++    QFile file(filename);
++    if (!file.open(QIODevice::ReadOnly))
++        return false;
++    QByteArray data = file.peek(64);
++    bool alpha;
++    if (m_texture.canBindCompressedTexture
++            (data.constData(), data.size(), format, &alpha)) {
++        resize(0, 0);
++        data = file.readAll();
++        file.close();
++        QSize size = m_texture.bindCompressedTexture
++            (data.constData(), data.size(), format);
++        if (!size.isEmpty()) {
++            w = size.width();
++            h = size.height();
++            is_null = false;
++            d = 32;
++            m_hasAlpha = alpha;
++            m_source = QImage();
++            m_dirty = isValid();
++            return true;
++        }
++        return false;
++    }
++    fromImage(QImageReader(&file, format).read(), flags);
++    return !isNull();
++}
++
++bool QGLPixmapData::fromData(const uchar *buffer, uint len, const char *format,
++                             Qt::ImageConversionFlags flags)
++{
++    bool alpha;
++    const char *buf = reinterpret_cast<const char *>(buffer);
++    if (m_texture.canBindCompressedTexture(buf, int(len), format, &alpha)) {
++        resize(0, 0);
++        QSize size = m_texture.bindCompressedTexture(buf, int(len), format);
++        if (!size.isEmpty()) {
++            w = size.width();
++            h = size.height();
++            is_null = false;
++            d = 32;
++            m_hasAlpha = alpha;
++            m_source = QImage();
++            m_dirty = isValid();
++            return true;
++        }
++    }
++    return QPixmapData::fromData(buffer, len, format, flags);
++}
++
+ bool QGLPixmapData::scroll(int dx, int dy, const QRect &rect)
+ {
+     Q_UNUSED(dx);
+diff --git a/src/opengl/qpixmapdata_gl_p.h b/src/opengl/qpixmapdata_gl_p.h
+index 8a13e03..007c52a 100644
+--- a/src/opengl/qpixmapdata_gl_p.h
++++ b/src/opengl/qpixmapdata_gl_p.h
+@@ -106,6 +106,10 @@ public:
+     // Re-implemented from QPixmapData:
+     void resize(int width, int height);
+     void fromImage(const QImage &image, Qt::ImageConversionFlags flags);
++    bool fromFile(const QString &filename, const char *format,
++                  Qt::ImageConversionFlags flags);
++    bool fromData(const uchar *buffer, uint len, const char *format,
++                  Qt::ImageConversionFlags flags);
+     void copy(const QPixmapData *data, const QRect &rect);
+     bool scroll(int dx, int dy, const QRect &rect);
+     void fill(const QColor &color);
+-- 
+1.6.5
+