diff options
Diffstat (limited to 'recipes/qt4')
33 files changed, 3766 insertions, 6 deletions
diff --git a/recipes/qt4/qt-4.6.0.inc b/recipes/qt4/qt-4.6.0.inc index b29b708d74..91565f7e0e 100644 --- a/recipes/qt4/qt-4.6.0.inc +++ b/recipes/qt4/qt-4.6.0.inc @@ -1,5 +1,7 @@ DEFAULT_PREFERENCE = "-1" +FILESPATHPKG .= ":qt-${PV}" + SRC_URI = "ftp://ftp.trolltech.com/qt/source/qt-everywhere-opensource-src-${PV}.tar.gz \ file://0001-cross-compile.patch;patch=1 \ file://0002-fix-resinit-declaration.patch;patch=1 \ @@ -12,6 +14,37 @@ SRC_URI = "ftp://ftp.trolltech.com/qt/source/qt-everywhere-opensource-src-${PV}. file://g++.conf \ file://linux.conf \ " + +# Patches for '4.6' qt branch +SRC_URI += "\ + file://0860-Added-caching-of-vectorpaths-to-the-GL-paint-engine.patch;patch=1 \ + file://0917-Better-check-for-EGL-extension-strings.patch;patch=1 \ + file://0919-Rebind-window-surface-fbo-after-native-GL-rendering.patch;patch=1 \ + file://0943-Fixed-OpenGL-graphicssystem-issues-for-OpenGL-ES-2.0.patch;patch=1 \ + file://0945-Add-EGL_BUFFER_SIZE-to-QEglProperties-reduceConfigur.patch;patch=1 \ + file://0946-Fix-WA_TranslucentBackground-for-QGLWidgets-on-X11-E.patch;patch=1 \ + file://0947-Compressed-texture-binding-for-QtOpenGL-ETC1-and-PVR.patch;patch=1 \ + file://0951-Detect-GL2-paint-engine-based-on-fragment-shaders-no.patch;patch=1 \ + file://0971-Fix-GL_BGRA-formats-under-OpenGL-ES-systems.patch;patch=1 \ + file://0991-QGtkStyle-support-for-the-inner-border-property-in-G.patch;patch=1 \ + file://0992-Make-sure-a-context-is-current-when-loading-compress.patch;patch=1 \ + file://0993-Fix-upside-down-PVR-compressed-textures.patch;patch=1 \ + file://0996-Export-QGLShareRegister-because-qgl_share_reg-is-exp.patch;patch=1 \ + file://0998-Set-stacking-class-for-stays-on-top-windows-in-DFB.patch;patch=1 \ + file://0999-Enable-customizing-of-DirectFB-layer-to-use.patch;patch=1 \ + file://1008-GLES-2-should-not-use-a-multisampled-format-by-defau.patch;patch=1 \ + file://1115-Fix-QGLWidgets-created-with-an-alpha-channel-on-X11-.patch;patch=1 \ + file://1118-Fix-EGL-surface-leaks-when-re-parenting-QGLWidget-on.patch;patch=1 \ + file://1136-Disable-depth-testing-during-the-2D-QGLWidget-render.patch;patch=1 \ + file://1149-GL2Engine-Don-t-mark-brush-as-dirty-if-it-hasn-t-cha.patch;patch=1 \ + file://1157-Align-GL_RGB-lines-on-a-4-byte-boundary-when-uploadi.patch;patch=1 \ +# file://1165-NEON-configure-detection-and-initial-blend-function-.patch;patch=1 \ + file://1175-Fix-memory-leak-of-QGLGlyphCoord-objects-in-the-Open.patch;patch=1 \ + file://1197-Add-GLfloat-2-2-GLfloat-3-3-uniform-setters-to-QGLSh.patch;patch=1 \ + file://1198-Handle-broken-shaders-better-in-the-GL2-engine-s-sha.patch;patch=1 \ + file://1205-Fix-text-rendering-on-GL2-paint-engine.patch;patch=1 \ +" + S = "${WORKDIR}/qt-everywhere-opensource-src-${PV}" do_configure_prepend() { @@ -22,8 +55,6 @@ do_configure_prepend() { -e /QMAKE_UIC3\ /d \ -e /QMAKE_RCC\ /d \ ${S}/configure - -# sed -i /tools.pro/d ${S}/src/src.pro } QT_GLFLAGS ?= "" diff --git a/recipes/qt4/qt-4.6.0/0838-Fixed-the-GL2-engine-stroker-to-handle-Qt-SvgMiterJo.patch b/recipes/qt4/qt-4.6.0/0838-Fixed-the-GL2-engine-stroker-to-handle-Qt-SvgMiterJo.patch new file mode 100644 index 0000000000..a517d3ce41 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0838-Fixed-the-GL2-engine-stroker-to-handle-Qt-SvgMiterJo.patch @@ -0,0 +1,25 @@ +From 0f61a0f1ce02bb0248cb87055240a8a474dce452 Mon Sep 17 00:00:00 2001 +From: Kim Motoyoshi Kalland <kim.kalland@nokia.com> +Date: Fri, 27 Nov 2009 16:17:25 +0100 +Subject: [PATCH 0838/1244] Fixed the GL2 engine stroker to handle Qt::SvgMiterJoin. + +Reviewed-by: Trond +--- + .../gl2paintengineex/qtriangulatingstroker.cpp | 1 + + 1 files changed, 1 insertions(+), 0 deletions(-) + +diff --git a/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp b/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp +index c78f73f..6082f49 100644 +--- a/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp ++++ b/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp +@@ -313,6 +313,7 @@ void QTriangulatingStroker::join(const qreal *pts) + switch (m_join_style) { + case Qt::BevelJoin: + break; ++ case Qt::SvgMiterJoin: + case Qt::MiterJoin: { + // Find out on which side the join should be. + int count = m_vertices.size(); +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0860-Added-caching-of-vectorpaths-to-the-GL-paint-engine.patch b/recipes/qt4/qt-4.6.0/0860-Added-caching-of-vectorpaths-to-the-GL-paint-engine.patch new file mode 100644 index 0000000000..794380ab91 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0860-Added-caching-of-vectorpaths-to-the-GL-paint-engine.patch @@ -0,0 +1,317 @@ +From dbfdfdb1bc37dd18dd1b723b5d5b0b65c37f3f41 Mon Sep 17 00:00:00 2001 +From: Gunnar Sletta <gunnar@trolltech.com> +Date: Tue, 1 Dec 2009 09:18:47 +0100 +Subject: [PATCH 0860/1244] Added caching of vectorpaths to the GL paint engine. + +The first time a path is drawn we call makeCachable on the path, which +means that if it is drawn again, we start caching it. This is a bit of +a trick to avoid caching paths that are drawn once and discared while +at the same time cache paths that are reused automatically. + +The GL engine owns the vertex information and is responsible for cleaning +it up. If the vectorpath is destroyed first, it will call the cleanup function. +if the engine dies first, we still require some hooks to clean up the cache +in the path. More to come. When VBO's are used, these will be a leaked if the +path is destroyed after the engine. + +Reviewed-by: Samuel +--- + src/gui/painting/qpaintengineex.cpp | 16 +++- + src/gui/painting/qvectorpath_p.h | 13 ++- + src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h | 2 + + .../gl2paintengineex/qpaintengineex_opengl2.cpp | 115 +++++++++++++++++++- + .../gl2paintengineex/qpaintengineex_opengl2_p.h | 4 + + 5 files changed, 139 insertions(+), 11 deletions(-) + +diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp +index 7d1c109..9a0e319 100644 +--- a/src/gui/painting/qpaintengineex.cpp ++++ b/src/gui/painting/qpaintengineex.cpp +@@ -56,6 +56,20 @@ QT_BEGIN_NAMESPACE + * class QVectorPath + * + */ ++QVectorPath::~QVectorPath() ++{ ++ if (m_hints & ShouldUseCacheHint) { ++ CacheEntry *e = m_cache; ++ while (e) { ++ if (e->data) ++ e->cleanup(e->engine, e->data); ++ CacheEntry *n = e->next; ++ delete e; ++ e = n; ++ } ++ } ++} ++ + + QRectF QVectorPath::controlPointRect() const + { +@@ -94,7 +108,7 @@ QRectF QVectorPath::controlPointRect() const + + + QVectorPath::CacheEntry *QVectorPath::addCacheData(QPaintEngineEx *engine, void *data, +- qvectorpath_cache_cleanup cleanup) { ++ qvectorpath_cache_cleanup cleanup) const{ + Q_ASSERT(!lookupCacheData(engine)); + if ((m_hints & IsCachedHint) == 0) { + m_cache = 0; +diff --git a/src/gui/painting/qvectorpath_p.h b/src/gui/painting/qvectorpath_p.h +index ec27970..5eaddf4 100644 +--- a/src/gui/painting/qvectorpath_p.h ++++ b/src/gui/painting/qvectorpath_p.h +@@ -68,7 +68,7 @@ QT_MODULE(Gui) + + class QPaintEngineEx; + +-typedef void (*qvectorpath_cache_cleanup)(void *data); ++typedef void (*qvectorpath_cache_cleanup)(QPaintEngineEx *engine, void *data); + + struct QRealRect { + qreal x1, y1, x2, y2; +@@ -118,6 +118,8 @@ public: + { + } + ++ ~QVectorPath(); ++ + QRectF controlPointRect() const; + + inline Hint shape() const { return (Hint) (m_hints & ShapeMask); } +@@ -128,6 +130,7 @@ public: + inline bool hasImplicitClose() const { return m_hints & ImplicitClose; } + inline bool hasWindingFill() const { return m_hints & WindingFill; } + ++ inline void makeCacheable() const { m_hints |= ShouldUseCacheHint; m_cache = 0; } + inline uint hints() const { return m_hints; } + + inline const QPainterPath::ElementType *elements() const { return m_elements; } +@@ -146,9 +149,9 @@ public: + CacheEntry *next; + }; + +- CacheEntry *addCacheData(QPaintEngineEx *engine, void *data, qvectorpath_cache_cleanup cleanup); ++ CacheEntry *addCacheData(QPaintEngineEx *engine, void *data, qvectorpath_cache_cleanup cleanup) const; + inline CacheEntry *lookupCacheData(QPaintEngineEx *engine) const { +- Q_ASSERT(m_hints & IsCachedHint); ++ Q_ASSERT(m_hints & ShouldUseCacheHint); + CacheEntry *e = m_cache; + while (e) { + if (e->engine == engine) +@@ -162,14 +165,14 @@ public: + private: + Q_DISABLE_COPY(QVectorPath) + +- CacheEntry *m_cache; +- + const QPainterPath::ElementType *m_elements; + const qreal *m_points; + const int m_count; + + mutable uint m_hints; + mutable QRealRect m_cp_rect; ++ ++ mutable CacheEntry *m_cache; + }; + + Q_GUI_EXPORT const QVectorPath &qtVectorPathForPath(const QPainterPath &path); +diff --git a/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h b/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h +index 03aec17..98eaa91 100644 +--- a/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h ++++ b/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h +@@ -112,6 +112,8 @@ public: + int stopCount() const { return vertexArrayStops.size(); } + QGLRect boundingRect() const; + ++ int vertexCount() const { return vertexArray.size(); } ++ + void lineToArray(const GLfloat x, const GLfloat y); + + private: +diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp +index 6a708b4..3fce384 100644 +--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp ++++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp +@@ -62,6 +62,8 @@ + and use the correct program when we really need it. + */ + ++// #define QT_OPENGL_CACHE_AS_VBOS ++ + #include "qpaintengineex_opengl2_p.h" + + #include <string.h> //for memcpy +@@ -344,6 +346,13 @@ extern QImage qt_imageForBrush(int brushStyle, bool invert); + QGL2PaintEngineExPrivate::~QGL2PaintEngineExPrivate() + { + delete shaderManager; ++ ++ while (pathCaches.size()) { ++ QVectorPath::CacheEntry *e = *(pathCaches.constBegin()); ++ e->cleanup(e->engine, e->data); ++ e->data = 0; ++ e->engine = 0; ++ } + } + + void QGL2PaintEngineExPrivate::updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform, GLuint id) +@@ -846,6 +855,30 @@ void QGL2PaintEngineExPrivate::transferMode(EngineMode newMode) + mode = newMode; + } + ++struct QGL2PEVectorPathCache ++{ ++#ifdef QT_OPENGL_CACHE_AS_VBOS ++ GLuint vbo; ++#else ++ float *vertices; ++#endif ++ int vertexCount; ++ GLenum primitiveType; ++ qreal iscale; ++}; ++ ++void qopengl2paintengine_cleanup_vectorpath(QPaintEngineEx *engine, void *data) ++{ ++ QGL2PEVectorPathCache *c = (QGL2PEVectorPathCache *) data; ++#ifdef QT_OPENGL_CACHE_AS_VBOS ++ QGL2PaintEngineExPrivate *d = QGL2PaintEngineExPrivate::getData((QGL2PaintEngineEx *) engine); ++ d->unusedVBOSToClean << c->vbo; ++#else ++ qFree(c->vertices); ++#endif ++ delete c; ++} ++ + // Assumes everything is configured for the brush you want to use + void QGL2PaintEngineExPrivate::fill(const QVectorPath& path) + { +@@ -863,10 +896,74 @@ void QGL2PaintEngineExPrivate::fill(const QVectorPath& path) + prepareForDraw(currentBrush->isOpaque()); + composite(rect); + } else if (path.isConvex()) { +- vertexCoordinateArray.clear(); +- vertexCoordinateArray.addPath(path, inverseScale, false); +- prepareForDraw(currentBrush->isOpaque()); +- drawVertexArrays(vertexCoordinateArray, GL_TRIANGLE_FAN); ++ ++ if (path.isCacheable()) { ++ QVectorPath::CacheEntry *data = path.lookupCacheData(q); ++ QGL2PEVectorPathCache *cache; ++ ++ if (data) { ++ cache = (QGL2PEVectorPathCache *) data->data; ++ // Check if scale factor is exceeded for curved paths and generate curves if so... ++ if (path.isCurved()) { ++ qreal scaleFactor = cache->iscale / inverseScale; ++ if (scaleFactor < 0.5 || scaleFactor > 2.0) { ++#ifdef QT_OPENGL_CACHE_AS_VBOS ++ glDeleteBuffers(1, &cache->vbo); ++ cache->vbo = 0; ++#else ++ qFree(cache->vertices); ++#endif ++ cache->vertexCount = 0; ++ } ++ } ++ } else { ++ cache = new QGL2PEVectorPathCache; ++ cache->vertexCount = 0; ++ data = const_cast<QVectorPath &>(path).addCacheData(q, cache, qopengl2paintengine_cleanup_vectorpath); ++ } ++ ++ // Flatten the path at the current scale factor and fill it into the cache struct. ++ if (!cache->vertexCount) { ++ vertexCoordinateArray.clear(); ++ vertexCoordinateArray.addPath(path, inverseScale, false); ++ int vertexCount = vertexCoordinateArray.vertexCount(); ++ int floatSizeInBytes = vertexCount * 2 * sizeof(float); ++ cache->vertexCount = vertexCount; ++ cache->primitiveType = GL_TRIANGLE_FAN; ++ cache->iscale = inverseScale; ++#ifdef QT_OPENGL_CACHE_AS_VBOS ++ glGenBuffers(1, &cache->vbo); ++ glBindBuffer(GL_ARRAY_BUFFER, cache->vbo); ++ glBufferData(GL_ARRAY_BUFFER, floatSizeInBytes, vertexCoordinateArray.data(), GL_STATIC_DRAW); ++#else ++ cache->vertices = (float *) qMalloc(floatSizeInBytes); ++ memcpy(cache->vertices, vertexCoordinateArray.data(), floatSizeInBytes); ++#endif ++ } ++ ++ prepareForDraw(currentBrush->isOpaque()); ++ glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR); ++#ifdef QT_OPENGL_CACHE_AS_VBOS ++ glBindBuffer(GL_ARRAY_BUFFER, cache->vbo); ++ glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, false, 0, 0); ++#else ++ glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, false, 0, cache->vertices); ++#endif ++ glDrawArrays(cache->primitiveType, 0, cache->vertexCount); ++ ++ } else { ++ // printf(" - Marking path as cachable...\n"); ++ // Tag it for later so that if the same path is drawn twice, it is assumed to be static and thus cachable ++ // ### Remove before release... ++ static bool do_vectorpath_cache = qgetenv("QT_OPENGL_NO_PATH_CACHE").isEmpty(); ++ if (do_vectorpath_cache) ++ path.makeCacheable(); ++ vertexCoordinateArray.clear(); ++ vertexCoordinateArray.addPath(path, inverseScale, false); ++ prepareForDraw(currentBrush->isOpaque()); ++ drawVertexArrays(vertexCoordinateArray, GL_TRIANGLE_FAN); ++ } ++ + } else { + // The path is too complicated & needs the stencil technique + vertexCoordinateArray.clear(); +@@ -1756,7 +1853,8 @@ bool QGL2PaintEngineEx::begin(QPaintDevice *pdev) + d->device->beginPaint(); + + #if !defined(QT_OPENGL_ES_2) +- bool success = qt_resolve_version_2_0_functions(d->ctx); ++ bool success = qt_resolve_version_2_0_functions(d->ctx) ++ && qt_resolve_buffer_extensions(d->ctx); + Q_ASSERT(success); + Q_UNUSED(success); + #endif +@@ -1817,6 +1915,13 @@ bool QGL2PaintEngineEx::end() + delete d->shaderManager; + d->shaderManager = 0; + ++#ifdef QT_OPENGL_CACHE_AS_VBOS ++ if (!d->unusedVBOSToClean.isEmpty()) { ++ glDeleteBuffers(d->unusedVBOSToClean.size(), d->unusedVBOSToClean.constData()); ++ d->unusedVBOSToClean.clear(); ++ } ++#endif ++ + return false; + } + +diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h +index b554f6d..0084476 100644 +--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h ++++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h +@@ -221,6 +221,7 @@ public: + void restoreDepthRangeForRenderText(); + + static QGLEngineShaderManager* shaderManagerForEngine(QGL2PaintEngineEx *engine) { return engine->d_func()->shaderManager; } ++ static QGL2PaintEngineExPrivate *getData(QGL2PaintEngineEx *engine) { return engine->d_func(); } + + QGL2PaintEngineEx* q; + QGLPaintDevice* device; +@@ -294,6 +295,9 @@ public: + QScopedPointer<QPixmapFilter> fastBlurFilter; + QScopedPointer<QPixmapFilter> dropShadowFilter; + QScopedPointer<QPixmapFilter> fastDropShadowFilter; ++ ++ QSet<QVectorPath::CacheEntry *> pathCaches; ++ QVector<GLuint> unusedVBOSToClean; + }; + + QT_END_NAMESPACE +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0917-Better-check-for-EGL-extension-strings.patch b/recipes/qt4/qt-4.6.0/0917-Better-check-for-EGL-extension-strings.patch new file mode 100644 index 0000000000..9febe7553e --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0917-Better-check-for-EGL-extension-strings.patch @@ -0,0 +1,34 @@ +From 108ab335537d20bc74aa9115d46cf91243223c4e Mon Sep 17 00:00:00 2001 +From: Rhys Weatherley <rhys.weatherley@nokia.com> +Date: Fri, 4 Dec 2009 17:03:41 +1000 +Subject: [PATCH 0917/1244] Better check for EGL extension strings + +The previous code might have failed if the desired extension name +was a prefix of another name: "EGL_foo" member of "EGL_foo_bar". +This change introduces a more precise check. + +Task-number: QTBUG-6454 +Reviewed-by: Sarah Smith +--- + src/gui/egl/qegl.cpp | 5 ++++- + 1 files changed, 4 insertions(+), 1 deletions(-) + +diff --git a/src/gui/egl/qegl.cpp b/src/gui/egl/qegl.cpp +index cf28dc4..6ee4bfc 100644 +--- a/src/gui/egl/qegl.cpp ++++ b/src/gui/egl/qegl.cpp +@@ -429,7 +429,10 @@ QString QEglContext::extensions() + + bool QEglContext::hasExtension(const char* extensionName) + { +- return extensions().contains(QLatin1String(extensionName)); ++ QList<QByteArray> extensions = ++ QByteArray(reinterpret_cast<const char *> ++ (eglQueryString(QEglContext::defaultDisplay(0), EGL_EXTENSIONS))).split(' '); ++ return extensions.contains(extensionName); + } + + QEglContext *QEglContext::currentContext(QEgl::API api) +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0919-Rebind-window-surface-fbo-after-native-GL-rendering.patch b/recipes/qt4/qt-4.6.0/0919-Rebind-window-surface-fbo-after-native-GL-rendering.patch new file mode 100644 index 0000000000..f3dbdb57e7 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0919-Rebind-window-surface-fbo-after-native-GL-rendering.patch @@ -0,0 +1,95 @@ +From c0b81480b2909b18ac15bdd124a562ae005c2f41 Mon Sep 17 00:00:00 2001 +From: Rhys Weatherley <rhys.weatherley@nokia.com> +Date: Fri, 4 Dec 2009 17:17:00 +1000 +Subject: [PATCH 0919/1244] Rebind window surface fbo after native GL rendering + +If the user called QGLFramebufferObject::bind()/release() during a +beginNativePainting() callout, the release() would reset the context's +fbo to zero, not the actual window surface fbo. + +Task-number: QTBUG-6204 +Reviewed-by: Tom +--- + src/opengl/qgl.cpp | 1 + + src/opengl/qgl_p.h | 1 + + src/opengl/qglframebufferobject.cpp | 4 ++-- + src/opengl/qglpaintdevice.cpp | 10 ++++++++++ + 4 files changed, 14 insertions(+), 2 deletions(-) + +diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp +index 5ada125..94b8aa5 100644 +--- a/src/opengl/qgl.cpp ++++ b/src/opengl/qgl.cpp +@@ -1495,6 +1495,7 @@ void QGLContextPrivate::init(QPaintDevice *dev, const QGLFormat &format) + version_flags_cached = false; + version_flags = QGLFormat::OpenGL_Version_None; + current_fbo = 0; ++ default_fbo = 0; + active_engine = 0; + } + +diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h +index 8e472e5..ab72c9c 100644 +--- a/src/opengl/qgl_p.h ++++ b/src/opengl/qgl_p.h +@@ -328,6 +328,7 @@ public: + GLint max_texture_size; + + GLuint current_fbo; ++ GLuint default_fbo; + QPaintEngine *active_engine; + + static inline QGLContextGroup *contextGroup(const QGLContext *ctx) { return ctx->d_ptr->group; } +diff --git a/src/opengl/qglframebufferobject.cpp b/src/opengl/qglframebufferobject.cpp +index d79283e..d0297c9 100644 +--- a/src/opengl/qglframebufferobject.cpp ++++ b/src/opengl/qglframebufferobject.cpp +@@ -899,8 +899,8 @@ bool QGLFramebufferObject::release() + #endif + + if (current) { +- current->d_ptr->current_fbo = 0; +- glBindFramebuffer(GL_FRAMEBUFFER_EXT, 0); ++ current->d_ptr->current_fbo = current->d_ptr->default_fbo; ++ glBindFramebuffer(GL_FRAMEBUFFER_EXT, current->d_ptr->default_fbo); + } + + return true; +diff --git a/src/opengl/qglpaintdevice.cpp b/src/opengl/qglpaintdevice.cpp +index 2867de5..bcd90a5 100644 +--- a/src/opengl/qglpaintdevice.cpp ++++ b/src/opengl/qglpaintdevice.cpp +@@ -89,6 +89,12 @@ void QGLPaintDevice::beginPaint() + ctx->d_ptr->current_fbo = m_thisFBO; + glBindFramebuffer(GL_FRAMEBUFFER_EXT, m_thisFBO); + } ++ ++ // Set the default fbo for the context to m_thisFBO so that ++ // if some raw GL code between beginNativePainting() and ++ // endNativePainting() calls QGLFramebufferObject::release(), ++ // painting will revert to the window surface's fbo. ++ ctx->d_ptr->default_fbo = m_thisFBO; + } + + void QGLPaintDevice::ensureActiveTarget() +@@ -101,6 +107,8 @@ void QGLPaintDevice::ensureActiveTarget() + ctx->d_ptr->current_fbo = m_thisFBO; + glBindFramebuffer(GL_FRAMEBUFFER_EXT, m_thisFBO); + } ++ ++ ctx->d_ptr->default_fbo = m_thisFBO; + } + + void QGLPaintDevice::endPaint() +@@ -111,6 +119,8 @@ void QGLPaintDevice::endPaint() + ctx->d_ptr->current_fbo = m_previousFBO; + glBindFramebuffer(GL_FRAMEBUFFER_EXT, m_previousFBO); + } ++ ++ ctx->d_ptr->default_fbo = 0; + } + + QGLFormat QGLPaintDevice::format() const +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0943-Fixed-OpenGL-graphicssystem-issues-for-OpenGL-ES-2.0.patch b/recipes/qt4/qt-4.6.0/0943-Fixed-OpenGL-graphicssystem-issues-for-OpenGL-ES-2.0.patch new file mode 100644 index 0000000000..5ef0b28822 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0943-Fixed-OpenGL-graphicssystem-issues-for-OpenGL-ES-2.0.patch @@ -0,0 +1,146 @@ +From 60be72310c0f9469b3201b250b257473184ccf2a Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Samuel=20R=C3=B8dal?= <sroedal@trolltech.com> +Date: Thu, 3 Dec 2009 11:53:31 +0100 +Subject: [PATCH 0943/1244] Fixed OpenGL graphicssystem issues for OpenGL ES 2.0 platforms. + +The format and internal_format parameters to glTexImage2D need to always +match on OpenGL ES 2.0. + +Reviewed-by: Tom Cooksey +--- + src/opengl/qgl_p.h | 3 ++- + src/opengl/qpixmapdata_gl.cpp | 38 ++++++++++++++++++++++++++++++-------- + src/opengl/qwindowsurface_gl.cpp | 9 ++++----- + 3 files changed, 36 insertions(+), 14 deletions(-) + +diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h +index ab72c9c..b2407ba 100644 +--- a/src/opengl/qgl_p.h ++++ b/src/opengl/qgl_p.h +@@ -518,7 +518,8 @@ bool qt_gl_preferGL2Engine(); + + inline GLenum qt_gl_preferredTextureFormat() + { +- return QSysInfo::ByteOrder == QSysInfo::BigEndian ? GL_RGBA : GL_BGRA; ++ return (QGLExtensions::glExtensions & QGLExtensions::BGRATextureFormat) && QSysInfo::ByteOrder == QSysInfo::LittleEndian ++ ? GL_BGRA : GL_RGBA; + } + + inline GLenum qt_gl_preferredTextureTarget() +diff --git a/src/opengl/qpixmapdata_gl.cpp b/src/opengl/qpixmapdata_gl.cpp +index fb55097..ab17789 100644 +--- a/src/opengl/qpixmapdata_gl.cpp ++++ b/src/opengl/qpixmapdata_gl.cpp +@@ -321,25 +321,47 @@ void QGLPixmapData::ensureCreated() const + QGLShareContextScope ctx(qt_gl_share_widget()->context()); + m_ctx = ctx; + +- const GLenum format = qt_gl_preferredTextureFormat(); ++ const GLenum internal_format = m_hasAlpha ? GL_RGBA : GL_RGB; ++#ifdef QT_OPENGL_ES_2 ++ const GLenum external_format = internal_format; ++#else ++ const GLenum external_format = qt_gl_preferredTextureFormat(); ++#endif + const GLenum target = GL_TEXTURE_2D; + + if (!m_texture.id) { + glGenTextures(1, &m_texture.id); + glBindTexture(target, m_texture.id); +- GLenum format = m_hasAlpha ? GL_RGBA : GL_RGB; +- glTexImage2D(target, 0, format, w, h, 0, +- GL_RGBA, GL_UNSIGNED_BYTE, 0); ++ glTexImage2D(target, 0, internal_format, w, h, 0, external_format, GL_UNSIGNED_BYTE, 0); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + } + + if (!m_source.isNull()) { +- const QImage tx = ctx->d_func()->convertToGLFormat(m_source, true, format); ++ if (external_format == GL_RGB) { ++ QImage tx = m_source.convertToFormat(QImage::Format_RGB32); ++ ++ QVector<uchar> pixelData(w * h * 3); ++ uchar *p = &pixelData[0]; ++ QRgb *src = (QRgb *)tx.bits(); ++ ++ for (int i = 0; i < w * h; ++i) { ++ *p++ = qRed(*src); ++ *p++ = qGreen(*src); ++ *p++ = qBlue(*src); ++ ++src; ++ } + +- glBindTexture(target, m_texture.id); +- glTexSubImage2D(target, 0, 0, 0, w, h, format, +- GL_UNSIGNED_BYTE, tx.bits()); ++ glBindTexture(target, m_texture.id); ++ glTexSubImage2D(target, 0, 0, 0, w, h, external_format, ++ GL_UNSIGNED_BYTE, &pixelData[0]); ++ } else { ++ const QImage tx = ctx->d_func()->convertToGLFormat(m_source, true, external_format); ++ ++ glBindTexture(target, m_texture.id); ++ glTexSubImage2D(target, 0, 0, 0, w, h, external_format, ++ GL_UNSIGNED_BYTE, tx.bits()); ++ } + + if (useFramebufferObjects()) + m_source = QImage(); +diff --git a/src/opengl/qwindowsurface_gl.cpp b/src/opengl/qwindowsurface_gl.cpp +index e353f5d..7194f9d 100644 +--- a/src/opengl/qwindowsurface_gl.cpp ++++ b/src/opengl/qwindowsurface_gl.cpp +@@ -493,7 +493,6 @@ void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint & + } + #endif + d_ptr->paintedRegion = QRegion(); +- + context()->swapBuffers(); + } else { + glFlush(); +@@ -688,11 +687,13 @@ void QGLWindowSurface::updateGeometry() { + d_ptr->size = rect.size(); + + if (d_ptr->ctx) { ++#ifndef QT_OPENGL_ES_2 + if (d_ptr->destructive_swap_buffers) { + glBindTexture(target, d_ptr->tex_id); + glTexImage2D(target, 0, GL_RGBA, rect.width(), rect.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, 0); + glBindTexture(target, 0); + } ++#endif + return; + } + +@@ -756,11 +757,7 @@ void QGLWindowSurface::updateGeometry() { + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); +-#ifndef QT_OPENGL_ES + glOrtho(0, d_ptr->pb->width(), d_ptr->pb->height(), 0, -999999, 999999); +-#else +- glOrthof(0, d_ptr->pb->width(), d_ptr->pb->height(), 0, -999999, 999999); +-#endif + + d_ptr->pb->d_ptr->qctx->d_func()->internal_context = true; + return; +@@ -774,6 +771,7 @@ void QGLWindowSurface::updateGeometry() { + + ctx->makeCurrent(); + ++#ifndef QT_OPENGL_ES_2 + if (d_ptr->destructive_swap_buffers) { + glGenTextures(1, &d_ptr->tex_id); + glBindTexture(target, d_ptr->tex_id); +@@ -783,6 +781,7 @@ void QGLWindowSurface::updateGeometry() { + glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glBindTexture(target, 0); + } ++#endif + + qDebug() << "QGLWindowSurface: Using plain widget as window surface" << this;; + d_ptr->ctx = ctx; +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0945-Add-EGL_BUFFER_SIZE-to-QEglProperties-reduceConfigur.patch b/recipes/qt4/qt-4.6.0/0945-Add-EGL_BUFFER_SIZE-to-QEglProperties-reduceConfigur.patch new file mode 100644 index 0000000000..1afcee62dd --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0945-Add-EGL_BUFFER_SIZE-to-QEglProperties-reduceConfigur.patch @@ -0,0 +1,33 @@ +From 92e9fcc25c62870c383c8558d576abc509a8c683 Mon Sep 17 00:00:00 2001 +From: Tom Cooksey <thomas.cooksey@nokia.com> +Date: Fri, 4 Dec 2009 19:42:07 +0100 +Subject: [PATCH 0945/1244] Add EGL_BUFFER_SIZE to QEglProperties::reduceConfiguration() + +Reviewed-by: Trustme +--- + src/gui/egl/qeglproperties.cpp | 9 +++++++++ + 1 files changed, 9 insertions(+), 0 deletions(-) + +diff --git a/src/gui/egl/qeglproperties.cpp b/src/gui/egl/qeglproperties.cpp +index 2d37edb..4d4410a 100644 +--- a/src/gui/egl/qeglproperties.cpp ++++ b/src/gui/egl/qeglproperties.cpp +@@ -229,6 +229,15 @@ void QEglProperties::setRenderableType(QEgl::API api) + // reductions in complexity are possible. + bool QEglProperties::reduceConfiguration() + { ++ // EGL chooses configs with the highest color depth over ++ // those with smaller (but faster) lower color depths. One ++ // way around this is to set EGL_BUFFER_SIZE to 16, which ++ // trumps the others. Of course, there may not be a 16-bit ++ // config avaliable, so it's the first restraint we remove. ++ if (value(EGL_BUFFER_SIZE) == 16) { ++ removeValue(EGL_BUFFER_SIZE); ++ return true; ++ } + if (removeValue(EGL_SAMPLE_BUFFERS)) { + removeValue(EGL_SAMPLES); + return true; +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0946-Fix-WA_TranslucentBackground-for-QGLWidgets-on-X11-E.patch b/recipes/qt4/qt-4.6.0/0946-Fix-WA_TranslucentBackground-for-QGLWidgets-on-X11-E.patch new file mode 100644 index 0000000000..6cdd9d13da --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0946-Fix-WA_TranslucentBackground-for-QGLWidgets-on-X11-E.patch @@ -0,0 +1,180 @@ +From 76c415b586991d978d46a888fb40c631513407dc Mon Sep 17 00:00:00 2001 +From: Tom Cooksey <thomas.cooksey@nokia.com> +Date: Fri, 4 Dec 2009 20:48:53 +0100 +Subject: [PATCH 0946/1244] Fix WA_TranslucentBackground for QGLWidgets on X11/EGL + +Also check for existing QEglContext before creating a new one and +leaking a context. + +Reviewed-by: TrustMe +--- + src/opengl/qgl_x11egl.cpp | 118 ++++++++++++++++++++++++++++----------------- + 1 files changed, 73 insertions(+), 45 deletions(-) + +diff --git a/src/opengl/qgl_x11egl.cpp b/src/opengl/qgl_x11egl.cpp +index b51c239..a868e83 100644 +--- a/src/opengl/qgl_x11egl.cpp ++++ b/src/opengl/qgl_x11egl.cpp +@@ -63,6 +63,7 @@ void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device) + props.setPixelFormat(static_cast<QImage *>(device)->format()); + } + ++// Chooses the EGL config and creates the EGL context + bool QGLContext::chooseContext(const QGLContext* shareContext) + { + Q_D(QGLContext); +@@ -73,56 +74,74 @@ bool QGLContext::chooseContext(const QGLContext* shareContext) + int devType = device()->devType(); + + // Get the display and initialize it. +- d->eglContext = new QEglContext(); +- d->eglContext->setApi(QEgl::OpenGL); +- if (!d->eglContext->openDisplay(device())) { +- delete d->eglContext; +- d->eglContext = 0; +- return false; +- } ++ if (d->eglContext == 0) { ++ d->eglContext = new QEglContext(); ++ d->eglContext->setApi(QEgl::OpenGL); ++ if (!d->eglContext->openDisplay(device())) { ++ delete d->eglContext; ++ d->eglContext = 0; ++ return false; ++ } + +- // Construct the configuration we need for this surface. +- QEglProperties configProps; +- qt_egl_set_format(configProps, devType, d->glFormat); +- qt_egl_add_platform_config(configProps, device()); +- configProps.setRenderableType(QEgl::OpenGL); +- +- QEgl::PixelFormatMatch matchType = QEgl::BestPixelFormat; +- if (device()->depth() == 16) { +- configProps.setValue(EGL_RED_SIZE, 5); +- configProps.setValue(EGL_GREEN_SIZE, 6); +- configProps.setValue(EGL_BLUE_SIZE, 5); +- configProps.setValue(EGL_ALPHA_SIZE, 0); +- matchType = QEgl::ExactPixelFormat; +- } +- configProps.setRenderableType(QEgl::OpenGL); ++ // Construct the configuration we need for this surface. ++ QEglProperties configProps; ++ qt_egl_set_format(configProps, devType, d->glFormat); ++ qt_egl_add_platform_config(configProps, device()); ++ configProps.setRenderableType(QEgl::OpenGL); ++ ++#if We_have_an_EGL_library_which_bothers_to_check_EGL_BUFFER_SIZE ++ if (device()->depth() == 16 && configProps.value(EGL_ALPHA_SIZE) <= 0) { ++ qDebug("Setting EGL_BUFFER_SIZE to 16"); ++ configProps.setValue(EGL_BUFFER_SIZE, 16); ++ configProps.setValue(EGL_ALPHA_SIZE, 0); ++ } + +- // Search for a matching configuration, reducing the complexity +- // each time until we get something that matches. +- if (!d->eglContext->chooseConfig(configProps, matchType)) { +- delete d->eglContext; +- d->eglContext = 0; +- return false; +- } ++ if (!d->eglContext->chooseConfig(configProps, QEgl::BestPixelFormat)) { ++ delete d->eglContext; ++ d->eglContext = 0; ++ return false; ++ } ++#else ++ QEgl::PixelFormatMatch matchType = QEgl::BestPixelFormat; ++ if ((device()->depth() == 16) && configProps.value(EGL_ALPHA_SIZE) == 0) { ++ configProps.setValue(EGL_RED_SIZE, 5); ++ configProps.setValue(EGL_GREEN_SIZE, 6); ++ configProps.setValue(EGL_BLUE_SIZE, 5); ++ configProps.setValue(EGL_ALPHA_SIZE, 0); ++ matchType = QEgl::ExactPixelFormat; ++ } + +- // Inform the higher layers about the actual format properties. +- qt_egl_update_format(*(d->eglContext), d->glFormat); ++ // Search for a matching configuration, reducing the complexity ++ // each time until we get something that matches. ++ if (!d->eglContext->chooseConfig(configProps, matchType)) { ++ delete d->eglContext; ++ d->eglContext = 0; ++ return false; ++ } ++#endif + +- // Create a new context for the configuration. +- if (!d->eglContext->createContext +- (shareContext ? shareContext->d_func()->eglContext : 0)) { +- delete d->eglContext; +- d->eglContext = 0; +- return false; +- } +- d->sharing = d->eglContext->isSharing(); +- if (d->sharing && shareContext) +- const_cast<QGLContext *>(shareContext)->d_func()->sharing = true; ++// qDebug("QGLContext::chooseContext() - using EGL config %d:", d->eglContext->config()); ++// qDebug() << QEglProperties(d->eglContext->config()).toString(); ++ ++ // Create a new context for the configuration. ++ if (!d->eglContext->createContext ++ (shareContext ? shareContext->d_func()->eglContext : 0)) { ++ delete d->eglContext; ++ d->eglContext = 0; ++ return false; ++ } ++ d->sharing = d->eglContext->isSharing(); ++ if (d->sharing && shareContext) ++ const_cast<QGLContext *>(shareContext)->d_func()->sharing = true; + + #if defined(EGL_VERSION_1_1) +- if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget) +- eglSwapInterval(d->eglContext->display(), d->glFormat.swapInterval()); ++ if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget) ++ eglSwapInterval(d->eglContext->display(), d->glFormat.swapInterval()); + #endif ++ } ++ ++ // Inform the higher layers about the actual format properties. ++ qt_egl_update_format(*(d->eglContext), d->glFormat); + + return true; + } +@@ -160,6 +179,9 @@ bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig conf + + memset(&vi, 0, sizeof(XVisualInfo)); + ++ EGLint eglConfigColorSize; ++ eglGetConfigAttrib(display, config, EGL_BUFFER_SIZE, &eglConfigColorSize); ++ + // Check to see if EGL is suggesting an appropriate visual id: + EGLint nativeVisualId; + eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &nativeVisualId); +@@ -189,8 +211,12 @@ bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig conf + } else + #endif + { +-// qDebug("Using opaque X Visual ID (%d) provided by EGL", (int)vi.visualid); +- vi = *chosenVisualInfo; ++ if (eglConfigColorSize == chosenVisualInfo->depth) { ++// qDebug("Using opaque X Visual ID (%d) provided by EGL", (int)vi.visualid); ++ vi = *chosenVisualInfo; ++ } else ++ qWarning("Warning: EGL suggested using X visual ID %d (%d bpp) for config %d (%d bpp), but the depths do not match!", ++ nativeVisualId, chosenVisualInfo->depth, (int)config, eglConfigColorSize); + } + XFree(chosenVisualInfo); + } +@@ -300,6 +326,8 @@ void QGLWidget::setContext(QGLContext *context, const QGLContext* shareContext, + + bool createFailed = false; + if (!d->glcx->isValid()) { ++ // Create the QGLContext here, which in turn chooses the EGL config ++ // and creates the EGL context: + if (!d->glcx->create(shareContext ? shareContext : oldcx)) + createFailed = true; + } +-- +1.6.5 + 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 + diff --git a/recipes/qt4/qt-4.6.0/0951-Detect-GL2-paint-engine-based-on-fragment-shaders-no.patch b/recipes/qt4/qt-4.6.0/0951-Detect-GL2-paint-engine-based-on-fragment-shaders-no.patch new file mode 100644 index 0000000000..787868e7c5 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0951-Detect-GL2-paint-engine-based-on-fragment-shaders-no.patch @@ -0,0 +1,68 @@ +From 8fea31ca0ab98ef6fed7bb2d87d97f4f425b2078 Mon Sep 17 00:00:00 2001 +From: Rhys Weatherley <rhys.weatherley@nokia.com> +Date: Mon, 7 Dec 2009 10:07:13 +1000 +Subject: [PATCH 0951/1244] Detect GL2 paint engine based on fragment shaders, not programs + +The auto-detect logic was looking for fragment programs to check +for OpenGL2 support. It should have been looking for fragment shaders. + +Task-number: QTBUG-5638 +Reviewed-by: Sarah Smith +--- + src/opengl/qgl.cpp | 7 +++++-- + src/opengl/qgl_p.h | 3 ++- + 2 files changed, 7 insertions(+), 3 deletions(-) + +diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp +index b376901..1ff102f 100644 +--- a/src/opengl/qgl.cpp ++++ b/src/opengl/qgl.cpp +@@ -173,12 +173,12 @@ public: + #else + // We can't do this in the constructor for this object because it + // needs to be called *before* the QApplication constructor. +- // Also check for the FragmentProgram extension in conjunction with ++ // Also check for the FragmentShader extension in conjunction with + // the 2.0 version flag, to cover the case where we export the display + // from an old GL 1.1 server to a GL 2.x client. In that case we can't + // use GL 2.0. + if ((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0) +- && (QGLExtensions::glExtensions & QGLExtensions::FragmentProgram) ++ && (QGLExtensions::glExtensions & QGLExtensions::FragmentShader) + && qgetenv("QT_GL_USE_OPENGL1ENGINE").isEmpty()) + engineType = QPaintEngine::OpenGL2; + else +@@ -4832,6 +4832,8 @@ void QGLExtensions::init_extensions() + glExtensions |= PVRTCTextureCompression; + if (extensions.contains("GL_ARB_fragment_program")) + glExtensions |= FragmentProgram; ++ if (extensions.contains("GL_ARB_fragment_shader")) ++ glExtensions |= FragmentShader; + if (extensions.contains("GL_ARB_texture_mirrored_repeat")) + glExtensions |= MirroredRepeat; + if (extensions.contains("GL_EXT_framebuffer_object")) +@@ -4849,6 +4851,7 @@ void QGLExtensions::init_extensions() + #if defined(QT_OPENGL_ES_2) + glExtensions |= FramebufferObject; + glExtensions |= GenerateMipmap; ++ glExtensions |= FragmentShader; + #endif + #if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL) + if (extensions.contains("GL_OES_framebuffer_object")) +diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h +index 0f785a5..179d69a 100644 +--- a/src/opengl/qgl_p.h ++++ b/src/opengl/qgl_p.h +@@ -383,7 +383,8 @@ public: + BGRATextureFormat = 0x00004000, + DDSTextureCompression = 0x00008000, + ETC1TextureCompression = 0x00010000, +- PVRTCTextureCompression = 0x00020000 ++ PVRTCTextureCompression = 0x00020000, ++ FragmentShader = 0x00040000 + }; + Q_DECLARE_FLAGS(Extensions, Extension) + +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0971-Fix-GL_BGRA-formats-under-OpenGL-ES-systems.patch b/recipes/qt4/qt-4.6.0/0971-Fix-GL_BGRA-formats-under-OpenGL-ES-systems.patch new file mode 100644 index 0000000000..37ac6f20c4 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0971-Fix-GL_BGRA-formats-under-OpenGL-ES-systems.patch @@ -0,0 +1,40 @@ +From 05d4b4c72a5089885c1515833e34177607c2c511 Mon Sep 17 00:00:00 2001 +From: Rhys Weatherley <rhys.weatherley@nokia.com> +Date: Tue, 8 Dec 2009 11:02:46 +1000 +Subject: [PATCH 0971/1244] Fix GL_BGRA formats under OpenGL/ES systems + +OpenGL/ES requires that the internal and external formats be the +same when calling glTexImage2D(). This caused problems with +devices that had the GL_EXT_bgra extension. + +This change makes the formats the same just before the upload and +also makes sure that the pixel type is GL_UNSIGNED_BYTE when +GL_BGRA is used. No change for desktop systems. + +Reviewed-by: Donald Carr +--- + src/opengl/qgl.cpp | 8 ++++++++ + 1 files changed, 8 insertions(+), 0 deletions(-) + +diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp +index 1ff102f..967ba48 100644 +--- a/src/opengl/qgl.cpp ++++ b/src/opengl/qgl.cpp +@@ -2234,6 +2234,14 @@ QGLTexture* QGLContextPrivate::bindTexture(const QImage &image, GLenum target, G + } + } + } ++#ifdef QT_OPENGL_ES ++ // OpenGL/ES requires that the internal and external formats be identical. ++ // This is typically used to convert GL_RGBA into GL_BGRA. ++ // Also, we need to use GL_UNSIGNED_BYTE when the format is GL_BGRA. ++ internalFormat = externalFormat; ++ if (pixel_type == GL_UNSIGNED_INT_8_8_8_8_REV) ++ pixel_type = GL_UNSIGNED_BYTE; ++#endif + #ifdef QGL_BIND_TEXTURE_DEBUG + printf(" - uploading, image.format=%d, externalFormat=0x%x, internalFormat=0x%x, pixel_type=0x%x\n", + img.format(), externalFormat, internalFormat, pixel_type); +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0991-QGtkStyle-support-for-the-inner-border-property-in-G.patch b/recipes/qt4/qt-4.6.0/0991-QGtkStyle-support-for-the-inner-border-property-in-G.patch new file mode 100644 index 0000000000..ee812f71f1 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0991-QGtkStyle-support-for-the-inner-border-property-in-G.patch @@ -0,0 +1,92 @@ +From f3c37838ab149a8a570b7f1df987705815ae45c0 Mon Sep 17 00:00:00 2001 +From: Robert Griebl <rgriebl@trolltech.com> +Date: Tue, 8 Dec 2009 17:10:57 +0100 +Subject: [PATCH 0991/1244] QGtkStyle: support for the inner-border property in GtkButtons + +This additional padding was not taken into account up to now. It didn't +matter for desktop themes, but Maemo5 uses a large (8pix) padding that can +not be ignored. + +Reviewed-by: jbache +--- + src/gui/styles/qgtkstyle.cpp | 16 ++++++++++++++++ + src/gui/styles/qgtkstyle_p.cpp | 2 ++ + src/gui/styles/qgtkstyle_p.h | 2 ++ + 3 files changed, 20 insertions(+), 0 deletions(-) + +diff --git a/src/gui/styles/qgtkstyle.cpp b/src/gui/styles/qgtkstyle.cpp +index afa3325..097a2b5 100644 +--- a/src/gui/styles/qgtkstyle.cpp ++++ b/src/gui/styles/qgtkstyle.cpp +@@ -3375,12 +3375,28 @@ QIcon QGtkStyle::standardIconImplementation(StandardPixmap standardIcon, + /*! \reimp */ + QRect QGtkStyle::subElementRect(SubElement element, const QStyleOption *option, const QWidget *widget) const + { ++ Q_D(const QGtkStyle); ++ + QRect r = QCleanlooksStyle::subElementRect(element, option, widget); + switch (element) { + case SE_ProgressBarLabel: + case SE_ProgressBarContents: + case SE_ProgressBarGroove: + return option->rect; ++ case SE_PushButtonContents: ++ if (!d->gtk_check_version(2, 10, 0)) { ++ GtkWidget *gtkButton = d->gtkWidget(QLS("GtkButton")); ++ GtkBorder *border = 0; ++ d->gtk_widget_style_get(gtkButton, "inner-border", &border, NULL); ++ if (border) { ++ r = option->rect.adjusted(border->left, border->top, -border->right, -border->top); ++ d->gtk_border_free(border); ++ } else { ++ r = option->rect.adjusted(1, 1, -1, -1); ++ } ++ r = visualRect(option->direction, option->rect, r); ++ } ++ break; + default: + break; + } +diff --git a/src/gui/styles/qgtkstyle_p.cpp b/src/gui/styles/qgtkstyle_p.cpp +index 22dfc62..a644a5b 100644 +--- a/src/gui/styles/qgtkstyle_p.cpp ++++ b/src/gui/styles/qgtkstyle_p.cpp +@@ -158,6 +158,7 @@ Ptr_gtk_window_get_type QGtkStylePrivate::gtk_window_get_type = 0; + Ptr_gtk_widget_get_type QGtkStylePrivate::gtk_widget_get_type = 0; + Ptr_gtk_rc_get_style_by_paths QGtkStylePrivate::gtk_rc_get_style_by_paths = 0; + Ptr_gtk_check_version QGtkStylePrivate::gtk_check_version = 0; ++Ptr_gtk_border_free QGtkStylePrivate::gtk_border_free = 0; + + Ptr_pango_font_description_get_size QGtkStylePrivate::pango_font_description_get_size = 0; + Ptr_pango_font_description_get_weight QGtkStylePrivate::pango_font_description_get_weight = 0; +@@ -416,6 +417,7 @@ void QGtkStylePrivate::resolveGtk() const + gtk_widget_get_type =(Ptr_gtk_widget_get_type)libgtk.resolve("gtk_widget_get_type"); + gtk_rc_get_style_by_paths =(Ptr_gtk_rc_get_style_by_paths)libgtk.resolve("gtk_rc_get_style_by_paths"); + gtk_check_version =(Ptr_gtk_check_version)libgtk.resolve("gtk_check_version"); ++ gtk_border_free =(Ptr_gtk_border_free)libgtk.resolve("gtk_border_free"); + pango_font_description_get_size = (Ptr_pango_font_description_get_size)libgtk.resolve("pango_font_description_get_size"); + pango_font_description_get_weight = (Ptr_pango_font_description_get_weight)libgtk.resolve("pango_font_description_get_weight"); + pango_font_description_get_family = (Ptr_pango_font_description_get_family)libgtk.resolve("pango_font_description_get_family"); +diff --git a/src/gui/styles/qgtkstyle_p.h b/src/gui/styles/qgtkstyle_p.h +index f6ab8a3..c27308f 100644 +--- a/src/gui/styles/qgtkstyle_p.h ++++ b/src/gui/styles/qgtkstyle_p.h +@@ -176,6 +176,7 @@ typedef GtkWidget* (*Ptr_gtk_file_chooser_dialog_new)(const gchar *title, + typedef void (*Ptr_gtk_file_chooser_set_current_name) (GtkFileChooser *, const gchar *); + typedef gboolean (*Ptr_gtk_file_chooser_set_filename) (GtkFileChooser *chooser, const gchar *name); + typedef gint (*Ptr_gtk_dialog_run) (GtkDialog*); ++typedef void (*Ptr_gtk_border_free)(GtkBorder *); + + typedef guchar* (*Ptr_gdk_pixbuf_get_pixels) (const GdkPixbuf *pixbuf); + typedef int (*Ptr_gdk_pixbuf_get_width) (const GdkPixbuf *pixbuf); +@@ -371,6 +372,7 @@ public: + static Ptr_gtk_widget_get_type gtk_widget_get_type; + static Ptr_gtk_rc_get_style_by_paths gtk_rc_get_style_by_paths; + static Ptr_gtk_check_version gtk_check_version; ++ static Ptr_gtk_border_free gtk_border_free; + + static Ptr_pango_font_description_get_size pango_font_description_get_size; + static Ptr_pango_font_description_get_weight pango_font_description_get_weight; +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0992-Make-sure-a-context-is-current-when-loading-compress.patch b/recipes/qt4/qt-4.6.0/0992-Make-sure-a-context-is-current-when-loading-compress.patch new file mode 100644 index 0000000000..301fba29fd --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0992-Make-sure-a-context-is-current-when-loading-compress.patch @@ -0,0 +1,33 @@ +From 51297287f1be5c31337203cbf5a0e3eae6047a88 Mon Sep 17 00:00:00 2001 +From: Rhys Weatherley <rhys.weatherley@nokia.com> +Date: Wed, 9 Dec 2009 08:46:37 +1000 +Subject: [PATCH 0992/1244] Make sure a context is current when loading compressed textures. + +Reviewed-by: trustme +--- + src/opengl/qpixmapdata_gl.cpp | 2 ++ + 1 files changed, 2 insertions(+), 0 deletions(-) + +diff --git a/src/opengl/qpixmapdata_gl.cpp b/src/opengl/qpixmapdata_gl.cpp +index 0299cea..4e1d50d 100644 +--- a/src/opengl/qpixmapdata_gl.cpp ++++ b/src/opengl/qpixmapdata_gl.cpp +@@ -424,6 +424,7 @@ bool QGLPixmapData::fromFile(const QString &filename, const char *format, + resize(0, 0); + data = file.readAll(); + file.close(); ++ QGLShareContextScope ctx(qt_gl_share_widget()->context()); + QSize size = m_texture.bindCompressedTexture + (data.constData(), data.size(), format); + if (!size.isEmpty()) { +@@ -449,6 +450,7 @@ bool QGLPixmapData::fromData(const uchar *buffer, uint len, const char *format, + const char *buf = reinterpret_cast<const char *>(buffer); + if (m_texture.canBindCompressedTexture(buf, int(len), format, &alpha)) { + resize(0, 0); ++ QGLShareContextScope ctx(qt_gl_share_widget()->context()); + QSize size = m_texture.bindCompressedTexture(buf, int(len), format); + if (!size.isEmpty()) { + w = size.width(); +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0993-Fix-upside-down-PVR-compressed-textures.patch b/recipes/qt4/qt-4.6.0/0993-Fix-upside-down-PVR-compressed-textures.patch new file mode 100644 index 0000000000..70aeb7bbf0 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0993-Fix-upside-down-PVR-compressed-textures.patch @@ -0,0 +1,36 @@ +From 62fac41edfff5e42e4c3308376cb08e5d9a10afe Mon Sep 17 00:00:00 2001 +From: Rhys Weatherley <rhys.weatherley@nokia.com> +Date: Wed, 9 Dec 2009 09:10:11 +1000 +Subject: [PATCH 0993/1244] Fix upside down PVR compressed textures. + +The "vertical flip" flag in the PVR format is the inverse of the +"inverted y" state that we use in Qt. + +Reviewed-by: trustme +--- + src/opengl/qgl.cpp | 7 ++++--- + 1 files changed, 4 insertions(+), 3 deletions(-) + +diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp +index 967ba48..8003a29 100644 +--- a/src/opengl/qgl.cpp ++++ b/src/opengl/qgl.cpp +@@ -5363,11 +5363,12 @@ QSize QGLTexture::bindCompressedTexturePVR(const char *buf, int len) + // Restore the default pixel alignment for later texture uploads. + glPixelStorei(GL_UNPACK_ALIGNMENT, 4); + +- // Set the invert flag for the texture. ++ // Set the invert flag for the texture. The "vertical flip" ++ // flag in PVR is the opposite sense to our sense of inversion. + if ((pvrHeader->flags & PVR_VERTICAL_FLIP) != 0) +- options |= QGLContext::InvertedYBindOption; +- else + options &= ~QGLContext::InvertedYBindOption; ++ else ++ options |= QGLContext::InvertedYBindOption; + + return QSize(pvrHeader->width, pvrHeader->height); + } +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0996-Export-QGLShareRegister-because-qgl_share_reg-is-exp.patch b/recipes/qt4/qt-4.6.0/0996-Export-QGLShareRegister-because-qgl_share_reg-is-exp.patch new file mode 100644 index 0000000000..52303d9ed8 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0996-Export-QGLShareRegister-because-qgl_share_reg-is-exp.patch @@ -0,0 +1,26 @@ +From f59908d4a6edcd333a156d4c94ddbd9b30f7e810 Mon Sep 17 00:00:00 2001 +From: Rhys Weatherley <rhys.weatherley@nokia.com> +Date: Wed, 9 Dec 2009 11:06:30 +1000 +Subject: [PATCH 0996/1244] Export QGLShareRegister because qgl_share_reg() is exported + +Reviewed-by: trustme +--- + src/opengl/qgl_p.h | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h +index 179d69a..615fb60 100644 +--- a/src/opengl/qgl_p.h ++++ b/src/opengl/qgl_p.h +@@ -397,7 +397,7 @@ public: + Q_DECLARE_OPERATORS_FOR_FLAGS(QGLExtensions::Extensions) + + +-class Q_AUTOTEST_EXPORT QGLShareRegister ++class Q_OPENGL_EXPORT QGLShareRegister + { + public: + QGLShareRegister() {} +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0998-Set-stacking-class-for-stays-on-top-windows-in-DFB.patch b/recipes/qt4/qt-4.6.0/0998-Set-stacking-class-for-stays-on-top-windows-in-DFB.patch new file mode 100644 index 0000000000..b8687949e0 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0998-Set-stacking-class-for-stays-on-top-windows-in-DFB.patch @@ -0,0 +1,39 @@ +From 472c13edc85a6c7efef1e3b904333d0c9a5f9da6 Mon Sep 17 00:00:00 2001 +From: Anders Bakken <anders.bakken@nokia.com> +Date: Thu, 3 Dec 2009 08:55:20 -0800 +Subject: [PATCH 0998/1244] Set stacking class for stays-on-top windows in DFB + +For better compatibility with non-QWS DirectFB apps running in the same +session we should set the stacking class of Windows that have the +StaysOnTop flag set. This corresponds nicely to DWSC_UPPER. + +Reviewed-by: Jervey Kong <jervey.kong@nokia.com> +--- + .../gfxdrivers/directfb/qdirectfbwindowsurface.cpp | 4 +++- + 1 files changed, 3 insertions(+), 1 deletions(-) + +diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.cpp +index 021d52e..b79418a 100644 +--- a/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.cpp ++++ b/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.cpp +@@ -128,7 +128,6 @@ IDirectFBWindow *QDirectFBWindowSurface::directFBWindow() const + return (dfbWindow ? dfbWindow : (sibling ? sibling->dfbWindow : 0)); + } + +- + void QDirectFBWindowSurface::createWindow(const QRect &rect) + { + IDirectFBDisplayLayer *layer = screen->dfbDisplayLayer(); +@@ -169,6 +168,9 @@ void QDirectFBWindowSurface::createWindow(const QRect &rect) + DirectFBErrorFatal("QDirectFBWindowSurface::createWindow", result); + + if (window()) { ++ if (window()->windowFlags() & Qt::WindowStaysOnTopHint) { ++ dfbWindow->SetStackingClass(dfbWindow, DWSC_UPPER); ++ } + DFBWindowID winid; + result = dfbWindow->GetID(dfbWindow, &winid); + if (result != DFB_OK) { +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/0999-Enable-customizing-of-DirectFB-layer-to-use.patch b/recipes/qt4/qt-4.6.0/0999-Enable-customizing-of-DirectFB-layer-to-use.patch new file mode 100644 index 0000000000..5dcc670845 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/0999-Enable-customizing-of-DirectFB-layer-to-use.patch @@ -0,0 +1,41 @@ +From 941c6637a83f765c028f40973bb7bcca0ecbafb5 Mon Sep 17 00:00:00 2001 +From: Anders Bakken <anders.bakken@nokia.com> +Date: Tue, 8 Dec 2009 08:19:58 -0800 +Subject: [PATCH 0999/1244] Enable customizing of DirectFB layer to use + +This patch enables you to use a different layer for Qt apps by +specifying: + +E.g. + +QWS_DISPLAY=directfb:layerid=2 + +Reviewed-by: Donald Carr <donald.carr@nokia.com> +--- + .../gfxdrivers/directfb/qdirectfbscreen.cpp | 7 +++++-- + 1 files changed, 5 insertions(+), 2 deletions(-) + +diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp +index 4cb0184..d3fe183 100644 +--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp ++++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp +@@ -1259,11 +1259,14 @@ bool QDirectFBScreen::connect(const QString &displaySpec) + setIntOption(displayArgs, QLatin1String("height"), &h); + + #ifndef QT_NO_DIRECTFB_LAYER +- result = d_ptr->dfb->GetDisplayLayer(d_ptr->dfb, DLID_PRIMARY, ++ int layerId = DLID_PRIMARY; ++ setIntOption(displayArgs, QLatin1String("layerid"), &layerId); ++ ++ result = d_ptr->dfb->GetDisplayLayer(d_ptr->dfb, static_cast<DFBDisplayLayerID>(layerId), + &d_ptr->dfbLayer); + if (result != DFB_OK) { + DirectFBError("QDirectFBScreen::connect: " +- "Unable to get primary display layer!", result); ++ "Unable to get display layer!", result); + return false; + } + result = d_ptr->dfbLayer->GetScreen(d_ptr->dfbLayer, &d_ptr->dfbScreen); +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1008-GLES-2-should-not-use-a-multisampled-format-by-defau.patch b/recipes/qt4/qt-4.6.0/1008-GLES-2-should-not-use-a-multisampled-format-by-defau.patch new file mode 100644 index 0000000000..f504599638 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1008-GLES-2-should-not-use-a-multisampled-format-by-defau.patch @@ -0,0 +1,46 @@ +From c4d66e27ea69b84bf280209fc72239132924930d Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Trond=20Kjern=C3=A5sen?= <trond@trolltech.com> +Date: Wed, 9 Dec 2009 12:14:58 +0100 +Subject: [PATCH 1008/1244] GLES 2 should *not* use a multisampled format by default. + +This is a platform regression and should never have been there in the +first place. Having this as the default format on embedded devices +may drop the framerates with as much as 30% on selected HW. + +Reviewed-by: Tom Cooksey +--- + src/opengl/qgl.cpp | 3 +-- + src/opengl/qgl_p.h | 3 --- + 2 files changed, 1 insertions(+), 5 deletions(-) + +diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp +index 25285b5..dcf8c00 100644 +--- a/src/opengl/qgl.cpp ++++ b/src/opengl/qgl.cpp +@@ -397,8 +397,7 @@ static inline GLint qgluProject(GLdouble objx, GLdouble objy, GLdouble objz, + \i \link setDirectRendering() Direct rendering:\endlink Enabled. + \i \link setOverlay() Overlay:\endlink Disabled. + \i \link setPlane() Plane:\endlink 0 (i.e., normal plane). +- \i \link setSampleBuffers() Multisample buffers:\endlink Enabled on +- OpenGL/ES 2.0, disabled on other platforms. ++ \i \link setSampleBuffers() Multisample buffers:\endlink Disabled. + \endlist + */ + +diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h +index 615fb60..8a0b31f 100644 +--- a/src/opengl/qgl_p.h ++++ b/src/opengl/qgl_p.h +@@ -133,9 +133,6 @@ public: + : ref(1) + { + opts = QGL::DoubleBuffer | QGL::DepthBuffer | QGL::Rgba | QGL::DirectRendering | QGL::StencilBuffer; +-#if defined(QT_OPENGL_ES_2) +- opts |= QGL::SampleBuffers; +-#endif + pln = 0; + depthSize = accumSize = stencilSize = redSize = greenSize = blueSize = alphaSize = -1; + numSamples = -1; +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1115-Fix-QGLWidgets-created-with-an-alpha-channel-on-X11-.patch b/recipes/qt4/qt-4.6.0/1115-Fix-QGLWidgets-created-with-an-alpha-channel-on-X11-.patch new file mode 100644 index 0000000000..6b3ad4e860 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1115-Fix-QGLWidgets-created-with-an-alpha-channel-on-X11-.patch @@ -0,0 +1,30 @@ +From 6b29466ed7b5328ee61c1751bd4efb72f70946d3 Mon Sep 17 00:00:00 2001 +From: Tom Cooksey <thomas.cooksey@nokia.com> +Date: Tue, 15 Dec 2009 17:26:37 +0100 +Subject: [PATCH 1115/1244] Fix QGLWidgets created with an alpha channel on X11/EGL + +If the QGLWidget's QGLFormat says it should have an alpha +channel, try to find an ARGB Visual. + +Reviewed-By: Trond +Task-number: QT-2602 +--- + src/opengl/qgl_x11egl.cpp | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/src/opengl/qgl_x11egl.cpp b/src/opengl/qgl_x11egl.cpp +index b10e7e9..19026b3 100644 +--- a/src/opengl/qgl_x11egl.cpp ++++ b/src/opengl/qgl_x11egl.cpp +@@ -336,7 +336,7 @@ void QGLWidget::setContext(QGLContext *context, const QGLContext* shareContext, + // If the application has set WA_TranslucentBackground and not explicitly set + // the alpha buffer size to zero, modify the format so it have an alpha channel + QGLFormat& fmt = d->glcx->d_func()->glFormat; +- const bool tryArgbVisual = testAttribute(Qt::WA_TranslucentBackground); ++ const bool tryArgbVisual = testAttribute(Qt::WA_TranslucentBackground) || fmt.alpha(); + if (tryArgbVisual && fmt.alphaBufferSize() == -1) + fmt.setAlphaBufferSize(1); + +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1118-Fix-EGL-surface-leaks-when-re-parenting-QGLWidget-on.patch b/recipes/qt4/qt-4.6.0/1118-Fix-EGL-surface-leaks-when-re-parenting-QGLWidget-on.patch new file mode 100644 index 0000000000..b0a2147020 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1118-Fix-EGL-surface-leaks-when-re-parenting-QGLWidget-on.patch @@ -0,0 +1,116 @@ +From 9f3ae04fae52cd37855b135a0f2f519d1c5b969c Mon Sep 17 00:00:00 2001 +From: Tom Cooksey <thomas.cooksey@nokia.com> +Date: Tue, 15 Dec 2009 18:11:05 +0100 +Subject: [PATCH 1118/1244] Fix EGL surface leaks when re-parenting QGLWidget on X11/EGL + +When a QGLWidget is re-parented, it's native X11 window usually +gets destroyed and re-created. This also happens when you set a +window attribute or flag. On EGL, we must destroy the surface +for the window before destroying the window itself, otherwise +we can leak the surface. This also fixes lots of BadDrawable +errors when running the autotests (which were due to surface +leaks!). + +Reviewed-By: TrustMe +--- + src/opengl/qgl.cpp | 5 +++++ + src/opengl/qgl.h | 1 + + src/opengl/qgl_egl.cpp | 34 +++++++++++++++++++++------------- + src/opengl/qgl_p.h | 1 + + 4 files changed, 28 insertions(+), 13 deletions(-) + +diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp +index 2a3ce54..32534aa 100644 +--- a/src/opengl/qgl.cpp ++++ b/src/opengl/qgl.cpp +@@ -3810,6 +3810,11 @@ bool QGLWidget::event(QEvent *e) + } + + #if defined(QT_OPENGL_ES) ++ // A re-parent is likely to destroy the X11 window and re-create it. It is important ++ // that we free the EGL surface _before_ the winID changes - otherwise we can leak. ++ if (e->type() == QEvent::ParentAboutToChange) ++ d->glcx->d_func()->destroyEglSurfaceForDevice(); ++ + if ((e->type() == QEvent::ParentChange) || (e->type() == QEvent::WindowStateChange)) { + // The window may have been re-created during re-parent or state change - if so, the EGL + // surface will need to be re-created. +diff --git a/src/opengl/qgl.h b/src/opengl/qgl.h +index 079953f..2076c46 100644 +--- a/src/opengl/qgl.h ++++ b/src/opengl/qgl.h +@@ -546,6 +546,7 @@ private: + friend class QGLPixelBuffer; + friend class QGLPixelBufferPrivate; + friend class QGLContext; ++ friend class QGLContextPrivate; + friend class QGLOverlayWidget; + friend class QOpenGLPaintEngine; + friend class QGLPaintDevice; +diff --git a/src/opengl/qgl_egl.cpp b/src/opengl/qgl_egl.cpp +index fbf0349..839e8eb 100644 +--- a/src/opengl/qgl_egl.cpp ++++ b/src/opengl/qgl_egl.cpp +@@ -142,19 +142,7 @@ void QGLContext::reset() + d->cleanup(); + doneCurrent(); + if (d->eglContext) { +- if (d->eglSurface != EGL_NO_SURFACE) { +-#ifdef Q_WS_X11 +- // Make sure we don't call eglDestroySurface on a surface which +- // was created for a different winId: +- if (d->paintDevice->devType() == QInternal::Widget) { +- QGLWidget* w = static_cast<QGLWidget*>(d->paintDevice); +- +- if (w->d_func()->eglSurfaceWindowId == w->winId()) +- eglDestroySurface(d->eglContext->display(), d->eglSurface); +- } else +-#endif +- eglDestroySurface(d->eglContext->display(), d->eglSurface); +- } ++ d->destroyEglSurfaceForDevice(); + delete d->eglContext; + } + d->eglContext = 0; +@@ -198,6 +186,26 @@ void QGLContext::swapBuffers() const + d->eglContext->swapBuffers(d->eglSurface); + } + ++void QGLContextPrivate::destroyEglSurfaceForDevice() ++{ ++ if (eglSurface != EGL_NO_SURFACE) { ++#ifdef Q_WS_X11 ++ // Make sure we don't call eglDestroySurface on a surface which ++ // was created for a different winId: ++ if (paintDevice->devType() == QInternal::Widget) { ++ QGLWidget* w = static_cast<QGLWidget*>(paintDevice); ++ ++ if (w->d_func()->eglSurfaceWindowId == w->winId()) ++ eglDestroySurface(eglContext->display(), eglSurface); ++ else ++ qWarning("WARNING: Potential EGL surface leak!"); ++ } else ++#endif ++ eglDestroySurface(eglContext->display(), eglSurface); ++ eglSurface = EGL_NO_SURFACE; ++ } ++} ++ + void QGLWidget::setMouseTracking(bool enable) + { + QWidget::setMouseTracking(enable); +diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h +index 11770d3..99c0f33 100644 +--- a/src/opengl/qgl_p.h ++++ b/src/opengl/qgl_p.h +@@ -288,6 +288,7 @@ public: + #if defined(QT_OPENGL_ES) + QEglContext *eglContext; + EGLSurface eglSurface; ++ void destroyEglSurfaceForDevice(); + #elif defined(Q_WS_X11) || defined(Q_WS_MAC) + void* cx; + #endif +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1136-Disable-depth-testing-during-the-2D-QGLWidget-render.patch b/recipes/qt4/qt-4.6.0/1136-Disable-depth-testing-during-the-2D-QGLWidget-render.patch new file mode 100644 index 0000000000..30abab6468 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1136-Disable-depth-testing-during-the-2D-QGLWidget-render.patch @@ -0,0 +1,54 @@ +From 7371d787d9b2667132c0caadb9964189b1d8c9fc Mon Sep 17 00:00:00 2001 +From: Rhys Weatherley <rhys.weatherley@nokia.com> +Date: Thu, 17 Dec 2009 11:17:11 +1000 +Subject: [PATCH 1136/1244] Disable depth testing during the 2D QGLWidget::renderText() + +Also document the depth testing conditions for the 2D and 3D +versions of the function. + +Task-number: QTBUG-5041 +Reviewed-by: Daniel Pope +--- + src/opengl/qgl.cpp | 12 ++++++++++++ + 1 files changed, 12 insertions(+), 0 deletions(-) + +diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp +index 32534aa..466e851 100644 +--- a/src/opengl/qgl.cpp ++++ b/src/opengl/qgl.cpp +@@ -4302,6 +4302,7 @@ static void qt_save_gl_state() + glDisable(GL_CULL_FACE); + glDisable(GL_LIGHTING); + glDisable(GL_STENCIL_TEST); ++ glDisable(GL_DEPTH_TEST); + glEnable(GL_BLEND); + glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); + } +@@ -4355,6 +4356,10 @@ static void qt_gl_draw_text(QPainter *p, int x, int y, const QString &str, + \note This function clears the stencil buffer. + + \note This function is not supported on OpenGL/ES systems. ++ ++ \note This function temporarily disables depth-testing when the ++ text is drawn. ++ + \l{Overpainting Example}{Overpaint} with QPainter::drawText() instead. + */ + +@@ -4445,6 +4450,13 @@ void QGLWidget::renderText(int x, int y, const QString &str, const QFont &font, + have the labels move with the model as it is rotated etc. + + \note This function is not supported on OpenGL/ES systems. ++ ++ \note If depth testing is enabled before this function is called, ++ then the drawn text will be depth-tested against the models that ++ have already been drawn in the scene. Use \c{glDisable(GL_DEPTH_TEST)} ++ before calling this function to annotate the models without ++ depth-testing the text. ++ + \l{Overpainting Example}{Overpaint} with QPainter::drawText() instead. + */ + void QGLWidget::renderText(double x, double y, double z, const QString &str, const QFont &font, int) +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1149-GL2Engine-Don-t-mark-brush-as-dirty-if-it-hasn-t-cha.patch b/recipes/qt4/qt-4.6.0/1149-GL2Engine-Don-t-mark-brush-as-dirty-if-it-hasn-t-cha.patch new file mode 100644 index 0000000000..49cd32bc07 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1149-GL2Engine-Don-t-mark-brush-as-dirty-if-it-hasn-t-cha.patch @@ -0,0 +1,307 @@ +From ca30ced65ead8e81dfcb25178f4bfb6244487356 Mon Sep 17 00:00:00 2001 +From: Tom Cooksey <thomas.cooksey@nokia.com> +Date: Thu, 17 Dec 2009 14:34:16 +0100 +Subject: [PATCH 1149/1244] GL2Engine: Don't mark brush as dirty if it hasn't changed +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +If the same brush is used over and over again, this gives a +huge performance boost (measured to be 25% faster on desktop +and 73% faster on SGX). + +Reviewed-By: Samuel Rødal +--- + .../gl2paintengineex/qglengineshadermanager.cpp | 1 + + .../gl2paintengineex/qpaintengineex_opengl2.cpp | 69 +++++++++++--------- + .../gl2paintengineex/qpaintengineex_opengl2_p.h | 5 +- + 3 files changed, 41 insertions(+), 34 deletions(-) + +diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp +index 8a8f483..1187c2d 100644 +--- a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp ++++ b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp +@@ -406,6 +406,7 @@ void QGLEngineShaderManager::setDirty() + + void QGLEngineShaderManager::setSrcPixelType(Qt::BrushStyle style) + { ++ Q_ASSERT(style != Qt::NoBrush); + if (srcPixelType == PixelSrcType(style)) + return; + +diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp +index fb9bcb4..8ca2fd4 100644 +--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp ++++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp +@@ -386,19 +386,25 @@ inline QColor qt_premultiplyColor(QColor c, GLfloat opacity) + } + + +-void QGL2PaintEngineExPrivate::setBrush(const QBrush* brush) ++void QGL2PaintEngineExPrivate::setBrush(const QBrush& brush) + { ++ Q_ASSERT(brush.style() != Qt::NoBrush); ++ ++ if (qbrush_fast_equals(currentBrush, brush)) ++ return; ++ + currentBrush = brush; ++ + brushTextureDirty = true; + brushUniformsDirty = true; +- if (currentBrush->style() == Qt::TexturePattern +- && qHasPixmapTexture(*brush) && brush->texture().isQBitmap()) ++ if (currentBrush.style() == Qt::TexturePattern ++ && qHasPixmapTexture(brush) && brush.texture().isQBitmap()) + { + shaderManager->setSrcPixelType(QGLEngineShaderManager::TextureSrcWithPattern); + } else { +- shaderManager->setSrcPixelType(currentBrush->style()); ++ shaderManager->setSrcPixelType(currentBrush.style()); + } +- shaderManager->optimiseForBrushTransform(currentBrush->transform()); ++ shaderManager->optimiseForBrushTransform(currentBrush.transform()); + } + + +@@ -420,7 +426,7 @@ void QGL2PaintEngineExPrivate::updateBrushTexture() + { + Q_Q(QGL2PaintEngineEx); + // qDebug("QGL2PaintEngineExPrivate::updateBrushTexture()"); +- Qt::BrushStyle style = currentBrush->style(); ++ Qt::BrushStyle style = currentBrush.style(); + + if ( (style >= Qt::Dense1Pattern) && (style <= Qt::DiagCrossPattern) ) { + // Get the image data for the pattern +@@ -433,7 +439,7 @@ void QGL2PaintEngineExPrivate::updateBrushTexture() + else if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) { + // Gradiant brush: All the gradiants use the same texture + +- const QGradient* g = currentBrush->gradient(); ++ const QGradient* g = currentBrush.gradient(); + + // We apply global opacity in the fragment shaders, so we always pass 1.0 + // for opacity to the cache. +@@ -450,7 +456,7 @@ void QGL2PaintEngineExPrivate::updateBrushTexture() + updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE, q->state()->renderHints & QPainter::SmoothPixmapTransform); + } + else if (style == Qt::TexturePattern) { +- const QPixmap& texPixmap = currentBrush->texture(); ++ const QPixmap& texPixmap = currentBrush.texture(); + + glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT); + QGLTexture *tex = ctx->d_func()->bindTexture(texPixmap, GL_TEXTURE_2D, GL_RGBA, QGLContext::InternalBindOption); +@@ -464,15 +470,15 @@ void QGL2PaintEngineExPrivate::updateBrushTexture() + void QGL2PaintEngineExPrivate::updateBrushUniforms() + { + // qDebug("QGL2PaintEngineExPrivate::updateBrushUniforms()"); +- Qt::BrushStyle style = currentBrush->style(); ++ Qt::BrushStyle style = currentBrush.style(); + + if (style == Qt::NoBrush) + return; + +- QTransform brushQTransform = currentBrush->transform(); ++ QTransform brushQTransform = currentBrush.transform(); + + if (style == Qt::SolidPattern) { +- QColor col = qt_premultiplyColor(currentBrush->color(), (GLfloat)q->state()->opacity); ++ QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity); + shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::FragmentColor), col); + } + else { +@@ -480,7 +486,7 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() + QPointF translationPoint; + + if (style <= Qt::DiagCrossPattern) { +- QColor col = qt_premultiplyColor(currentBrush->color(), (GLfloat)q->state()->opacity); ++ QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity); + + shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col); + +@@ -488,7 +494,7 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() + shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize); + } + else if (style == Qt::LinearGradientPattern) { +- const QLinearGradient *g = static_cast<const QLinearGradient *>(currentBrush->gradient()); ++ const QLinearGradient *g = static_cast<const QLinearGradient *>(currentBrush.gradient()); + + QPointF realStart = g->start(); + QPointF realFinal = g->finalStop(); +@@ -508,7 +514,7 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() + shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize); + } + else if (style == Qt::ConicalGradientPattern) { +- const QConicalGradient *g = static_cast<const QConicalGradient *>(currentBrush->gradient()); ++ const QConicalGradient *g = static_cast<const QConicalGradient *>(currentBrush.gradient()); + translationPoint = g->center(); + + GLfloat angle = -(g->angle() * 2 * Q_PI) / 360.0; +@@ -519,7 +525,7 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() + shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize); + } + else if (style == Qt::RadialGradientPattern) { +- const QRadialGradient *g = static_cast<const QRadialGradient *>(currentBrush->gradient()); ++ const QRadialGradient *g = static_cast<const QRadialGradient *>(currentBrush.gradient()); + QPointF realCenter = g->center(); + QPointF realFocal = g->focalPoint(); + qreal realRadius = g->radius(); +@@ -537,10 +543,10 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() + shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize); + } + else if (style == Qt::TexturePattern) { +- const QPixmap& texPixmap = currentBrush->texture(); ++ const QPixmap& texPixmap = currentBrush.texture(); + +- if (qHasPixmapTexture(*currentBrush) && currentBrush->texture().isQBitmap()) { +- QColor col = qt_premultiplyColor(currentBrush->color(), (GLfloat)q->state()->opacity); ++ if (qHasPixmapTexture(currentBrush) && currentBrush.texture().isQBitmap()) { ++ QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity); + shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col); + } + +@@ -561,7 +567,7 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms() + QTransform gl_to_qt(1, 0, 0, -1, 0, height); + QTransform inv_matrix; + if (style == Qt::TexturePattern && textureInvertedY == -1) +- inv_matrix = gl_to_qt * (QTransform(1, 0, 0, -1, 0, currentBrush->texture().height()) * brushQTransform * matrix).inverted() * translate; ++ inv_matrix = gl_to_qt * (QTransform(1, 0, 0, -1, 0, currentBrush.texture().height()) * brushQTransform * matrix).inverted() * translate; + else + inv_matrix = gl_to_qt * (brushQTransform * matrix).inverted() * translate; + +@@ -866,7 +872,7 @@ void QGL2PaintEngineExPrivate::fill(const QVectorPath& path) + // Check to see if there's any hints + if (path.shape() == QVectorPath::RectangleHint) { + QGLRect rect(points[0].x(), points[0].y(), points[2].x(), points[2].y()); +- prepareForDraw(currentBrush->isOpaque()); ++ prepareForDraw(currentBrush.isOpaque()); + composite(rect); + } else if (path.isConvex()) { + +@@ -914,7 +920,7 @@ void QGL2PaintEngineExPrivate::fill(const QVectorPath& path) + #endif + } + +- prepareForDraw(currentBrush->isOpaque()); ++ prepareForDraw(currentBrush.isOpaque()); + glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR); + #ifdef QT_OPENGL_CACHE_AS_VBOS + glBindBuffer(GL_ARRAY_BUFFER, cache->vbo); +@@ -933,7 +939,7 @@ void QGL2PaintEngineExPrivate::fill(const QVectorPath& path) + path.makeCacheable(); + vertexCoordinateArray.clear(); + vertexCoordinateArray.addPath(path, inverseScale, false); +- prepareForDraw(currentBrush->isOpaque()); ++ prepareForDraw(currentBrush.isOpaque()); + drawVertexArrays(vertexCoordinateArray, GL_TRIANGLE_FAN); + } + +@@ -958,7 +964,7 @@ void QGL2PaintEngineExPrivate::fill(const QVectorPath& path) + glStencilFunc(GL_NOTEQUAL, 0, GL_STENCIL_HIGH_BIT); + } + +- prepareForDraw(currentBrush->isOpaque()); ++ prepareForDraw(currentBrush.isOpaque()); + + if (inRenderText) + prepareDepthRangeForRenderText(); +@@ -1155,10 +1161,10 @@ bool QGL2PaintEngineExPrivate::prepareForDraw(bool srcPixelsAreOpaque) + : QGLEngineShaderManager::NoOpacity; + if (stateHasOpacity && (mode != ImageDrawingMode)) { + // Using a brush +- bool brushIsPattern = (currentBrush->style() >= Qt::Dense1Pattern) && +- (currentBrush->style() <= Qt::DiagCrossPattern); ++ bool brushIsPattern = (currentBrush.style() >= Qt::Dense1Pattern) && ++ (currentBrush.style() <= Qt::DiagCrossPattern); + +- if ((currentBrush->style() == Qt::SolidPattern) || brushIsPattern) ++ if ((currentBrush.style() == Qt::SolidPattern) || brushIsPattern) + opacityMode = QGLEngineShaderManager::NoOpacity; // Global opacity handled by srcPixel shader + } + } +@@ -1286,7 +1292,7 @@ void QGL2PaintEngineEx::fill(const QVectorPath &path, const QBrush &brush) + d->matrixDirty = true; + } + +- d->setBrush(&brush); ++ d->setBrush(brush); + d->fill(path); + + if (doOffset) { +@@ -1325,7 +1331,7 @@ void QGL2PaintEngineEx::stroke(const QVectorPath &path, const QPen &pen) + } + + bool opaque = penBrush.isOpaque() && s->opacity > 0.99; +- d->setBrush(&penBrush); ++ d->setBrush(penBrush); + d->transferMode(BrushDrawingMode); + + // updateMatrix() is responsible for setting the inverse scale on +@@ -1604,7 +1610,7 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(const QPointF &p, QFontEngineGly + glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, textureCoordinateArray.data()); + + QBrush pensBrush = q->state()->pen.brush(); +- setBrush(&pensBrush); ++ setBrush(pensBrush); + + if (inRenderText) + prepareDepthRangeForRenderText(); +@@ -1649,7 +1655,7 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(const QPointF &p, QFontEngineGly + q->state()->opacity = 1; + opacityUniformDirty = true; + pensBrush = Qt::white; +- setBrush(&pensBrush); ++ setBrush(pensBrush); + } + + compositionModeDirty = false; // I can handle this myself, thank you very much +@@ -1670,7 +1676,7 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(const QPointF &p, QFontEngineGly + q->state()->opacity = oldOpacity; + opacityUniformDirty = true; + pensBrush = q->state()->pen.brush(); +- setBrush(&pensBrush); ++ setBrush(pensBrush); + } + + compositionModeDirty = false; +@@ -1815,6 +1821,7 @@ bool QGL2PaintEngineEx::begin(QPaintDevice *pdev) + d->opacityUniformDirty = true; + d->needsSync = true; + d->use_system_clip = !systemClip().isEmpty(); ++ d->currentBrush = QBrush(); + + d->dirtyStencilRegion = QRect(0, 0, d->width, d->height); + d->stencilClean = true; +diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h +index 77ca3a8..33ce24d 100644 +--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h ++++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h +@@ -171,7 +171,6 @@ public: + q(q_ptr), + width(0), height(0), + ctx(0), +- currentBrush(0), + inverseScale(1), + shaderManager(0), + inRenderText(false) +@@ -185,7 +184,7 @@ public: + void updateCompositionMode(); + void updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform, GLuint id = -1); + +- void setBrush(const QBrush* brush); ++ void setBrush(const QBrush& brush); + + void transferMode(EngineMode newMode); + void resetGLState(); +@@ -244,7 +243,7 @@ public: + QRect currentScissorBounds; + uint maxClip; + +- const QBrush* currentBrush; // May not be the state's brush! ++ QBrush currentBrush; // May not be the state's brush! + + GLfloat inverseScale; + +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1157-Align-GL_RGB-lines-on-a-4-byte-boundary-when-uploadi.patch b/recipes/qt4/qt-4.6.0/1157-Align-GL_RGB-lines-on-a-4-byte-boundary-when-uploadi.patch new file mode 100644 index 0000000000..4029d0dc33 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1157-Align-GL_RGB-lines-on-a-4-byte-boundary-when-uploadi.patch @@ -0,0 +1,45 @@ +From 87777f7c0f4c3e338d23d2c3d368a8a484a35a6e Mon Sep 17 00:00:00 2001 +From: Rhys Weatherley <rhys.weatherley@nokia.com> +Date: Fri, 18 Dec 2009 15:01:07 +1000 +Subject: [PATCH 1157/1244] Align GL_RGB lines on a 4-byte boundary when uploading pixmap textures + +Previous code was aligning lines on a 3-byte boundary. + +Task-number: QTBUG-6902 +Reviewed-by: Julian de Bhal +--- + src/opengl/qpixmapdata_gl.cpp | 15 ++------------- + 1 files changed, 2 insertions(+), 13 deletions(-) + +diff --git a/src/opengl/qpixmapdata_gl.cpp b/src/opengl/qpixmapdata_gl.cpp +index 4e1d50d..92c990b 100644 +--- a/src/opengl/qpixmapdata_gl.cpp ++++ b/src/opengl/qpixmapdata_gl.cpp +@@ -341,22 +341,11 @@ void QGLPixmapData::ensureCreated() const + + if (!m_source.isNull()) { + if (external_format == GL_RGB) { +- QImage tx = m_source.convertToFormat(QImage::Format_RGB32); +- +- QVector<uchar> pixelData(w * h * 3); +- uchar *p = &pixelData[0]; +- QRgb *src = (QRgb *)tx.bits(); +- +- for (int i = 0; i < w * h; ++i) { +- *p++ = qRed(*src); +- *p++ = qGreen(*src); +- *p++ = qBlue(*src); +- ++src; +- } ++ const QImage tx = m_source.convertToFormat(QImage::Format_RGB888); + + glBindTexture(target, m_texture.id); + glTexSubImage2D(target, 0, 0, 0, w, h, external_format, +- GL_UNSIGNED_BYTE, &pixelData[0]); ++ GL_UNSIGNED_BYTE, tx.bits()); + } else { + const QImage tx = ctx->d_func()->convertToGLFormat(m_source, true, external_format); + +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1165-NEON-configure-detection-and-initial-blend-function-.patch b/recipes/qt4/qt-4.6.0/1165-NEON-configure-detection-and-initial-blend-function-.patch new file mode 100644 index 0000000000..9d2ca87654 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1165-NEON-configure-detection-and-initial-blend-function-.patch @@ -0,0 +1,593 @@ + +Adds new NEON configure test and -no-neon configure option. NEON +implementations can also be turned off by setting the QT_NO_NEON +environment variable. + +Performance improvements (in frames per second): +- Blending ARGB32 on RGB32/ARGB32, mostly opaque: 71 % +- Blending ARGB32 on RGB32/ARGB32, no opaque pixels: 108 % +- Blending ARGB32 on RGB32/ARGB32, with 0.5 opacity: 158 % +- Blending RGB32 on RGB32/ARGB32, with 0.5 opacity: 189 % + +Task-number: QTBUG-6684 +Reviewed-by: Gunnar Sletta +Reviewed-by: Paul Olav Tvete +--- + config.tests/unix/neon/neon.cpp | 51 +++++++ + config.tests/unix/neon/neon.pro | 2 + + configure | 22 +++- + src/gui/painting/painting.pri | 7 + + src/gui/painting/qblendfunctions.cpp | 2 +- + src/gui/painting/qdrawhelper.cpp | 16 ++- + src/gui/painting/qdrawhelper_neon.cpp | 260 +++++++++++++++++++++++++++++++++ + src/gui/painting/qdrawhelper_neon_p.h | 76 ++++++++++ + 8 files changed, 432 insertions(+), 4 deletions(-) + create mode 100644 config.tests/unix/neon/neon.cpp + create mode 100644 config.tests/unix/neon/neon.pro + create mode 100644 src/gui/painting/qdrawhelper_neon.cpp + create mode 100644 src/gui/painting/qdrawhelper_neon_p.h + +diff --git a/config.tests/unix/neon/neon.cpp b/config.tests/unix/neon/neon.cpp +new file mode 100644 +index 0000000..c31a9fd +--- /dev/null ++++ b/config.tests/unix/neon/neon.cpp +@@ -0,0 +1,51 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). ++** All rights reserved. ++** Contact: Nokia Corporation (qt-info@nokia.com) ++** ++** This file is part of the config.tests of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** No Commercial Usage ++** This file contains pre-release code and may not be distributed. ++** You may use this file in accordance with the terms and conditions ++** contained in the Technology Preview License Agreement accompanying ++** this package. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Nokia gives you certain additional ++** rights. These rights are described in the Nokia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** If you have questions regarding the use of this file, please contact ++** Nokia at qt-info@nokia.com. ++** ++** ++** ++** ++** ++** ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#include <arm_neon.h> ++ ++int main(int, char**) ++{ ++ int32x4_t null = vdupq_n_s32(0x0); ++ ++ int result; ++ vst1q_lane_s32(&result, null, 0); ++ return result; ++} +diff --git a/config.tests/unix/neon/neon.pro b/config.tests/unix/neon/neon.pro +new file mode 100644 +index 0000000..de20c4e +--- /dev/null ++++ b/config.tests/unix/neon/neon.pro +@@ -0,0 +1,2 @@ ++SOURCES = neon.cpp ++CONFIG -= x11 qt +diff --git a/configure b/configure +index 2114863..22e6bd4 100755 +--- a/configure ++++ b/configure +@@ -745,6 +745,7 @@ CFG_HOST_ENDIAN=auto + CFG_DOUBLEFORMAT=auto + CFG_ARMFPA=auto + CFG_IWMMXT=no ++CFG_NEON=auto + CFG_CLOCK_GETTIME=auto + CFG_CLOCK_MONOTONIC=auto + CFG_MREMAP=auto +@@ -1604,6 +1605,13 @@ while [ "$#" -gt 0 ]; do + iwmmxt) + CFG_IWMMXT="yes" + ;; ++ neon) ++ if [ "$VAL" = "no" ]; then ++ CFG_NEON="$VAL" ++ else ++ UNKNOWN_OPT=yes ++ fi ++ ;; + reduce-relocations) + if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then + CFG_REDUCE_RELOCATIONS="$VAL" +@@ -3889,6 +3897,7 @@ Qt for Embedded Linux only: + -iwmmxt ............ Compile using the iWMMXt instruction set + (available on some XScale CPUs). + ++ -no-neon ........... Do not compile with use of NEON instructions. + EOF + fi + +@@ -4509,6 +4518,15 @@ if [ "$CFG_IWMMXT" = "yes" ]; then + fi + fi + ++# detect neon support ++if ([ "${CFG_ARCH}" = "arm" ] || [ "${CFG_ARCH}" = "armv6" ]) && [ "${CFG_NEON}" = "auto" ]; then ++ if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/neon "neon" $L_FLAGS $I_FLAGS $l_FLAGS "-mfpu=neon"; then ++ CFG_NEON=yes ++ else ++ CFG_NEON=no ++ fi ++fi ++ + # detect zlib + if [ "$CFG_ZLIB" = "no" ]; then + # Note: Qt no longer support builds without zlib +@@ -6124,6 +6142,7 @@ fi + [ "$CFG_SSE" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse" + [ "$CFG_SSE2" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG sse2" + [ "$CFG_IWMMXT" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG iwmmxt" ++[ "$CFG_NEON" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG neon" + [ "$PLATFORM_MAC" = "yes" ] && QMAKE_CONFIG="$QMAKE_CONFIG $CFG_MAC_ARCHS" + if [ "$CFG_IPV6" = "yes" ]; then + QT_CONFIG="$QT_CONFIG ipv6" +@@ -7416,8 +7435,9 @@ echo "Declarative module .. $CFG_DECLARATIVE" + echo "STL support ......... $CFG_STL" + echo "PCH support ......... $CFG_PRECOMPILE" + echo "MMX/3DNOW/SSE/SSE2.. ${CFG_MMX}/${CFG_3DNOW}/${CFG_SSE}/${CFG_SSE2}" +-if [ "${CFG_ARCH}" = "arm" ]; then ++if [ "${CFG_ARCH}" = "arm" ] || [ "${CFG_ARCH}" = "armv6" ]; then + echo "iWMMXt support ...... ${CFG_IWMMXT}" ++ echo "NEON support ........ ${CFG_NEON}" + fi + [ "${PLATFORM_QWS}" != "yes" ] && echo "Graphics System ..... $CFG_GRAPHICS_SYSTEM" + echo "IPv6 support ........ $CFG_IPV6" +diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri +index 628a109..0b1e79a 100644 +--- a/src/gui/painting/painting.pri ++++ b/src/gui/painting/painting.pri +@@ -379,6 +379,13 @@ symbian { + QMAKE_CXXFLAGS.ARMCC *= -O3 + } + ++neon { ++ DEFINES += QT_HAVE_NEON ++ HEADERS += painting/qdrawhelper_neon_p.h ++ SOURCES += painting/qdrawhelper_neon.cpp ++ ++} ++ + contains(QT_CONFIG, zlib) { + INCLUDEPATH += ../3rdparty/zlib + } else:!contains(QT_CONFIG, no-zlib) { +diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp +index 1d15dac..81d1515 100644 +--- a/src/gui/painting/qblendfunctions.cpp ++++ b/src/gui/painting/qblendfunctions.cpp +@@ -605,7 +605,7 @@ static void qt_blend_argb32_on_argb32(uchar *destPixels, int dbpl, + } + + +-static void qt_blend_rgb32_on_rgb32(uchar *destPixels, int dbpl, ++void qt_blend_rgb32_on_rgb32(uchar *destPixels, int dbpl, + const uchar *srcPixels, int sbpl, + int w, int h, + int const_alpha) +diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp +index 23236ec..84cf5cc 100644 +--- a/src/gui/painting/qdrawhelper.cpp ++++ b/src/gui/painting/qdrawhelper.cpp +@@ -44,6 +44,7 @@ + #include <private/qpainter_p.h> + #include <private/qdrawhelper_x86_p.h> + #include <private/qdrawhelper_armv6_p.h> ++#include <private/qdrawhelper_neon_p.h> + #include <private/qmath_p.h> + #include <qmath.h> + +@@ -7725,7 +7726,8 @@ enum CPUFeatures { + SSE = 0x10, + SSE2 = 0x20, + CMOV = 0x40, +- IWMMXT = 0x80 ++ IWMMXT = 0x80, ++ NEON = 0x100 + }; + + static uint detectCPUFeatures() +@@ -7751,6 +7753,9 @@ static uint detectCPUFeatures() + // runtime detection only available when running as a previlegied process + static const bool doIWMMXT = !qgetenv("QT_NO_IWMMXT").toInt(); + return doIWMMXT ? IWMMXT : 0; ++#elif defined(QT_HAVE_NEON) ++ static const bool doNEON = !qgetenv("QT_NO_NEON").toInt(); ++ return doNEON ? NEON : 0; + #else + uint features = 0; + #if defined(__x86_64__) || defined(Q_OS_WIN64) +@@ -8122,7 +8127,14 @@ void qInitDrawhelperAsm() + qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_armv6; + qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_armv6; + qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_armv6; +-#endif // Q_CC_RVCT && QT_HAVE_ARMV6 ++#elif defined(QT_HAVE_NEON) ++ if (features & NEON) { ++ qBlendFunctions[QImage::Format_RGB32][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_neon; ++ qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_neon; ++ qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_neon; ++ qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_neon; ++ } ++#endif + + if (functionForModeSolidAsm) { + const int destinationMode = QPainter::CompositionMode_Destination; +diff --git a/src/gui/painting/qdrawhelper_neon.cpp b/src/gui/painting/qdrawhelper_neon.cpp +new file mode 100644 +index 0000000..7fe11bf +--- /dev/null ++++ b/src/gui/painting/qdrawhelper_neon.cpp +@@ -0,0 +1,260 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). ++** All rights reserved. ++** Contact: Nokia Corporation (qt-info@nokia.com) ++** ++** This file is part of the QtGui module of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** No Commercial Usage ++** This file contains pre-release code and may not be distributed. ++** You may use this file in accordance with the terms and conditions ++** contained in the Technology Preview License Agreement accompanying ++** this package. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Nokia gives you certain additional ++** rights. These rights are described in the Nokia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** If you have questions regarding the use of this file, please contact ++** Nokia at qt-info@nokia.com. ++** ++** ++** ++** ++** ++** ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#include <private/qdrawhelper_p.h> ++ ++#ifdef QT_HAVE_NEON ++ ++#include <private/qdrawhelper_neon_p.h> ++#include <arm_neon.h> ++ ++QT_BEGIN_NAMESPACE ++ ++static inline int16x8_t qvdiv_255_s16(int16x8_t x, int16x8_t half) ++{ ++ // result = (x + (x >> 8) + 0x80) >> 8 ++ ++ const int16x8_t temp = vshrq_n_s16(x, 8); // x >> 8 ++ const int16x8_t sum_part = vaddq_s16(x, half); // x + 0x80 ++ const int16x8_t sum = vaddq_s16(temp, sum_part); ++ ++ return vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(sum), 8)); ++} ++ ++static inline int16x8_t qvbyte_mul_s16(int16x8_t x, int16x8_t alpha, int16x8_t half) ++{ ++ // t = qRound(x * alpha / 255.0) ++ ++ const int16x8_t t = vmulq_s16(x, alpha); // t ++ return qvdiv_255_s16(t, half); ++} ++ ++static inline int16x8_t qvinterpolate_pixel_255(int16x8_t x, int16x8_t a, int16x8_t y, int16x8_t b, int16x8_t half) ++{ ++ // t = x * a + y * b ++ ++ const int16x8_t ta = vmulq_s16(x, a); ++ const int16x8_t tb = vmulq_s16(y, b); ++ ++ return qvdiv_255_s16(vaddq_s16(ta, tb), half); ++} ++ ++static inline int16x8_t qvsource_over_s16(int16x8_t src16, int16x8_t dst16, int16x8_t half, int16x8_t full) ++{ ++ const int16x4_t alpha16_high = vdup_lane_s16(vget_high_s16(src16), 3); ++ const int16x4_t alpha16_low = vdup_lane_s16(vget_low_s16(src16), 3); ++ ++ const int16x8_t alpha16 = vsubq_s16(full, vcombine_s16(alpha16_low, alpha16_high)); ++ ++ return vaddq_s16(src16, qvbyte_mul_s16(dst16, alpha16, half)); ++} ++ ++void qt_blend_argb32_on_argb32_neon(uchar *destPixels, int dbpl, ++ const uchar *srcPixels, int sbpl, ++ int w, int h, ++ int const_alpha) ++{ ++ const uint *src = (const uint *) srcPixels; ++ uint *dst = (uint *) destPixels; ++ int16x8_t half = vdupq_n_s16(0x80); ++ int16x8_t full = vdupq_n_s16(0xff); ++ if (const_alpha == 256) { ++ for (int y = 0; y < h; ++y) { ++ int x = 0; ++ for (; x < w-3; x += 4) { ++ int32x4_t src32 = vld1q_s32((int32_t *)&src[x]); ++ if ((src[x] & src[x+1] & src[x+2] & src[x+3]) >= 0xff000000) { ++ // all opaque ++ vst1q_s32((int32_t *)&dst[x], src32); ++ } else if (src[x] | src[x+1] | src[x+2] | src[x+3]) { ++ int32x4_t dst32 = vld1q_s32((int32_t *)&dst[x]); ++ ++ const uint8x16_t src8 = vreinterpretq_u8_s32(src32); ++ const uint8x16_t dst8 = vreinterpretq_u8_s32(dst32); ++ ++ const uint8x8_t src8_low = vget_low_u8(src8); ++ const uint8x8_t dst8_low = vget_low_u8(dst8); ++ ++ const uint8x8_t src8_high = vget_high_u8(src8); ++ const uint8x8_t dst8_high = vget_high_u8(dst8); ++ ++ const int16x8_t src16_low = vreinterpretq_s16_u16(vmovl_u8(src8_low)); ++ const int16x8_t dst16_low = vreinterpretq_s16_u16(vmovl_u8(dst8_low)); ++ ++ const int16x8_t src16_high = vreinterpretq_s16_u16(vmovl_u8(src8_high)); ++ const int16x8_t dst16_high = vreinterpretq_s16_u16(vmovl_u8(dst8_high)); ++ ++ const int16x8_t result16_low = qvsource_over_s16(src16_low, dst16_low, half, full); ++ const int16x8_t result16_high = qvsource_over_s16(src16_high, dst16_high, half, full); ++ ++ const int32x2_t result32_low = vreinterpret_s32_s8(vmovn_s16(result16_low)); ++ const int32x2_t result32_high = vreinterpret_s32_s8(vmovn_s16(result16_high)); ++ ++ vst1q_s32((int32_t *)&dst[x], vcombine_s32(result32_low, result32_high)); ++ } ++ } ++ for (; x<w; ++x) { ++ uint s = src[x]; ++ if (s >= 0xff000000) ++ dst[x] = s; ++ else if (s != 0) ++ dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s)); ++ } ++ dst = (quint32 *)(((uchar *) dst) + dbpl); ++ src = (const quint32 *)(((const uchar *) src) + sbpl); ++ } ++ } else if (const_alpha != 0) { ++ const_alpha = (const_alpha * 255) >> 8; ++ int16x8_t const_alpha16 = vdupq_n_s16(const_alpha); ++ for (int y = 0; y < h; ++y) { ++ int x = 0; ++ for (; x < w-3; x += 4) { ++ if (src[x] | src[x+1] | src[x+2] | src[x+3]) { ++ int32x4_t src32 = vld1q_s32((int32_t *)&src[x]); ++ int32x4_t dst32 = vld1q_s32((int32_t *)&dst[x]); ++ ++ const uint8x16_t src8 = vreinterpretq_u8_s32(src32); ++ const uint8x16_t dst8 = vreinterpretq_u8_s32(dst32); ++ ++ const uint8x8_t src8_low = vget_low_u8(src8); ++ const uint8x8_t dst8_low = vget_low_u8(dst8); ++ ++ const uint8x8_t src8_high = vget_high_u8(src8); ++ const uint8x8_t dst8_high = vget_high_u8(dst8); ++ ++ const int16x8_t src16_low = vreinterpretq_s16_u16(vmovl_u8(src8_low)); ++ const int16x8_t dst16_low = vreinterpretq_s16_u16(vmovl_u8(dst8_low)); ++ ++ const int16x8_t src16_high = vreinterpretq_s16_u16(vmovl_u8(src8_high)); ++ const int16x8_t dst16_high = vreinterpretq_s16_u16(vmovl_u8(dst8_high)); ++ ++ const int16x8_t srcalpha16_low = qvbyte_mul_s16(src16_low, const_alpha16, half); ++ const int16x8_t srcalpha16_high = qvbyte_mul_s16(src16_high, const_alpha16, half); ++ ++ const int16x8_t result16_low = qvsource_over_s16(srcalpha16_low, dst16_low, half, full); ++ const int16x8_t result16_high = qvsource_over_s16(srcalpha16_high, dst16_high, half, full); ++ ++ const int32x2_t result32_low = vreinterpret_s32_s8(vmovn_s16(result16_low)); ++ const int32x2_t result32_high = vreinterpret_s32_s8(vmovn_s16(result16_high)); ++ ++ vst1q_s32((int32_t *)&dst[x], vcombine_s32(result32_low, result32_high)); ++ } ++ } ++ for (; x<w; ++x) { ++ uint s = src[x]; ++ if (s != 0) { ++ s = BYTE_MUL(s, const_alpha); ++ dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s)); ++ } ++ } ++ dst = (quint32 *)(((uchar *) dst) + dbpl); ++ src = (const quint32 *)(((const uchar *) src) + sbpl); ++ } ++ } ++} ++ ++// qblendfunctions.cpp ++void qt_blend_rgb32_on_rgb32(uchar *destPixels, int dbpl, ++ const uchar *srcPixels, int sbpl, ++ int w, int h, ++ int const_alpha); ++ ++void qt_blend_rgb32_on_rgb32_neon(uchar *destPixels, int dbpl, ++ const uchar *srcPixels, int sbpl, ++ int w, int h, ++ int const_alpha) ++{ ++ if (const_alpha != 256) { ++ if (const_alpha != 0) { ++ const uint *src = (const uint *) srcPixels; ++ uint *dst = (uint *) destPixels; ++ int16x8_t half = vdupq_n_s16(0x80); ++ const_alpha = (const_alpha * 255) >> 8; ++ int one_minus_const_alpha = 255 - const_alpha; ++ int16x8_t const_alpha16 = vdupq_n_s16(const_alpha); ++ int16x8_t one_minus_const_alpha16 = vdupq_n_s16(255 - const_alpha); ++ for (int y = 0; y < h; ++y) { ++ int x = 0; ++ for (; x < w-3; x += 4) { ++ int32x4_t src32 = vld1q_s32((int32_t *)&src[x]); ++ int32x4_t dst32 = vld1q_s32((int32_t *)&dst[x]); ++ ++ const uint8x16_t src8 = vreinterpretq_u8_s32(src32); ++ const uint8x16_t dst8 = vreinterpretq_u8_s32(dst32); ++ ++ const uint8x8_t src8_low = vget_low_u8(src8); ++ const uint8x8_t dst8_low = vget_low_u8(dst8); ++ ++ const uint8x8_t src8_high = vget_high_u8(src8); ++ const uint8x8_t dst8_high = vget_high_u8(dst8); ++ ++ const int16x8_t src16_low = vreinterpretq_s16_u16(vmovl_u8(src8_low)); ++ const int16x8_t dst16_low = vreinterpretq_s16_u16(vmovl_u8(dst8_low)); ++ ++ const int16x8_t src16_high = vreinterpretq_s16_u16(vmovl_u8(src8_high)); ++ const int16x8_t dst16_high = vreinterpretq_s16_u16(vmovl_u8(dst8_high)); ++ ++ const int16x8_t result16_low = qvinterpolate_pixel_255(src16_low, const_alpha16, dst16_low, one_minus_const_alpha16, half); ++ const int16x8_t result16_high = qvinterpolate_pixel_255(src16_high, const_alpha16, dst16_high, one_minus_const_alpha16, half); ++ ++ const int32x2_t result32_low = vreinterpret_s32_s8(vmovn_s16(result16_low)); ++ const int32x2_t result32_high = vreinterpret_s32_s8(vmovn_s16(result16_high)); ++ ++ vst1q_s32((int32_t *)&dst[x], vcombine_s32(result32_low, result32_high)); ++ } ++ for (; x<w; ++x) { ++ uint s = src[x]; ++ s = BYTE_MUL(s, const_alpha); ++ dst[x] = INTERPOLATE_PIXEL_255(src[x], const_alpha, dst[x], one_minus_const_alpha); ++ } ++ dst = (quint32 *)(((uchar *) dst) + dbpl); ++ src = (const quint32 *)(((const uchar *) src) + sbpl); ++ } ++ } ++ } else { ++ qt_blend_rgb32_on_rgb32(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha); ++ } ++} ++ ++QT_END_NAMESPACE ++ ++#endif // QT_HAVE_NEON ++ +diff --git a/src/gui/painting/qdrawhelper_neon_p.h b/src/gui/painting/qdrawhelper_neon_p.h +new file mode 100644 +index 0000000..cb9a0d6 +--- /dev/null ++++ b/src/gui/painting/qdrawhelper_neon_p.h +@@ -0,0 +1,76 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). ++** All rights reserved. ++** Contact: Nokia Corporation (qt-info@nokia.com) ++** ++** This file is part of the QtGui module of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** No Commercial Usage ++** This file contains pre-release code and may not be distributed. ++** You may use this file in accordance with the terms and conditions ++** contained in the Technology Preview License Agreement accompanying ++** this package. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Nokia gives you certain additional ++** rights. These rights are described in the Nokia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** If you have questions regarding the use of this file, please contact ++** Nokia at qt-info@nokia.com. ++** ++** ++** ++** ++** ++** ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#ifndef QDRAWHELPER_NEON_P_H ++#define QDRAWHELPER_NEON_P_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 <private/qdrawhelper_p.h> ++ ++QT_BEGIN_NAMESPACE ++ ++#ifdef QT_HAVE_NEON ++ ++void qt_blend_argb32_on_argb32_neon(uchar *destPixels, int dbpl, ++ const uchar *srcPixels, int sbpl, ++ int w, int h, ++ int const_alpha); ++ ++void qt_blend_rgb32_on_rgb32_neon(uchar *destPixels, int dbpl, ++ const uchar *srcPixels, int sbpl, ++ int w, int h, ++ int const_alpha); ++ ++#endif // QT_HAVE_NEON ++ ++QT_END_NAMESPACE ++ ++#endif // QDRAWHELPER_NEON_P_H +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1175-Fix-memory-leak-of-QGLGlyphCoord-objects-in-the-Open.patch b/recipes/qt4/qt-4.6.0/1175-Fix-memory-leak-of-QGLGlyphCoord-objects-in-the-Open.patch new file mode 100644 index 0000000000..7c79b6ba1c --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1175-Fix-memory-leak-of-QGLGlyphCoord-objects-in-the-Open.patch @@ -0,0 +1,60 @@ +From c2dca4c9f1eb360305de5ea520a0b322737dc600 Mon Sep 17 00:00:00 2001 +From: Rhys Weatherley <rhys.weatherley@nokia.com> +Date: Mon, 21 Dec 2009 08:35:43 +1000 +Subject: [PATCH 1175/1244] Fix memory leak of QGLGlyphCoord objects in the OpenGL1 paint engine + +Task-number: QTBUG-6936 +Reviewed-by: Julian de Bhal +--- + src/opengl/qpaintengine_opengl.cpp | 14 +++++++++++--- + 1 files changed, 11 insertions(+), 3 deletions(-) + +diff --git a/src/opengl/qpaintengine_opengl.cpp b/src/opengl/qpaintengine_opengl.cpp +index 4823408..9c15d56 100644 +--- a/src/opengl/qpaintengine_opengl.cpp ++++ b/src/opengl/qpaintengine_opengl.cpp +@@ -4707,6 +4707,12 @@ typedef QHash<QFontEngine*, QGLGlyphHash*> QGLFontGlyphHash; + typedef QHash<quint64, QGLFontTexture*> QGLFontTexHash; + typedef QHash<const QGLContext*, QGLFontGlyphHash*> QGLContextHash; + ++static inline void qt_delete_glyph_hash(QGLGlyphHash *hash) ++{ ++ qDeleteAll(*hash); ++ delete hash; ++} ++ + class QGLGlyphCache : public QObject + { + Q_OBJECT +@@ -4747,7 +4753,7 @@ void QGLGlyphCache::fontEngineDestroyed(QObject *o) + if (font_cache->find(fe) != font_cache->end()) { + ctx = keys.at(i); + QGLGlyphHash *cache = font_cache->take(fe); +- delete cache; ++ qt_delete_glyph_hash(cache); + break; + } + } +@@ -4784,7 +4790,7 @@ void QGLGlyphCache::cleanupContext(const QGLContext *ctx) + QList<QFontEngine *> keys = font_cache->keys(); + for (int i=0; i < keys.size(); ++i) { + QFontEngine *fe = keys.at(i); +- delete font_cache->take(fe); ++ qt_delete_glyph_hash(font_cache->take(fe)); + quint64 font_key = (reinterpret_cast<quint64>(ctx) << 32) | reinterpret_cast<quint64>(fe); + QGLFontTexture *font_tex = qt_font_textures.take(font_key); + if (font_tex) { +@@ -4825,7 +4831,9 @@ void QGLGlyphCache::cleanCache() + QList<const QGLContext *> keys = qt_context_cache.keys(); + for (int i=0; i < keys.size(); ++i) { + QGLFontGlyphHash *font_cache = qt_context_cache.value(keys.at(i)); +- qDeleteAll(*font_cache); ++ QGLFontGlyphHash::Iterator it = font_cache->begin(); ++ for (; it != font_cache->end(); ++it) ++ qt_delete_glyph_hash(it.value()); + font_cache->clear(); + } + qDeleteAll(qt_context_cache); +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1196-Fix-build-with-neon-instructions-enabled-but-not-set.patch b/recipes/qt4/qt-4.6.0/1196-Fix-build-with-neon-instructions-enabled-but-not-set.patch new file mode 100644 index 0000000000..972e4900d5 --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1196-Fix-build-with-neon-instructions-enabled-but-not-set.patch @@ -0,0 +1,29 @@ +From b97aedb9e68c6fe610aff10792c92b2292da0b07 Mon Sep 17 00:00:00 2001 +From: Tom Cooksey <thomas.cooksey@nokia.com> +Date: Tue, 22 Dec 2009 13:37:06 +0100 +Subject: [PATCH 1196/1244] Fix build with neon instructions enabled but not set in mkspec +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Reviewed-By: Samuel Rødal +--- + src/gui/painting/painting.pri | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri +index 0b1e79a..a6cc9c7 100644 +--- a/src/gui/painting/painting.pri ++++ b/src/gui/painting/painting.pri +@@ -383,7 +383,7 @@ neon { + DEFINES += QT_HAVE_NEON + HEADERS += painting/qdrawhelper_neon_p.h + SOURCES += painting/qdrawhelper_neon.cpp +- QMAKE.CXXFLAGS *= -mfpu=neon ++ QMAKE_CXXFLAGS *= -mfpu=neon + } + + contains(QT_CONFIG, zlib) { +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1197-Add-GLfloat-2-2-GLfloat-3-3-uniform-setters-to-QGLSh.patch b/recipes/qt4/qt-4.6.0/1197-Add-GLfloat-2-2-GLfloat-3-3-uniform-setters-to-QGLSh.patch new file mode 100644 index 0000000000..2fe027bb3c --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1197-Add-GLfloat-2-2-GLfloat-3-3-uniform-setters-to-QGLSh.patch @@ -0,0 +1,121 @@ +From 2b4d3391fd922dfc5ac28815bbd5f36c4041b658 Mon Sep 17 00:00:00 2001 +From: Tom Cooksey <thomas.cooksey@nokia.com> +Date: Mon, 21 Dec 2009 16:36:14 +0100 +Subject: [PATCH 1197/1244] Add GLfloat[2][2] & GLfloat[3][3] uniform setters to QGLShaderProgram + +Reviewed-By: Rhys Weatherley +--- + src/opengl/qglshaderprogram.cpp | 67 +++++++++++++++++++++++++++++++++++++++ + src/opengl/qglshaderprogram.h | 4 ++ + 2 files changed, 71 insertions(+), 0 deletions(-) + +diff --git a/src/opengl/qglshaderprogram.cpp b/src/opengl/qglshaderprogram.cpp +index b4191dc..f9737a5 100644 +--- a/src/opengl/qglshaderprogram.cpp ++++ b/src/opengl/qglshaderprogram.cpp +@@ -2275,6 +2275,42 @@ void QGLShaderProgram::setUniformValue(const char *name, const QMatrix4x4& value + \overload + + Sets the uniform variable at \a location in the current context ++ to a 2x2 matrix \a value. The matrix elements must be specified ++ in column-major order. ++ ++ \sa setAttributeValue() ++ \since 4.6.2 ++*/ ++void QGLShaderProgram::setUniformValue(int location, const GLfloat value[2][2]) ++{ ++ Q_D(QGLShaderProgram); ++ Q_UNUSED(d); ++ if (location != -1) ++ glUniformMatrix2fv(location, 1, GL_FALSE, value[0]); ++} ++ ++/*! ++ \overload ++ ++ Sets the uniform variable at \a location in the current context ++ to a 3x3 matrix \a value. The matrix elements must be specified ++ in column-major order. ++ ++ \sa setAttributeValue() ++ \since 4.6.2 ++*/ ++void QGLShaderProgram::setUniformValue(int location, const GLfloat value[3][3]) ++{ ++ Q_D(QGLShaderProgram); ++ Q_UNUSED(d); ++ if (location != -1) ++ glUniformMatrix3fv(location, 1, GL_FALSE, value[0]); ++} ++ ++/*! ++ \overload ++ ++ Sets the uniform variable at \a location in the current context + to a 4x4 matrix \a value. The matrix elements must be specified + in column-major order. + +@@ -2288,6 +2324,37 @@ void QGLShaderProgram::setUniformValue(int location, const GLfloat value[4][4]) + glUniformMatrix4fv(location, 1, GL_FALSE, value[0]); + } + ++ ++/*! ++ \overload ++ ++ Sets the uniform variable called \a name in the current context ++ to a 2x2 matrix \a value. The matrix elements must be specified ++ in column-major order. ++ ++ \sa setAttributeValue() ++ \since 4.6.2 ++*/ ++void QGLShaderProgram::setUniformValue(const char *name, const GLfloat value[2][2]) ++{ ++ setUniformValue(uniformLocation(name), value); ++} ++ ++/*! ++ \overload ++ ++ Sets the uniform variable called \a name in the current context ++ to a 3x3 matrix \a value. The matrix elements must be specified ++ in column-major order. ++ ++ \sa setAttributeValue() ++ \since 4.6.2 ++*/ ++void QGLShaderProgram::setUniformValue(const char *name, const GLfloat value[3][3]) ++{ ++ setUniformValue(uniformLocation(name), value); ++} ++ + /*! + \overload + +diff --git a/src/opengl/qglshaderprogram.h b/src/opengl/qglshaderprogram.h +index deeaee2..4eb80dd 100644 +--- a/src/opengl/qglshaderprogram.h ++++ b/src/opengl/qglshaderprogram.h +@@ -216,6 +216,8 @@ public: + void setUniformValue(int location, const QMatrix4x2& value); + void setUniformValue(int location, const QMatrix4x3& value); + void setUniformValue(int location, const QMatrix4x4& value); ++ void setUniformValue(int location, const GLfloat value[2][2]); ++ void setUniformValue(int location, const GLfloat value[3][3]); + void setUniformValue(int location, const GLfloat value[4][4]); + void setUniformValue(int location, const QTransform& value); + +@@ -242,6 +244,8 @@ public: + void setUniformValue(const char *name, const QMatrix4x2& value); + void setUniformValue(const char *name, const QMatrix4x3& value); + void setUniformValue(const char *name, const QMatrix4x4& value); ++ void setUniformValue(const char *name, const GLfloat value[2][2]); ++ void setUniformValue(const char *name, const GLfloat value[3][3]); + void setUniformValue(const char *name, const GLfloat value[4][4]); + void setUniformValue(const char *name, const QTransform& value); + +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1198-Handle-broken-shaders-better-in-the-GL2-engine-s-sha.patch b/recipes/qt4/qt-4.6.0/1198-Handle-broken-shaders-better-in-the-GL2-engine-s-sha.patch new file mode 100644 index 0000000000..d81051dd9b --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1198-Handle-broken-shaders-better-in-the-GL2-engine-s-sha.patch @@ -0,0 +1,269 @@ +From b784d4991b186037ccd2b60ae3101697a2251160 Mon Sep 17 00:00:00 2001 +From: Tom Cooksey <thomas.cooksey@nokia.com> +Date: Tue, 22 Dec 2009 09:10:14 +0100 +Subject: [PATCH 1198/1244] Handle broken shaders better in the GL2 engine's shader manager + +The shader manager will now a) not seg-fault and b) actually tell you +which shader has the error. + +Reviewed-By: Kim +--- + .../gl2paintengineex/qglengineshadermanager.cpp | 191 ++++++++++++-------- + 1 files changed, 114 insertions(+), 77 deletions(-) + +diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp +index 1187c2d..9d545b9 100644 +--- a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp ++++ b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp +@@ -170,13 +170,15 @@ QGLEngineSharedShaders::QGLEngineSharedShaders(const QGLContext* context) + source.append(qShaderSnippets[MainVertexShader]); + source.append(qShaderSnippets[PositionOnlyVertexShader]); + vertexShader = new QGLShader(QGLShader::Vertex, context, this); +- vertexShader->compileSourceCode(source); ++ if (!vertexShader->compileSourceCode(source)) ++ qWarning("Vertex shader for simpleShaderProg (MainVertexShader & PositionOnlyVertexShader) failed to compile"); + + source.clear(); + source.append(qShaderSnippets[MainFragmentShader]); + source.append(qShaderSnippets[ShockingPinkSrcFragmentShader]); + fragShader = new QGLShader(QGLShader::Fragment, context, this); +- fragShader->compileSourceCode(source); ++ if (!fragShader->compileSourceCode(source)) ++ qWarning("Fragment shader for simpleShaderProg (MainFragmentShader & ShockingPinkSrcFragmentShader) failed to compile"); + + simpleShaderProg = new QGLShaderProgram(context, this); + simpleShaderProg->addShader(vertexShader); +@@ -193,13 +195,15 @@ QGLEngineSharedShaders::QGLEngineSharedShaders(const QGLContext* context) + source.append(qShaderSnippets[MainWithTexCoordsVertexShader]); + source.append(qShaderSnippets[UntransformedPositionVertexShader]); + vertexShader = new QGLShader(QGLShader::Vertex, context, this); +- vertexShader->compileSourceCode(source); ++ if (!vertexShader->compileSourceCode(source)) ++ qWarning("Vertex shader for blitShaderProg (MainWithTexCoordsVertexShader & UntransformedPositionVertexShader) failed to compile"); + + source.clear(); + source.append(qShaderSnippets[MainFragmentShader]); + source.append(qShaderSnippets[ImageSrcFragmentShader]); + fragShader = new QGLShader(QGLShader::Fragment, context, this); +- fragShader->compileSourceCode(source); ++ if (!fragShader->compileSourceCode(source)) ++ qWarning("Fragment shader for blitShaderProg (MainFragmentShader & ImageSrcFragmentShader) failed to compile"); + + blitShaderProg = new QGLShaderProgram(context, this); + blitShaderProg->addShader(vertexShader); +@@ -234,84 +238,95 @@ QGLEngineShaderProg *QGLEngineSharedShaders::findProgramInCache(const QGLEngineS + } + } + +- QByteArray source; +- source.append(qShaderSnippets[prog.mainFragShader]); +- source.append(qShaderSnippets[prog.srcPixelFragShader]); +- if (prog.srcPixelFragShader == CustomImageSrcFragmentShader) +- source.append(prog.customStageSource); +- if (prog.compositionFragShader) +- source.append(qShaderSnippets[prog.compositionFragShader]); +- if (prog.maskFragShader) +- source.append(qShaderSnippets[prog.maskFragShader]); +- QGLShader* fragShader = new QGLShader(QGLShader::Fragment, ctxGuard.context(), this); +- fragShader->compileSourceCode(source); +- +- source.clear(); +- source.append(qShaderSnippets[prog.mainVertexShader]); +- source.append(qShaderSnippets[prog.positionVertexShader]); +- QGLShader* vertexShader = new QGLShader(QGLShader::Vertex, ctxGuard.context(), this); +- vertexShader->compileSourceCode(source); ++ QGLShader *vertexShader = 0; ++ QGLShader *fragShader = 0; ++ QGLEngineShaderProg *newProg = 0; ++ bool success = false; ++ ++ do { ++ QByteArray source; ++ source.append(qShaderSnippets[prog.mainFragShader]); ++ source.append(qShaderSnippets[prog.srcPixelFragShader]); ++ if (prog.srcPixelFragShader == CustomImageSrcFragmentShader) ++ source.append(prog.customStageSource); ++ if (prog.compositionFragShader) ++ source.append(qShaderSnippets[prog.compositionFragShader]); ++ if (prog.maskFragShader) ++ source.append(qShaderSnippets[prog.maskFragShader]); ++ fragShader = new QGLShader(QGLShader::Fragment, ctxGuard.context(), this); ++ QByteArray description; ++#if defined(QT_DEBUG) ++ // Name the shader for easier debugging ++ description.append("Fragment shader: main="); ++ description.append(snippetNameStr(prog.mainFragShader)); ++ description.append(", srcPixel="); ++ description.append(snippetNameStr(prog.srcPixelFragShader)); ++ if (prog.compositionFragShader) { ++ description.append(", composition="); ++ description.append(snippetNameStr(prog.compositionFragShader)); ++ } ++ if (prog.maskFragShader) { ++ description.append(", mask="); ++ description.append(snippetNameStr(prog.maskFragShader)); ++ } ++ fragShader->setObjectName(QString::fromLatin1(description)); ++#endif ++ if (!fragShader->compileSourceCode(source)) { ++ qWarning() << "Warning:" << description << "failed to compile!"; ++ break; ++ } + ++ source.clear(); ++ source.append(qShaderSnippets[prog.mainVertexShader]); ++ source.append(qShaderSnippets[prog.positionVertexShader]); ++ vertexShader = new QGLShader(QGLShader::Vertex, ctxGuard.context(), this); + #if defined(QT_DEBUG) +- // Name the shaders for easier debugging +- QByteArray description; +- description.append("Fragment shader: main="); +- description.append(snippetNameStr(prog.mainFragShader)); +- description.append(", srcPixel="); +- description.append(snippetNameStr(prog.srcPixelFragShader)); +- if (prog.compositionFragShader) { +- description.append(", composition="); +- description.append(snippetNameStr(prog.compositionFragShader)); +- } +- if (prog.maskFragShader) { +- description.append(", mask="); +- description.append(snippetNameStr(prog.maskFragShader)); +- } +- fragShader->setObjectName(QString::fromLatin1(description)); +- +- description.clear(); +- description.append("Vertex shader: main="); +- description.append(snippetNameStr(prog.mainVertexShader)); +- description.append(", position="); +- description.append(snippetNameStr(prog.positionVertexShader)); +- vertexShader->setObjectName(QString::fromLatin1(description)); ++ // Name the shader for easier debugging ++ description.clear(); ++ description.append("Vertex shader: main="); ++ description.append(snippetNameStr(prog.mainVertexShader)); ++ description.append(", position="); ++ description.append(snippetNameStr(prog.positionVertexShader)); ++ vertexShader->setObjectName(QString::fromLatin1(description)); + #endif ++ if (!vertexShader->compileSourceCode(source)) { ++ qWarning() << "Warning:" << description << "failed to compile!"; ++ break; ++ } + +- QGLEngineShaderProg* newProg = new QGLEngineShaderProg(prog); +- +- // If the shader program's not found in the cache, create it now. +- newProg->program = new QGLShaderProgram(ctxGuard.context(), this); +- newProg->program->addShader(vertexShader); +- newProg->program->addShader(fragShader); +- +- // We have to bind the vertex attribute names before the program is linked: +- newProg->program->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR); +- if (newProg->useTextureCoords) +- newProg->program->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR); +- if (newProg->useOpacityAttribute) +- newProg->program->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR); +- +- newProg->program->link(); +- if (!newProg->program->isLinked()) { +- QLatin1String none("none"); +- QLatin1String br("\n"); +- QString error; +- error = QLatin1String("Shader program failed to link,") ++ newProg = new QGLEngineShaderProg(prog); ++ ++ // If the shader program's not found in the cache, create it now. ++ newProg->program = new QGLShaderProgram(ctxGuard.context(), this); ++ newProg->program->addShader(vertexShader); ++ newProg->program->addShader(fragShader); ++ ++ // We have to bind the vertex attribute names before the program is linked: ++ newProg->program->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR); ++ if (newProg->useTextureCoords) ++ newProg->program->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR); ++ if (newProg->useOpacityAttribute) ++ newProg->program->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR); ++ ++ newProg->program->link(); ++ if (!newProg->program->isLinked()) { ++ QLatin1String none("none"); ++ QLatin1String br("\n"); ++ QString error; ++ error = QLatin1String("Shader program failed to link,") + #if defined(QT_DEBUG) +- + br +- + QLatin1String(" Shaders Used:") + br +- + QLatin1String(" ") + vertexShader->objectName() + QLatin1String(": ") + br +- + QLatin1String(vertexShader->sourceCode()) + br +- + QLatin1String(" ") + fragShader->objectName() + QLatin1String(": ") + br +- + QLatin1String(fragShader->sourceCode()) + br ++ + br ++ + QLatin1String(" Shaders Used:") + br ++ + QLatin1String(" ") + vertexShader->objectName() + QLatin1String(": ") + br ++ + QLatin1String(vertexShader->sourceCode()) + br ++ + QLatin1String(" ") + fragShader->objectName() + QLatin1String(": ") + br ++ + QLatin1String(fragShader->sourceCode()) + br + #endif +- + QLatin1String(" Error Log:\n") +- + QLatin1String(" ") + newProg->program->log(); +- qWarning() << error; +- delete newProg; // Deletes the QGLShaderProgram in it's destructor +- newProg = 0; +- } +- else { ++ + QLatin1String(" Error Log:\n") ++ + QLatin1String(" ") + newProg->program->log(); ++ qWarning() << error; ++ break; ++ } + if (cachedPrograms.count() > 30) { + // The cache is full, so delete the last 5 programs in the list. + // These programs will be least used, as a program us bumped to +@@ -323,6 +338,22 @@ QGLEngineShaderProg *QGLEngineSharedShaders::findProgramInCache(const QGLEngineS + } + + cachedPrograms.insert(0, newProg); ++ ++ success = true; ++ } while (false); ++ ++ // Clean up everything if we weren't successful ++ if (!success) { ++ if (newProg) { ++ delete newProg; // Also deletes the QGLShaderProgram which in turn deletes the QGLShaders ++ newProg = 0; ++ } ++ else { ++ if (vertexShader) ++ delete vertexShader; ++ if (fragShader) ++ delete fragShader; ++ } + } + + return newProg; +@@ -364,6 +395,9 @@ QGLEngineShaderManager::~QGLEngineShaderManager() + + uint QGLEngineShaderManager::getUniformLocation(Uniform id) + { ++ if (!currentShaderProg) ++ return 0; ++ + QVector<uint> &uniformLocations = currentShaderProg->uniformLocations; + if (uniformLocations.isEmpty()) + uniformLocations.fill(GLuint(-1), NumUniforms); +@@ -468,7 +502,10 @@ void QGLEngineShaderManager::removeCustomStage() + + QGLShaderProgram* QGLEngineShaderManager::currentProgram() + { +- return currentShaderProg->program; ++ if (currentShaderProg) ++ return currentShaderProg->program; ++ else ++ return simpleProgram(); + } + + QGLShaderProgram* QGLEngineShaderManager::simpleProgram() +-- +1.6.5 + diff --git a/recipes/qt4/qt-4.6.0/1205-Fix-text-rendering-on-GL2-paint-engine.patch b/recipes/qt4/qt-4.6.0/1205-Fix-text-rendering-on-GL2-paint-engine.patch new file mode 100644 index 0000000000..548ed9246f --- /dev/null +++ b/recipes/qt4/qt-4.6.0/1205-Fix-text-rendering-on-GL2-paint-engine.patch @@ -0,0 +1,83 @@ +From a8c3ed1dbe209488866e687d1a63c6143a04cfe0 Mon Sep 17 00:00:00 2001 +From: Tom Cooksey <thomas.cooksey@nokia.com> +Date: Wed, 23 Dec 2009 10:38:56 +0100 +Subject: [PATCH 1205/1244] Fix text rendering on GL2 paint engine + +If you draw with a brush, then draw a pixmap, then draw with the +same brush, the GL2 engine wouldn't update the fragment shader to +use the brush. This is because it detected the brush hadn't changed +and so didn't need updating. To fix this, we now set the current +brush to noBrush when drawing an image/pixmap so the engine knows +it needs to update the GL state for the brush. + +Reviewed-By: Kim +--- + .../gl2paintengineex/qpaintengineex_opengl2.cpp | 15 ++++++++++----- + .../gl2paintengineex/qpaintengineex_opengl2_p.h | 1 + + 2 files changed, 11 insertions(+), 5 deletions(-) + +diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp +index f52ed92..32fa3dc 100644 +--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp ++++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp +@@ -388,21 +388,24 @@ inline QColor qt_premultiplyColor(QColor c, GLfloat opacity) + + void QGL2PaintEngineExPrivate::setBrush(const QBrush& brush) + { +- Q_ASSERT(brush.style() != Qt::NoBrush); +- + if (qbrush_fast_equals(currentBrush, brush)) + return; + ++ const Qt::BrushStyle newStyle = qbrush_style(brush); ++ Q_ASSERT(newStyle != Qt::NoBrush); ++ + currentBrush = brush; ++ brushUniformsDirty = true; // All brushes have at least one uniform ++ ++ if (newStyle > Qt::SolidPattern) ++ brushTextureDirty = true; + +- brushTextureDirty = true; +- brushUniformsDirty = true; + if (currentBrush.style() == Qt::TexturePattern + && qHasPixmapTexture(brush) && brush.texture().isQBitmap()) + { + shaderManager->setSrcPixelType(QGLEngineShaderManager::TextureSrcWithPattern); + } else { +- shaderManager->setSrcPixelType(currentBrush.style()); ++ shaderManager->setSrcPixelType(newStyle); + } + shaderManager->optimiseForBrushTransform(currentBrush.transform()); + } +@@ -700,6 +703,7 @@ static inline void setCoords(GLfloat *coords, const QGLRect &rect) + void QGL2PaintEngineExPrivate::drawTexture(const QGLRect& dest, const QGLRect& src, const QSize &textureSize, bool opaque, bool pattern) + { + // Setup for texture drawing ++ currentBrush = noBrush; + shaderManager->setSrcPixelType(pattern ? QGLEngineShaderManager::PatternSrc : QGLEngineShaderManager::ImageSrc); + if (prepareForDraw(opaque)) + shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT); +@@ -1782,6 +1786,7 @@ void QGL2PaintEngineEx::drawPixmaps(const QDrawPixmaps::Data *drawingData, int d + state()->renderHints & QPainter::SmoothPixmapTransform, texture->id); + + // Setup for texture drawing ++ d->currentBrush = d->noBrush; + d->shaderManager->setSrcPixelType(isBitmap ? QGLEngineShaderManager::PatternSrc : QGLEngineShaderManager::ImageSrc); + if (d->prepareForDraw(isOpaque)) + d->shaderManager->currentProgram()->setUniformValue(d->location(QGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT); +diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h +index f1ec6e6..8de4a82 100644 +--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h ++++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h +@@ -244,6 +244,7 @@ public: + uint maxClip; + + QBrush currentBrush; // May not be the state's brush! ++ const QBrush noBrush; + + GLfloat inverseScale; + +-- +1.6.5 + diff --git a/recipes/qt4/qt4-embedded-gles_4.6.0.bb b/recipes/qt4/qt4-embedded-gles_4.6.0.bb index f819c66212..04e074f9dd 100644 --- a/recipes/qt4/qt4-embedded-gles_4.6.0.bb +++ b/recipes/qt4/qt4-embedded-gles_4.6.0.bb @@ -1,5 +1,5 @@ require qt4-embedded.inc -PR = "${INC_PR}.0" +PR = "${INC_PR}.1" QT_GLFLAGS = "-opengl es2 -openvg" diff --git a/recipes/qt4/qt4-embedded.inc b/recipes/qt4/qt4-embedded.inc index 11fcd5849b..e8184e772d 100644 --- a/recipes/qt4/qt4-embedded.inc +++ b/recipes/qt4/qt4-embedded.inc @@ -4,7 +4,7 @@ LICENSE = "GPL QPL" PRIORITY = "optional" HOMEPAGE = "http://www.trolltech.com" DEPENDS += "directfb tslib" -INC_PR = "r14" +INC_PR = "r15" QT_BASE_NAME ?= "qt4-embedded" QT_BASE_LIB ?= "libqt-embedded" diff --git a/recipes/qt4/qt4-x11-free-gles_4.6.0.bb b/recipes/qt4/qt4-x11-free-gles_4.6.0.bb index a74feaf0eb..089992c142 100644 --- a/recipes/qt4/qt4-x11-free-gles_4.6.0.bb +++ b/recipes/qt4/qt4-x11-free-gles_4.6.0.bb @@ -1,5 +1,5 @@ require qt4-x11-free.inc -PR = "${INC_PR}.2" +PR = "${INC_PR}.3" QT_GLFLAGS = "-opengl es2 -openvg" diff --git a/recipes/qt4/qt4-x11-free.inc b/recipes/qt4/qt4-x11-free.inc index adf3bbc6c0..ade148bab6 100644 --- a/recipes/qt4/qt4-x11-free.inc +++ b/recipes/qt4/qt4-x11-free.inc @@ -6,7 +6,7 @@ LICENSE = "GPL QPL" DEPENDS += "virtual/libx11 fontconfig xft libxext libxrender libxrandr libxcursor" PROVIDES = "qt4x11" -INC_PR = "r13" +INC_PR = "r14" SRC_URI = "ftp://ftp.trolltech.com/qt/source/qt-x11-opensource-src-${PV}.tar.gz \ file://0001-cross-compile.patch;patch=1 \ |