Added Harmattan specific debian files to master branch.

Debian packaging files added to Master branch. One
translation file was removed as it was a left over from
an old commit. Reference to it was removed from rules file.
Similar commit is done for Harmattan as well. Task: BACKEND-564

Reviewed-by: Adrian Constantin

1 files changed, 1003 insertions, 0 deletions

diff --git a/config.profiles/harmattan/patches/glshadercache.diff b/config.profiles/harmattan/patches/glshadercache.diff
new file mode 100644
index 0000000..2c6ad9a
--- /dev/null
+++ b/config.profiles/harmattan/patches/glshadercache.diff
@@ -0,0 +1,1003 @@
+Index: qt-maemo-qtp/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
+===================================================================
+--- qt-maemo-qtp.orig/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
++++ qt-maemo-qtp/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
+@@ -42,12 +42,12 @@
+ #include "qglengineshadermanager_p.h"
+ #include "qglengineshadersource_p.h"
+ #include "qpaintengineex_opengl2_p.h"
++#include "qglshadercache_p.h"
+ 
+ #if defined(QT_DEBUG)
+ #include <QMetaEnum>
+ #endif
+ 
+-
+ QT_BEGIN_NAMESPACE
+ 
+ static void qt_shared_shaders_free(void *data)
+@@ -165,62 +165,89 @@
+ 
+     QGLShader* fragShader;
+     QGLShader* vertexShader;
+-    QByteArray source;
++    QByteArray vertexSource;
++    QByteArray fragSource;
+ 
+     // Compile up the simple shader:
+-    source.clear();
+-    source.append(qShaderSnippets[MainVertexShader]);
+-    source.append(qShaderSnippets[PositionOnlyVertexShader]);
+-    vertexShader = new QGLShader(QGLShader::Vertex, context, this);
+-    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);
+-    if (!fragShader->compileSourceCode(source))
+-        qWarning("Fragment shader for simpleShaderProg (MainFragmentShader & ShockingPinkSrcFragmentShader) failed to compile");
++    vertexSource.append(qShaderSnippets[MainVertexShader]);
++    vertexSource.append(qShaderSnippets[PositionOnlyVertexShader]);
++
++    fragSource.append(qShaderSnippets[MainFragmentShader]);
++    fragSource.append(qShaderSnippets[ShockingPinkSrcFragmentShader]);
+ 
+     simpleShaderProg = new QGLShaderProgram(context, this);
+-    simpleShaderProg->addShader(vertexShader);
+-    simpleShaderProg->addShader(fragShader);
+-    simpleShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
+-    simpleShaderProg->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
+-    simpleShaderProg->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
+-    simpleShaderProg->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
++
++    CachedShader simpleShaderCache(fragSource, vertexSource);
++
++    bool inCache = simpleShaderCache.load(simpleShaderProg, context);
++
++    if (!inCache) {
++        vertexShader = new QGLShader(QGLShader::Vertex, context, this);
++        if (!vertexShader->compileSourceCode(vertexSource))
++            qWarning("Vertex shader for simpleShaderProg (MainVertexShader & PositionOnlyVertexShader) failed to compile");
++
++        fragShader = new QGLShader(QGLShader::Fragment, context, this);
++        if (!fragShader->compileSourceCode(fragSource))
++            qWarning("Fragment shader for simpleShaderProg (MainFragmentShader & ShockingPinkSrcFragmentShader) failed to compile");
++
++        simpleShaderProg->addShader(vertexShader);
++        simpleShaderProg->addShader(fragShader);
++
++        simpleShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
++        simpleShaderProg->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
++        simpleShaderProg->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
++        simpleShaderProg->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
++    }
++
+     simpleShaderProg->link();
+-    if (!simpleShaderProg->isLinked()) {
++
++    if (simpleShaderProg->isLinked()) {
++        if (!inCache)
++            simpleShaderCache.store(simpleShaderProg, context);
++    } else {
+         qCritical() << "Errors linking simple shader:"
+                     << simpleShaderProg->log();
+     }
+ 
+     // Compile the blit shader:
+-    source.clear();
+-    source.append(qShaderSnippets[MainWithTexCoordsVertexShader]);
+-    source.append(qShaderSnippets[UntransformedPositionVertexShader]);
+-    vertexShader = new QGLShader(QGLShader::Vertex, context, this);
+-    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);
+-    if (!fragShader->compileSourceCode(source))
+-        qWarning("Fragment shader for blitShaderProg (MainFragmentShader & ImageSrcFragmentShader) failed to compile");
++    vertexSource.clear();
++    vertexSource.append(qShaderSnippets[MainWithTexCoordsVertexShader]);
++    vertexSource.append(qShaderSnippets[UntransformedPositionVertexShader]);
++
++    fragSource.clear();
++    fragSource.append(qShaderSnippets[MainFragmentShader]);
++    fragSource.append(qShaderSnippets[ImageSrcFragmentShader]);
+ 
+     blitShaderProg = new QGLShaderProgram(context, this);
+-    blitShaderProg->addShader(vertexShader);
+-    blitShaderProg->addShader(fragShader);
+-    blitShaderProg->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
+-    blitShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
++
++    CachedShader blitShaderCache(fragSource, vertexSource);
++
++    inCache = blitShaderCache.load(blitShaderProg, context);
++
++    if (!inCache) {
++        vertexShader = new QGLShader(QGLShader::Vertex, context, this);
++        if (!vertexShader->compileSourceCode(vertexSource))
++            qWarning("Vertex shader for blitShaderProg (MainWithTexCoordsVertexShader & UntransformedPositionVertexShader) failed to compile");
++
++        fragShader = new QGLShader(QGLShader::Fragment, context, this);
++        if (!fragShader->compileSourceCode(fragSource))
++            qWarning("Fragment shader for blitShaderProg (MainFragmentShader & ImageSrcFragmentShader) failed to compile");
++
++        blitShaderProg->addShader(vertexShader);
++        blitShaderProg->addShader(fragShader);
++
++        blitShaderProg->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
++        blitShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
++    }
++
+     blitShaderProg->link();
+-    if (!blitShaderProg->isLinked()) {
++    if (blitShaderProg->isLinked()) {
++        if (!inCache)
++            blitShaderCache.store(blitShaderProg, context);
++    } else {
+         qCritical() << "Errors linking blit shader:"
+-                    << simpleShaderProg->log();
++                    << blitShaderProg->log();
+     }
+-
+ }
+ 
+ QGLEngineSharedShaders::~QGLEngineSharedShaders()
+@@ -262,99 +289,108 @@
+         }
+     }
+ 
+-    QGLShader *vertexShader = 0;
+-    QGLShader *fragShader = 0;
+-    QGLEngineShaderProg *newProg = 0;
+-    bool success = false;
++    QScopedPointer<QGLEngineShaderProg> newProg;
+ 
+     do {
+-        QByteArray source;
++        QByteArray fragSource;
+         // Insert the custom stage before the srcPixel shader to work around an ATI driver bug
+         // where you cannot forward declare a function that takes a sampler as argument.
+         if (prog.srcPixelFragShader == CustomImageSrcFragmentShader)
+-            source.append(prog.customStageSource);
+-        source.append(qShaderSnippets[prog.mainFragShader]);
+-        source.append(qShaderSnippets[prog.srcPixelFragShader]);
++            fragSource.append(prog.customStageSource);
++        fragSource.append(qShaderSnippets[prog.mainFragShader]);
++        fragSource.append(qShaderSnippets[prog.srcPixelFragShader]);
+         if (prog.compositionFragShader)
+-            source.append(qShaderSnippets[prog.compositionFragShader]);
++            fragSource.append(qShaderSnippets[prog.compositionFragShader]);
+         if (prog.maskFragShader)
+-            source.append(qShaderSnippets[prog.maskFragShader]);
+-        fragShader = new QGLShader(QGLShader::Fragment, ctxGuard.context(), this);
+-        QByteArray description;
++            fragSource.append(qShaderSnippets[prog.maskFragShader]);
++
++        QByteArray vertexSource;
++        vertexSource.append(qShaderSnippets[prog.mainVertexShader]);
++        vertexSource.append(qShaderSnippets[prog.positionVertexShader]);
++
++        QScopedPointer<QGLShaderProgram> shaderProgram(new QGLShaderProgram(ctxGuard.context(), this));
++
++        CachedShader shaderCache(fragSource, vertexSource);
++        bool inCache = shaderCache.load(shaderProgram.data(), ctxGuard.context());
++
++        if (!inCache) {
++
++            QScopedPointer<QGLShader> 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));
++            // 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;
+-        }
++            if (!fragShader->compileSourceCode(fragSource)) {
++                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);
++            QScopedPointer<QGLShader> vertexShader(new QGLShader(QGLShader::Vertex, ctxGuard.context(), this));
+ #if defined(QT_DEBUG)
+-        // 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));
++            // 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;
+-        }
++            if (!vertexShader->compileSourceCode(vertexSource)) {
++                qWarning() << "Warning:" << description << "failed to compile!";
++                break;
++            }
+ 
+-        newProg = new QGLEngineShaderProg(prog);
++            shaderProgram->addShader(vertexShader.take());
++            shaderProgram->addShader(fragShader.take());
+ 
+-        // 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);
+-        if (newProg->usePmvMatrixAttribute) {
+-            newProg->program->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
+-            newProg->program->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
+-            newProg->program->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
++            // We have to bind the vertex attribute names before the program is linked:
++            shaderProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
++            if (prog.useTextureCoords)
++                shaderProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
++            if (prog.useOpacityAttribute)
++                shaderProgram->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR);
++            if (prog.usePmvMatrixAttribute) {
++                shaderProgram->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
++                shaderProgram->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
++                shaderProgram->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
++            }
+         }
+ 
++        newProg.reset(new QGLEngineShaderProg(prog));
++        newProg->program = shaderProgram.take();
++
+         newProg->program->link();
+-        if (!newProg->program->isLinked()) {
++        if (newProg->program->isLinked()) {
++            if (!inCache)
++                shaderCache.store(newProg->program, ctxGuard.context());
++        } else {
+             QLatin1String none("none");
+             QLatin1String br("\n");
+             QString error;
+-            error = QLatin1String("Shader program failed to link,")
++            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
++            error += QLatin1String("\n  Shaders Used:\n");
++            for (int i = 0; i < newProg->program->shaders().count(); ++i) {
++                QGLShader *shader = newProg->program->shaders().at(i);
++                error += QLatin1String("    ") + shader->objectName() + QLatin1String(": \n")
++                         + QLatin1String(shader->sourceCode()) + br;
++            }
+ #endif
+-                + QLatin1String("  Error Log:\n")
+-                + QLatin1String("    ") + newProg->program->log();
++            error += QLatin1String("  Error Log:\n")
++                     + QLatin1String("    ") + newProg->program->log();
+             qWarning() << error;
+             break;
+         }
+@@ -376,26 +412,10 @@
+             }
+         }
+ 
+-        cachedPrograms.insert(0, newProg);
+-
+-        success = true;
++        cachedPrograms.insert(0, newProg.data());
+     } 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;
++    return newProg.take();
+ }
+ 
+ void QGLEngineSharedShaders::cleanupCustomStage(QGLCustomShaderStage* stage)
+Index: qt-maemo-qtp/src/opengl/gl2paintengineex/qglshadercache_meego_p.h
+===================================================================
+--- /dev/null
++++ qt-maemo-qtp/src/opengl/gl2paintengineex/qglshadercache_meego_p.h
+@@ -0,0 +1,457 @@
++/****************************************************************************
++**
++** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
++** All rights reserved.
++** Contact: Nokia Corporation (qt-info@nokia.com)
++**
++** This file is part of the QtOpenGL 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$
++**
++****************************************************************************/
++
++//
++//  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.
++//
++
++#ifndef QGLSHADERCACHE_MEEGO_P_H
++#define QGLSHADERCACHE_MEEGO_P_H
++
++#include <QtCore/qglobal.h>
++
++#if defined(QT_MEEGO_EXPERIMENTAL_SHADERCACHE) && defined(QT_OPENGL_ES_2)
++
++#include <QtCore/qcryptographichash.h>
++#include <QtCore/qsharedmemory.h>
++#include <QtCore/qsystemsemaphore.h>
++
++#ifndef QT_BOOTSTRAPPED
++#  include <GLES2/gl2ext.h>
++#endif
++#if defined(QT_DEBUG) || defined(QT_MEEGO_EXPERIMENTAL_SHADERCACHE_TRACE)
++#  include <syslog.h>
++#endif
++
++QT_BEGIN_HEADER
++
++/*
++    This cache stores internal Qt shader programs in shared memory.
++
++    This header file is ugly on purpose and can only be included once. It is only to be used
++    for the internal shader cache, not as a generic cache for anyone's shaders.
++
++    The cache stores either ShaderCacheMaxEntries shader programs or ShaderCacheDataSize kilobytes
++    of shader programs, whatever limit is reached first.
++
++    The layout of the cache is as outlined in the CachedShaders struct. After some
++    integers, an array of headers is reserved, then comes the space for the actual binaries.
++
++    Shader Programs are identified by the md5sum of their frag and vertex shader source code.
++
++    Shader Programs are never removed. The cache never shrinks or re-shuffles. This is done
++    on purpose to ensure minimum amount of locking, no alignment problems and very few write
++    operations.
++
++    Note: Locking the shader cache could be expensive, because the entire system might hang.
++    That's why the cache is immutable to minimize the time we need to keep it locked.
++
++    Why is it Meego specific?
++
++    First, the size is chosen so that it fits to generic meego usage. Second, on Meego, there's
++    always at least one Qt application active (the launcher), so the cache will never be destroyed.
++    Only when the last Qt app exits, the cache dies, which should only be when someone kills the
++    X11 server. And last but not least it was only tested with Meego's SGX driver.
++
++    There's a small tool in src/opengl/util/meego that dumps the contents of the cache.
++ */
++
++// anonymous namespace, prevent exporting of the private symbols
++namespace
++{
++
++struct CachedShaderHeader
++{
++    /* the index in the data[] member of CachedShaders */
++    int index;
++    /* the size of the binary shader */
++    GLsizei size;
++    /* the format of the binary shader */
++    GLenum format;
++    /* the md5sum of the frag+vertex shaders */
++    char md5Sum[16];
++};
++
++enum
++{
++    /* The maximum amount of shader programs the cache can hold */
++    ShaderCacheMaxEntries = 20
++};
++
++typedef CachedShaderHeader CachedShaderHeaders[ShaderCacheMaxEntries];
++
++enum
++{
++    // ShaderCacheDataSize is 20k minus the other data members of CachedShaders
++    ShaderCacheDataSize = 1024 * ShaderCacheMaxEntries - sizeof(CachedShaderHeaders) - 2 * sizeof(int)
++};
++
++struct CachedShaders
++{
++    /* How much space is still available in the cache */
++    inline int availableSize() const { return ShaderCacheDataSize - dataSize; }
++
++    /* The current amount of cached shaders */
++    int shaderCount;
++
++    /* The current amount (in bytes) of cached data */
++    int dataSize;
++
++    /* The headers describing the shaders */
++    CachedShaderHeaders headers;
++
++    /* The actual binary data of the shader programs */
++    char data[ShaderCacheDataSize];
++};
++
++//#define QT_DEBUG_SHADER_CACHE
++#ifdef QT_DEBUG_SHADER_CACHE
++static QDebug shaderCacheDebug()
++{
++    return QDebug(QtDebugMsg);
++}
++#else
++static inline QNoDebug shaderCacheDebug() { return QNoDebug(); }
++#endif
++
++class ShaderCacheSharedMemory
++{
++public:
++    ShaderCacheSharedMemory()
++        : shm(QLatin1String("qt_gles2_shadercache_" QT_VERSION_STR))
++    {
++        // we need a system semaphore here, since cache creation and initialization must be atomic
++        QSystemSemaphore attachSemaphore(QLatin1String("qt_gles2_shadercache_mutex_" QT_VERSION_STR), 1);
++
++        if (!attachSemaphore.acquire()) {
++            shaderCacheDebug() << "Unable to require shader cache semaphore:" << attachSemaphore.errorString();
++            return;
++        }
++
++        if (shm.attach()) {
++            // success!
++            shaderCacheDebug() << "Attached to shader cache";
++        } else {
++
++            // no cache exists - create and initialize it
++            if (shm.create(sizeof(CachedShaders))) {
++                shaderCacheDebug() << "Created new shader cache";
++                initializeCache();
++            } else {
++                shaderCacheDebug() << "Unable to create shader cache:" << shm.errorString();
++            }
++        }
++
++        attachSemaphore.release();
++    }
++
++    inline bool isAttached() const { return shm.isAttached(); }
++
++    inline bool lock() { return shm.lock(); }
++    inline bool unlock() { return shm.unlock(); }
++    inline void *data() { return shm.data(); }
++    inline QString errorString() { return shm.errorString(); }
++
++    ~ShaderCacheSharedMemory()
++    {
++        if (!shm.detach())
++            shaderCacheDebug() << "Unable to detach shader cache" << shm.errorString();
++    }
++
++private:
++    void initializeCache()
++    {
++        // no need to lock the shared memory since we're already protected by the
++        // attach system semaphore.
++
++        void *data = shm.data();
++        Q_ASSERT(data);
++
++        memset(data, 0, sizeof(CachedShaders));
++    }
++
++    QSharedMemory shm;
++};
++
++class ShaderCacheLocker
++{
++public:
++    inline ShaderCacheLocker(ShaderCacheSharedMemory *cache)
++        : shm(cache->lock() ? cache : (ShaderCacheSharedMemory *)0)
++    {
++        if (!shm)
++            shaderCacheDebug() << "Unable to lock shader cache" << cache->errorString();
++    }
++
++    inline bool isLocked() const { return shm; }
++
++    inline ~ShaderCacheLocker()
++    {
++        if (!shm)
++            return;
++        if (!shm->unlock())
++            shaderCacheDebug() << "Unable to unlock shader cache" << shm->errorString();
++    }
++
++private:
++    ShaderCacheSharedMemory *shm;
++};
++
++#ifdef QT_BOOTSTRAPPED
++} // end namespace
++#else
++
++static void traceCacheOverflow(const char *message)
++{
++#if defined(QT_DEBUG) || defined (QT_MEEGO_EXPERIMENTAL_SHADERCACHE_TRACE)
++    openlog(qPrintable(QCoreApplication::applicationName()), LOG_PID | LOG_ODELAY, LOG_USER);
++    syslog(LOG_DEBUG, message);
++    closelog();
++#endif
++    shaderCacheDebug() << message;
++}
++
++Q_GLOBAL_STATIC(ShaderCacheSharedMemory, shaderCacheSharedMemory)
++
++/*
++   Finds the index of the shader program identified by md5Sum in the cache.
++   Note: Does NOT lock the cache for reading, the cache must already be locked!
++
++   Returns -1 when no shader was found.
++ */
++static int qt_cache_index_unlocked(const QByteArray &md5Sum, CachedShaders *cache)
++{
++    for (int i = 0; i < cache->shaderCount; ++i) {
++        if (qstrncmp(md5Sum.constData(), cache->headers[i].md5Sum, 16) == 0) {
++            return i;
++        }
++    }
++    return -1;
++}
++
++/* Returns the index of the shader identified by md5Sum */
++static int qt_cache_index(const QByteArray &md5Sum)
++{
++    ShaderCacheSharedMemory *shm = shaderCacheSharedMemory();
++    if (!shm || !shm->isAttached())
++        return false;
++
++    Q_ASSERT(md5Sum.length() == 16);
++
++    ShaderCacheLocker locker(shm);
++    if (!locker.isLocked())
++        return false;
++
++    void *data = shm->data();
++    Q_ASSERT(data);
++
++    CachedShaders *cache = reinterpret_cast<CachedShaders *>(data);
++
++    return qt_cache_index_unlocked(md5Sum, cache);
++}
++
++/* Loads the cached shader at index \a shaderIndex into \a program
++ * Note: Since the cache is immutable, this operation doesn't lock the shared memory.
++ */
++static bool qt_cached_shader(QGLShaderProgram *program, const QGLContext *ctx, int shaderIndex)
++{
++    Q_ASSERT(shaderIndex >= 0 && shaderIndex <= ShaderCacheMaxEntries);
++    Q_ASSERT(program);
++
++    ShaderCacheSharedMemory *shm = shaderCacheSharedMemory();
++    if (!shm || !shm->isAttached())
++        return false;
++
++    void *data = shm->data();
++    Q_ASSERT(data);
++
++    CachedShaders *cache = reinterpret_cast<CachedShaders *>(data);
++
++    shaderCacheDebug() << "fetching cached shader at index" << shaderIndex
++                 << "dataIndex" << cache->headers[shaderIndex].index
++                 << "size" << cache->headers[shaderIndex].size
++                 << "format" << cache->headers[shaderIndex].format;
++
++    // call program->programId first, since that resolves the glProgramBinaryOES symbol
++    GLuint programId = program->programId();
++    glProgramBinaryOES(programId, cache->headers[shaderIndex].format,
++                       cache->data + cache->headers[shaderIndex].index,
++                       cache->headers[shaderIndex].size);
++
++    return true;
++}
++
++/* Stores the shader program in the cache. Returns false if there's an error with the cache, or
++   if the cache is too small to hold the shader. */
++static bool qt_cache_shader(const QGLShaderProgram *shader, const QGLContext *ctx, const QByteArray &md5Sum)
++{
++    ShaderCacheSharedMemory *shm = shaderCacheSharedMemory();
++    if (!shm || !shm->isAttached())
++        return false;
++
++    void *data = shm->data();
++    Q_ASSERT(data);
++
++    CachedShaders *cache = reinterpret_cast<CachedShaders *>(data);
++
++    ShaderCacheLocker locker(shm);
++    if (!locker.isLocked())
++        return false;
++
++    int cacheIdx = cache->shaderCount;
++    if (cacheIdx >= ShaderCacheMaxEntries) {
++        traceCacheOverflow("Qt OpenGL shader cache index overflow!");
++        return false;
++    }
++
++    // now that we have the lock on the shared memory, make sure no one
++    // inserted the shader already while we were unlocked
++    if (qt_cache_index_unlocked(md5Sum, cache) != -1)
++        return true; // already cached
++
++    shaderCacheDebug() << "Caching shader at index" << cacheIdx;
++
++    GLint binaryLength = 0;
++    glGetProgramiv(shader->programId(), GL_PROGRAM_BINARY_LENGTH_OES, &binaryLength);
++
++    if (!binaryLength) {
++        shaderCacheDebug() << "Unable to determine binary shader size!";
++        return false;
++    }
++
++    if (binaryLength > cache->availableSize()) {
++        traceCacheOverflow("Qt OpenGL shader cache data overflow!");
++        return false;
++    }
++
++    GLsizei size = 0;
++    GLenum format = 0;
++    glGetProgramBinaryOES(shader->programId(), binaryLength, &size, &format,
++            cache->data + cache->dataSize);
++
++    if (!size) {
++        shaderCacheDebug() << "Unable to get binary shader!";
++        return false;
++    }
++
++    cache->headers[cacheIdx].index = cache->dataSize;
++    cache->dataSize += binaryLength;
++    ++cache->shaderCount;
++    cache->headers[cacheIdx].size = binaryLength;
++    cache->headers[cacheIdx].format = format;
++
++    memcpy(cache->headers[cacheIdx].md5Sum, md5Sum.constData(), 16);
++
++    shaderCacheDebug() << "cached shader size" << size
++                       << "format" << format
++                       << "binarySize" << binaryLength
++                       << "cache index" << cacheIdx
++                       << "data index" << cache->headers[cacheIdx].index;
++
++    return true;
++}
++
++} // namespace
++
++QT_BEGIN_NAMESPACE
++
++QT_MODULE(OpenGL)
++
++class CachedShader
++{
++public:
++    CachedShader(const QByteArray &fragSource, const QByteArray &vertexSource)
++        : cacheIdx(-1)
++    {
++        QCryptographicHash md5Hash(QCryptographicHash::Md5);
++
++        md5Hash.addData(fragSource);
++        md5Hash.addData(vertexSource);
++
++        md5Sum = md5Hash.result();
++    }
++
++    bool isCached()
++    {
++        return cacheIndex() != -1;
++    }
++
++    int cacheIndex()
++    {
++        if (cacheIdx != -1)
++            return cacheIdx;
++        cacheIdx = qt_cache_index(md5Sum);
++        return cacheIdx;
++    }
++
++    bool load(QGLShaderProgram *program, const QGLContext *ctx)
++    {
++        if (cacheIndex() == -1)
++            return false;
++        return qt_cached_shader(program, ctx, cacheIdx);
++    }
++
++    bool store(QGLShaderProgram *program, const QGLContext *ctx)
++    {
++        return qt_cache_shader(program, ctx, md5Sum);
++    }
++
++private:
++    QByteArray md5Sum;
++    int cacheIdx;
++};
++
++
++QT_END_NAMESPACE
++
++#endif
++
++QT_END_HEADER
++
++#endif
++#endif
+Index: qt-maemo-qtp/src/opengl/gl2paintengineex/qglshadercache_p.h
+===================================================================
+--- /dev/null
++++ qt-maemo-qtp/src/opengl/gl2paintengineex/qglshadercache_p.h
+@@ -0,0 +1,98 @@
++/****************************************************************************
++**
++** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
++** All rights reserved.
++** Contact: Nokia Corporation (qt-info@nokia.com)
++**
++** This file is part of the QtOpenGL 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$
++**
++****************************************************************************/
++
++//
++//  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.
++//
++
++#ifndef QGLSHADERCACHE_P_H
++#define QGLSHADERCACHE_P_H
++
++#include <QtCore/qglobal.h>
++
++#if defined(QT_MEEGO_EXPERIMENTAL_SHADERCACHE) && defined(QT_OPENGL_ES_2)
++#  include "qglshadercache_meego_p.h"
++#else
++
++QT_BEGIN_HEADER
++
++QT_BEGIN_NAMESPACE
++
++QT_MODULE(OpenGL)
++
++class QGLShaderProgram;
++class QGLContext;
++
++class CachedShader
++{
++public:
++    inline CachedShader(const QByteArray &, const QByteArray &)
++    {}
++
++    inline bool isCached()
++    {
++        return false;
++    }
++
++    inline bool load(QGLShaderProgram *, const QGLContext *)
++    {
++        return false;
++    }
++
++    inline bool store(QGLShaderProgram *, const QGLContext *)
++    {
++        return false;
++    }
++};
++
++QT_END_NAMESPACE
++
++QT_END_HEADER
++
++#endif
++#endif
+Index: qt-maemo-qtp/src/opengl/opengl.pro
+===================================================================
+--- qt-maemo-qtp.orig/src/opengl/opengl.pro
++++ qt-maemo-qtp/src/opengl/opengl.pro
+@@ -58,7 +58,9 @@
+                 gl2paintengineex/qglcustomshaderstage_p.h \
+                 gl2paintengineex/qtriangulatingstroker_p.h \
+                 gl2paintengineex/qtriangulator_p.h \
+-                gl2paintengineex/qtextureglyphcache_gl_p.h
++                gl2paintengineex/qtextureglyphcache_gl_p.h \
++                gl2paintengineex/qglshadercache_p.h \
++                gl2paintengineex/qglshadercache_meego_p.h
+ 
+     SOURCES +=  qglshaderprogram.cpp \
+                 qglpixmapfilter.cpp \
+Index: qt-maemo-qtp/src/opengl/util/meego/main.cpp
+===================================================================
+--- /dev/null
++++ qt-maemo-qtp/src/opengl/util/meego/main.cpp
+@@ -0,0 +1,48 @@
++#include <QtCore/qdebug.h>
++
++#define QT_DEBUG_SHADER_CACHE
++#define QT_MEEGO_EXPERIMENTAL_SHADERCACHE
++#define QT_OPENGL_ES_2
++#define QT_BOOTSTRAPPED
++
++typedef int GLsizei;
++typedef unsigned int GLenum;
++
++#include "../../gl2paintengineex/qglshadercache_meego_p.h"
++
++#include <stdlib.h>
++#include <stdio.h>
++
++int main()
++{
++    ShaderCacheSharedMemory shm;
++
++    if (!shm.isAttached()) {
++        fprintf(stderr, "Unable to attach to shared memory\n");
++        return EXIT_FAILURE;
++    }
++
++    ShaderCacheLocker locker(&shm);
++    if (!locker.isLocked()) {
++        fprintf(stderr, "Unable to lock shared memory\n");
++        return EXIT_FAILURE;
++    }
++
++    void *data = shm.data();
++    Q_ASSERT(data);
++
++    CachedShaders *cache = reinterpret_cast<CachedShaders *>(data);
++
++    for (int i = 0; i < cache->shaderCount; ++i) {
++        printf("Shader %d: %d bytes\n", i, cache->headers[i].size);
++    }
++
++    printf("\nSummary:\n\n"
++           "    Amount of cached shaders: %d\n"
++           "                  Bytes used: %d\n"
++           "             Bytes available: %d\n",
++           cache->shaderCount, cache->dataSize, cache->availableSize());
++
++    return EXIT_SUCCESS;
++}
++
+Index: qt-maemo-qtp/src/opengl/util/meego/shader-cache-introspector.pro
+===================================================================
+--- /dev/null
++++ qt-maemo-qtp/src/opengl/util/meego/shader-cache-introspector.pro
+@@ -0,0 +1,7 @@
++TEMPLATE = app
++
++SOURCES += main.cpp
++
++TARGET = shader-cache-introspector
++
++QT = core