Merge lp:~afrantzis/ubuntu/maverick/glmemperf/ignore-problematic-benchmarks into lp:ubuntu/maverick/glmemperf

[Alexandros Frantzis]

[Stefano Rivera (stefanor)]

Have these patches been forwarded upstream? If so please update the quilt headers appropriately. If not, please do so :)

[Stefano Rivera (stefanor)]

review: Needs Fixing

[lp:~afrantzis/ubuntu/maverick/glmemperf/ignore-problematic-benchmarks]

4. By Alexandros Frantzis on 2010-08-04

* debian/patches/*.patch: Add 'Bug' field for patches that have been forwarded upstream.

[Alexandros Frantzis (afrantzis)]

I have forwarded the relevant patches upstream and have updated the quilt headers to reflect this.

Thanks!

[Stefano Rivera (stefanor)]

review: Approve

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2010-06-30 11:17:12 +0000
+++ .pc/applied-patches	2010-08-04 08:33:44 +0000
@@ -1,4 +1,6 @@
 optional_gles2_defines.patch
 add_missing_includes.patch
+exception_instead_of_assert.patch
+do_not_use_invalid_egl_config.patch
 no_makefile_in_debian_dir.patch
 autoreconf.patch

=== added directory '.pc/do_not_use_invalid_egl_config.patch'
=== added file '.pc/do_not_use_invalid_egl_config.patch/glmemperf.cpp'
--- .pc/do_not_use_invalid_egl_config.patch/glmemperf.cpp	1970-01-01 00:00:00 +0000
+++ .pc/do_not_use_invalid_egl_config.patch/glmemperf.cpp	2010-08-04 08:33:44 +0000
@@ -0,0 +1,503 @@
+/**
+ * OpenGL ES 2.0 memory performance estimator
+ * Copyright (C) 2009 Nokia
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * \author Sami Kyöstilä <[e-mail]>
+ */
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <X11/Xutil.h>
+#include <EGL/egl.h>
+#include <string>
+#include <unistd.h>
+#include <time.h>
+#include <memory>
+#include <list>
+#include <iostream>
+#include <algorithm>
+#include <sys/stat.h>
+#include <stdio.h>
+
+#include "native.h"
+#include "util.h"
+#include "test.h"
+#include "blittest.h"
+#include "cleartest.h"
+#include "pixmapblittest.h"
+#include "fboblittest.h"
+#include "shaderblittest.h"
+#include "cpuinterleavingtest.h"
+#include "config.h"
+
+#if defined(HAVE_LIBOSSO)
+#include <libosso.h>
+#endif
+
+/**
+ *  Command line options
+ */
+static struct
+{
+    int                    bitsPerPixel;
+    bool                   verbose;
+    int                    minTime;
+    std::list<std::string> includedTests;
+    std::list<std::string> excludedTests;
+} options;
+
+/** Shared EGL objects */
+struct Context ctx;
+
+#if defined(HAVE_LIBOSSO)
+osso_context_t* ossoContext;
+#endif
+
+bool initializeEgl(int width, int height, const EGLint* configAttrs, const EGLint* contextAttrs)
+{
+    EGLint configCount = 0;
+    
+#if defined(HAVE_LIBOSSO)
+    ossoContext = osso_initialize("com.nokia.memperf", "1.0", FALSE, NULL);
+    if (!ossoContext)
+    {
+        perror("osso_initialize");
+        goto out_error;
+    }
+#endif
+
+    ctx.dpy = eglGetDisplay(ctx.nativeDisplay);
+    ASSERT_EGL();
+   
+    eglInitialize(ctx.dpy, NULL, NULL);
+    eglChooseConfig(ctx.dpy, configAttrs, &ctx.config, 1, &configCount);
+    ASSERT_EGL();
+
+    if (!configCount)
+    {
+        printf("Config not found\n");
+        goto out_error;
+    }
+
+    if (options.verbose)
+    {
+        printf("Config attributes:\n");
+        dumpConfig(ctx.dpy, ctx.config);
+    }
+
+    if (!nativeCreateWindow(ctx.nativeDisplay, ctx.dpy, ctx.config, __FILE__,
+                            width, height, &ctx.win))
+    {
+        printf("Unable to create a window\n");
+        goto out_error;
+    }
+
+    ctx.context = eglCreateContext(ctx.dpy, ctx.config, EGL_NO_CONTEXT, contextAttrs);
+    ASSERT_EGL();
+    if (!ctx.context)
+    {
+        printf("Unable to create a context\n");
+        goto out_error;
+    }
+    
+    ctx.surface = eglCreateWindowSurface(ctx.dpy, ctx.config, ctx.win, NULL);
+    ASSERT_EGL();
+    if (!ctx.surface)
+    {
+        printf("Unable to create a surface\n");
+        goto out_error;
+    }
+
+    eglMakeCurrent(ctx.dpy, ctx.surface, ctx.surface, ctx.context);
+    ASSERT_EGL();
+    
+    eglSwapInterval(ctx.dpy, 0);
+    return true;
+
+out_error:
+    eglMakeCurrent(ctx.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    eglDestroySurface(ctx.dpy, ctx.surface);
+    eglDestroyContext(ctx.dpy, ctx.context);
+    eglTerminate(ctx.dpy);
+    nativeDestroyWindow(ctx.nativeDisplay, ctx.win);
+    nativeDestroyDisplay(ctx.nativeDisplay);
+    return false;
+}
+
+void terminateEgl()
+{
+    eglMakeCurrent(ctx.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    eglDestroySurface(ctx.dpy, ctx.surface);
+    eglDestroyContext(ctx.dpy, ctx.context);
+    eglTerminate(ctx.dpy);
+    nativeDestroyWindow(ctx.nativeDisplay, ctx.win);
+    nativeDestroyDisplay(ctx.nativeDisplay);
+
+#if defined(HAVE_LIBOSSO)
+    osso_deinitialize(ossoContext);
+    ossoContext = 0;
+#endif
+}
+
+int64_t timeDiff(const struct timespec& start, const struct timespec& end)
+{
+    int64_t s = start.tv_sec * (1000 * 1000 * 1000LL) + start.tv_nsec;
+    int64_t e =   end.tv_sec * (1000 * 1000 * 1000LL) +   end.tv_nsec;
+    return e - s;
+}
+
+bool shouldRunTest(const std::string& testName)
+{
+    std::list<std::string>::iterator i;
+    bool result = true;
+
+    if (options.includedTests.size())
+    {
+        result = false;
+        for (i = options.includedTests.begin(); i != options.includedTests.end(); ++i)
+        {
+            if (testName.find(*i) != std::string::npos)
+            {
+                result = true;
+                break;
+            }
+        }
+    }
+
+    for (i = options.excludedTests.begin(); i != options.excludedTests.end(); ++i)
+    {
+        if (testName.find(*i) != std::string::npos)
+        {
+            result = false;
+            break;
+        }
+    }
+
+    return result;
+}
+
+void runTest(Test& test)
+{
+    int frames = 0;
+    int frameLimit = 100;
+    int warmup = 20;
+    int64_t minTime = options.minTime * 1000 * 1000 * 1000LL;
+    struct timespec res, start, end;
+
+    if (!shouldRunTest(test.name()))
+    {
+        return;
+    }
+
+    clock_getres(CLOCK_REALTIME, &res);
+    //printf("Timer resolution: %d.%09d s\n", res.tv_sec, res.tv_nsec);
+    printf("%-40s", (test.name() + ":").c_str());
+    fflush(stdout);
+
+    try
+    {
+        test.prepare();
+        ASSERT_GL();
+        ASSERT_EGL();
+    } catch (const std::exception& e)
+    {
+        printf("%s\n", e.what());
+        return;
+    }
+
+    while (warmup--)
+    {
+        test(0);
+        swapBuffers();
+    }
+
+    ASSERT_GL();
+    ASSERT_EGL();
+
+#if defined(HAVE_LIBOSSO)
+    osso_display_blanking_pause(ossoContext);
+#endif
+
+    clock_gettime(CLOCK_REALTIME, &start);
+    while (frames < frameLimit)
+    {
+        test(frames);
+        swapBuffers();
+        clock_gettime(CLOCK_REALTIME, &end);
+        frames++;
+        if (frames >= frameLimit && timeDiff(start, end) < minTime)
+        {
+            frameLimit *= 2;
+        }
+    }
+
+    ASSERT_GL();
+    ASSERT_EGL();
+    
+    test.teardown();
+    ASSERT_GL();
+    ASSERT_EGL();
+
+    int64_t diff = timeDiff(start, end);
+    int fps = static_cast<int>((1000 * 1000 * 1000LL * frames) / diff);
+    //printf("%d frames in %6.2f ms (%3d fps) ", frames, diff / (1000.0f * 1000.0f), fps);
+    printf("%3d fps ", fps);
+
+    while (fps > 0)
+    {
+        fputc('#', stdout);
+        fps -= 3;
+    }
+    fputc('\n', stdout);
+}
+
+void getScreenSize(int& width, int& height)
+{
+    Window rootWindow = DefaultRootWindow(ctx.nativeDisplay);
+    XWindowAttributes rootAttrs;
+
+    XGetWindowAttributes(ctx.nativeDisplay, rootWindow, &rootAttrs);
+
+    width = rootAttrs.width;
+    height = rootAttrs.height;
+}
+
+void showIntro()
+{
+    std::cout << 
+        "GLMemPerf v" PACKAGE_VERSION " - OpenGL ES 2.0 memory performance benchmark\n"
+        "Copyright (C) 2009 Nokia Corporation. GLMemPerf comes with ABSOLUTELY\n"
+        "NO WARRANTY; This is free software, and you are welcome to redistribute\n"
+        "it under certain conditions.\n"
+        "\n";
+}
+
+void showUsage()
+{
+    std::cout << 
+        "Usage:\n"
+        "       glmemperf [OPTIONS]\n"
+        "Options:\n"
+        "       -h             This text\n"
+        "       -v             Verbose mode\n"
+        "       -i TEST        Include a specific test (full name or substring)\n"
+        "       -e TEST        Exclude a specific test (full name or substring)\n"
+        "       -t SECS        Minimum time to run each test\n"
+        "       -b BPP         Bits per pixel\n";
+}
+
+void parseArguments(const std::list<std::string>& args)
+{
+    std::list<std::string>::const_iterator i;
+
+    // Set up defaults
+    options.verbose = false;
+    options.minTime = 1;
+    options.bitsPerPixel = 16;
+
+    for (i = args.begin(), i++; i != args.end(); ++i)
+    {
+        if (*i == "-h" || *i == "--help")
+        {
+            showUsage();
+            exit(0);
+        }
+        else if (*i == "-i" && ++i != args.end())
+        {
+            options.includedTests.push_back(*i);
+        }
+        else if (*i == "-e" && ++i != args.end())
+        {
+            options.excludedTests.push_back(*i);
+        }
+        else if (*i == "-t" && ++i != args.end())
+        {
+            options.minTime = atoi((*i).c_str());
+        }
+        else if (*i == "-b" && ++i != args.end())
+        {
+            options.bitsPerPixel = atoi((*i).c_str());
+        }
+        else if (*i == "-v")
+        {
+            options.verbose = true;
+        }
+        else
+        {
+            std::cerr << "Invalid option: " << *i << std::endl;
+            showUsage();
+            exit(1);
+        }
+    }
+}
+
+void findDataDirectory()
+{
+    struct stat st;
+    if (stat("data", &st) == 0)
+    {
+        return;
+    }
+    chdir(PREFIX "/share/glmemperf/");
+    assert(stat("data", &st) == 0);
+}
+
+#define ADD_TEST(TEST) runTest(*std::auto_ptr<Test>(new TEST));
+
+int main(int argc, char** argv)
+{
+    std::list<std::string> args(argv, argv + argc);
+    
+    showIntro();
+    parseArguments(args);
+    findDataDirectory();
+
+    const EGLint configAttrs[] =
+    {
+        EGL_BUFFER_SIZE, options.bitsPerPixel,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_NONE
+    };
+
+    const EGLint configAttrs32[] =
+    {
+        EGL_BUFFER_SIZE, 32,
+        EGL_NONE
+    };
+
+    const EGLint contextAttrs[] =
+    {
+        EGL_CONTEXT_CLIENT_VERSION, 2,
+        EGL_NONE
+    };
+    int winWidth = 800;
+    int winHeight = 480;
+    const float w = winWidth, h = winHeight;
+    EGLConfig config32 = 0;
+    EGLint configCount = 0;
+
+    bool result = nativeCreateDisplay(&ctx.nativeDisplay);
+    assert(result);
+
+    getScreenSize(winWidth, winHeight);
+    result = initializeEgl(winWidth, winHeight, configAttrs, contextAttrs);
+    assert(result);
+
+    eglChooseConfig(ctx.dpy, configAttrs32, &config32, 1, &configCount);
+
+    if (!configCount)
+    {
+        printf("32bpp config not found\n");
+    }
+
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    ASSERT_GL();
+
+    // Clear test
+    ADD_TEST(ClearTest());
+
+    // Normal blits
+    ADD_TEST(BlitTest(GL_RGBA, GL_UNSIGNED_BYTE,              800, 480, "data/water2_800x480_rgba8888.raw"));
+    ADD_TEST(BlitTest(GL_RGB,  GL_UNSIGNED_BYTE,              800, 480, "data/water2_800x480_rgb888.raw"));
+    ADD_TEST(BlitTest(GL_RGBA, GL_UNSIGNED_BYTE,             1024, 512, "data/digital_nature2_1024x512_rgba8888.raw", false, 800.0 / 1024, 480.0 / 512));
+    ADD_TEST(BlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5,       800, 480, "data/water2_800x480_rgb565.raw"));
+    ADD_TEST(BlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5,      1024, 512, "data/digital_nature2_1024x512_rgb565.raw", false, 800.0 / 1024, 480.0 / 512));
+#ifdef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+    ADD_TEST(BlitTest(GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, 0, 1024, 512, "data/abstract3_1024x512_pvrtc4.raw", false, 800.0 / 1024, 480.0 / 512));
+#endif
+#ifdef GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG
+    ADD_TEST(BlitTest(GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG, 0, 1024, 512, "data/abstract3_1024x512_pvrtc2.raw", false, 800.0 / 1024, 480.0 / 512));
+#endif
+    ADD_TEST(BlitTest(GL_ETC1_RGB8_OES,                   0, 1024, 512, "data/abstract3_1024x512_etc1.raw", false, 800.0 / 1024, 480.0 / 512));
+    ADD_TEST(PixmapBlitTest(w, h, ctx.config));
+    ADD_TEST(PixmapBlitTest(w, h, config32));
+    ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,          w, h));
+    ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,          1024, 512, false, w / 1024, h / 512));
+    ADD_TEST(FBOBlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5,   w, h));
+    ADD_TEST(FBOBlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5,   1024, 512, false, w / 1042, h / 512));
+
+    // Rotated blits
+    ADD_TEST(BlitTest(GL_RGBA, GL_UNSIGNED_BYTE,              480,  800, "data/water2_480x800_rgba8888.raw", true));
+    ADD_TEST(BlitTest(GL_RGB,  GL_UNSIGNED_BYTE,              480,  800, "data/water2_480x800_rgb888.raw", true));
+    ADD_TEST(BlitTest(GL_RGBA, GL_UNSIGNED_BYTE,              512, 1024, "data/digital_nature2_512x1024_rgba8888.raw", true, 480.0 / 512, 800.0 / 1024));
+    ADD_TEST(BlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5,       480,  800, "data/water2_480x800_rgb565.raw", true));
+    ADD_TEST(BlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5,       512, 1024, "data/digital_nature2_512x1024_rgb565.raw", true, 480.0 / 512, 800.0 / 1024));
+#ifdef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+    ADD_TEST(BlitTest(GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, 0,  512, 1024, "data/abstract3_512x1024_pvrtc4.raw", true, 480.0 / 512, 800.0 / 1024));
+#endif
+#ifdef GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG
+    ADD_TEST(BlitTest(GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG, 0,  512, 1024, "data/abstract3_512x1024_pvrtc2.raw", true, 480.0 / 512, 800.0 / 1024));
+#endif
+    ADD_TEST(BlitTest(GL_ETC1_RGB8_OES,                   0,  512, 1024, "data/abstract3_512x1024_etc1.raw", true, 480.0 / 512, 800.0 / 1024));
+    ADD_TEST(PixmapBlitTest(h, w, ctx.config, true));
+    ADD_TEST(PixmapBlitTest(h, w, config32,   true));
+    ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,        w, h, true, h / w, w / h));
+    ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,        1024, 512, true, h / 512, w / 1024));
+    ADD_TEST(FBOBlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5, w, h, true, h / w, w / h));
+    ADD_TEST(FBOBlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5, 1024, 512, true, h / 512, w / 1024));
+
+    int gridW = 5;
+    int gridH = 3;
+    float w2 = winWidth  / gridW;
+    float h2 = winHeight / gridH;
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    // Small blended blits
+    ADD_TEST(BlitTest(GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4,     128, 128, "data/xorg_128x128_rgba4444.raw", false, gridW, gridH, 128.0 / w2, 128.0 / h2));
+    ADD_TEST(BlitTest(GL_RGBA, GL_UNSIGNED_BYTE,              127, 127, "data/xorg_127x127_rgba8888.raw", false, gridW, gridH, 127.0 / w2, 127.0 / h2));
+    ADD_TEST(BlitTest(GL_RGBA, GL_UNSIGNED_BYTE,              128, 128, "data/xorg_128x128_rgba8888.raw", false, gridW, gridH, 128.0 / w2, 128.0 / h2));
+    ADD_TEST(BlitTest(GL_RGB, GL_UNSIGNED_SHORT_5_6_5,        127, 127, "data/xorg_127x127_rgb565.raw",   false, gridW, gridH, 127.0 / w2, 127.0 / h2));
+    ADD_TEST(BlitTest(GL_RGB, GL_UNSIGNED_SHORT_5_6_5,        128, 128, "data/xorg_128x128_rgb565.raw",   false, gridW, gridH, 128.0 / w2, 128.0 / h2));
+#ifdef GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+    ADD_TEST(BlitTest(GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, 0, 128, 128, "data/xorg_128x128_pvrtc4.raw",   false, gridW, gridH, 128.0 / w2, 128.0 / h2));
+#endif
+#ifdef GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
+    ADD_TEST(BlitTest(GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, 0, 128, 128, "data/xorg_128x128_pvrtc2.raw",   false, gridW, gridH, 128.0 / w2, 128.0 / h2));
+#endif
+    ADD_TEST(BlitTest(GL_ETC1_RGB8_OES,                    0, 128, 128, "data/xorg_128x128_etc1.raw",     false, gridW, gridH, 128.0 / w2, 128.0 / h2));
+    ADD_TEST(ShaderBlitTest("mask", 128, 128, gridW, gridH * 0.5f, 128.0 / w2, 128.0 / h2));
+
+    // Rotated small blended blits
+    ADD_TEST(BlitTest(GL_RGBA, GL_UNSIGNED_BYTE,              127, 127, "data/xorg_127x127_rgba8888.raw", true, gridH, gridW, 127.0 / w2, 127.0 / h2));
+    ADD_TEST(BlitTest(GL_RGBA, GL_UNSIGNED_BYTE,              128, 128, "data/xorg_128x128_rgba8888.raw", true, gridH, gridW, 128.0 / w2, 128.0 / h2));
+    ADD_TEST(BlitTest(GL_RGB, GL_UNSIGNED_SHORT_5_6_5,        127, 127, "data/xorg_127x127_rgb565.raw",   true, gridH, gridW, 127.0 / w2, 127.0 / h2));
+    ADD_TEST(BlitTest(GL_RGB, GL_UNSIGNED_SHORT_5_6_5,        128, 128, "data/xorg_128x128_rgb565.raw",   true, gridH, gridW, 128.0 / w2, 128.0 / h2));
+#ifdef GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+    ADD_TEST(BlitTest(GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, 0, 128, 128, "data/xorg_128x128_pvrtc4.raw",   true, gridH, gridW, 128.0 / w2, 128.0 / h2));
+#endif
+#ifdef GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
+    ADD_TEST(BlitTest(GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, 0, 128, 128, "data/xorg_128x128_pvrtc2.raw",   true, gridH, gridW, 128.0 / w2, 128.0 / h2));
+#endif
+    ADD_TEST(BlitTest(GL_ETC1_RGB8_OES,                    0, 128, 128, "data/xorg_128x128_etc1.raw",     true, gridH, gridW, 128.0 / w2, 128.0 / h2));
+
+    glDisable(GL_BLEND);
+
+    // Shader tests
+    ADD_TEST(ShaderBlitTest("const", w, h));
+    ADD_TEST(ShaderBlitTest("lingrad", w, h));
+    ADD_TEST(ShaderBlitTest("radgrad", w, h));
+    ADD_TEST(ShaderBlitTest("palette", w, h));
+    
+    // CPU interleaving
+    ADD_TEST(CPUInterleavingTest(CPUI_XSHM_IMAGE, 2, 16, winWidth, winHeight));
+    ADD_TEST(CPUInterleavingTest(CPUI_XSHM_IMAGE, 2, 32, winWidth, winHeight));
+    ADD_TEST(CPUInterleavingTest(CPUI_TEXTURE_UPLOAD, 2, 16, winWidth, winHeight));
+    ADD_TEST(CPUInterleavingTest(CPUI_TEXTURE_UPLOAD, 2, 32, winWidth, winHeight));
+
+    terminateEgl();
+}

=== added directory '.pc/exception_instead_of_assert.patch'
=== added file '.pc/exception_instead_of_assert.patch/cpuinterleavingtest.cpp'
--- .pc/exception_instead_of_assert.patch/cpuinterleavingtest.cpp	1970-01-01 00:00:00 +0000
+++ .pc/exception_instead_of_assert.patch/cpuinterleavingtest.cpp	2010-08-04 08:33:44 +0000
@@ -0,0 +1,315 @@
+/**
+ * OpenGL ES 2.0 memory performance estimator
+ * Copyright (C) 2009 Nokia
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * \author Sami Kyöstilä <[e-mail]>
+ *
+ * CPU texture streaming test
+ */
+#include "cpuinterleavingtest.h"
+#include "util.h"
+#include "native.h"
+#include <sstream>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/XShm.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <stdio.h>
+
+template <typename TYPE>
+void fillTexture(TYPE* pixels, int width, int height, int stride, int frame)
+{
+    TYPE color = (TYPE)0xffffffffu;
+    for (int y = 0; y < height; y++)
+    {
+        for (int x = 0; x < width; x++)
+        {
+            if ((x + y + frame) & 0x10)
+            {
+                pixels[x] = color;
+            }
+            else
+            {
+                pixels[x] = 0;
+            }
+        }
+        pixels += stride / sizeof(TYPE);
+    }
+}
+
+CPUInterleavingTest::CPUInterleavingTest(CPUInterleavingMethod method,
+					 int buffers, int bitsPerPixel,
+					 int width, int height,
+                                         float texW, float texH):
+    BlitTest(width, height, false, texW, texH),
+    m_method(method),
+    m_buffers(buffers),
+    m_dataBitsPerPixel(bitsPerPixel),
+    m_readBuffer(buffers - 1),
+    m_writeBuffer(0)
+{
+}
+
+
+void CPUInterleavingTest::prepare()
+{
+    int i;
+    bool success;
+
+    BlitTest::prepare();
+
+    glGenTextures(m_buffers, m_textures);
+    for (int i = 0; i < m_buffers; i++)
+    {
+	glBindTexture(GL_TEXTURE_2D, m_textures[i]);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    }
+
+    ASSERT_GL();
+
+    switch (m_method)
+    {
+    case CPUI_TEXTURE_UPLOAD:
+	{
+	    m_dataStride = m_width * m_dataBitsPerPixel / 8;
+	    for (i = 0; i < m_buffers; i++)
+	    {
+		m_textureData[i] = new char[m_height * m_dataStride];
+	    }
+	}
+	break;
+    case CPUI_XSHM_IMAGE:
+        {
+            Status shmSupported = XShmQueryExtension(ctx.nativeDisplay);
+            if (!shmSupported)
+            {
+                fail("X11 shared memory extension not supported");
+            }
+
+            m_completionEvent = XShmGetEventBase(ctx.nativeDisplay) + ShmCompletion;
+
+            const EGLint pixmapConfigAttrs[] =
+            {
+                EGL_BUFFER_SIZE, m_dataBitsPerPixel,
+                EGL_NONE
+            };
+            EGLint configCount = 0;
+
+            eglChooseConfig(ctx.dpy, pixmapConfigAttrs, &m_config, 1, &configCount);
+            assert(configCount);
+
+	    for (i = 0; i < m_buffers; i++)
+	    {
+                success = nativeCreatePixmap(ctx.nativeDisplay, ctx.dpy,
+                                             m_config, m_width, m_height, &m_pixmaps[i]);
+                assert(success);
+
+                XGCValues gcValues;
+                m_gc[i] = XCreateGC(ctx.nativeDisplay, m_pixmaps[i], 0, &gcValues);
+
+                const EGLint surfAttrs[] =
+                {
+                    EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB,
+                    EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
+                    EGL_MIPMAP_TEXTURE, EGL_FALSE,
+                    EGL_NONE
+                };
+
+                m_surfaces[i] = eglCreatePixmapSurface(ctx.dpy, m_config, m_pixmaps[i], surfAttrs);
+                assert(m_surfaces[i] != EGL_NO_SURFACE);
+
+                glBindTexture(GL_TEXTURE_2D, m_textures[i]);
+                success = eglBindTexImage(ctx.dpy, m_surfaces[i], EGL_BACK_BUFFER);
+                assert(success);
+                
+                XVisualInfo visualInfo;
+                XVisualInfo* visual;
+                int visualCount = 0;
+                visualInfo.depth = m_dataBitsPerPixel;
+                visualInfo.screen = DefaultScreen(ctx.nativeDisplay);
+                visual = XGetVisualInfo(ctx.nativeDisplay, VisualDepthMask | VisualScreenMask, 
+                                        &visualInfo, &visualCount);
+
+                assert(visualCount > 0);
+
+                m_ximage[i] = XShmCreateImage(ctx.nativeDisplay, visual->visual, m_dataBitsPerPixel,
+                                              ZPixmap, NULL,
+                                              &m_shminfo[i], m_width, m_height);
+                m_shminfo[i].shmid = shmget(IPC_PRIVATE, 
+                                            m_ximage[i]->bytes_per_line *
+                                            m_ximage[i]->height, IPC_CREAT | 0777);
+                m_shminfo[i].shmaddr = m_ximage[i]->data = (char*)shmat(m_shminfo[i].shmid, 0, 0);
+                assert(m_shminfo[i].shmaddr);
+                m_shminfo[i].readOnly = False;
+                Status status = XShmAttach(ctx.nativeDisplay, &m_shminfo[i]);
+                assert(status);
+
+                m_textureData[i] = m_ximage[i]->data;
+                m_dataStride = m_ximage[i]->bytes_per_line;
+                m_writeCompleted[i] = true;
+                m_drawableIndex[m_pixmaps[i]] = i;
+	    }
+        }
+        break;
+    default:
+	assert(0);
+	return;
+    }
+}
+
+void CPUInterleavingTest::teardown()
+{
+    int i;
+    glDeleteTextures(m_buffers, m_textures);
+
+    switch (m_method)
+    {
+    case CPUI_TEXTURE_UPLOAD:
+	{
+	    for (i = 0; i < m_buffers; i++)
+	    {
+		delete[] m_textureData[i];
+	    }
+	}
+	break;
+    case CPUI_XSHM_IMAGE:
+        {
+	    for (i = 0; i < m_buffers; i++)
+	    {
+                XShmDetach(ctx.nativeDisplay, &m_shminfo[i]);
+                XDestroyImage(m_ximage[i]);
+                shmdt(m_shminfo[i].shmaddr);
+                shmctl(m_shminfo[i].shmid, IPC_RMID, 0);
+
+                eglReleaseTexImage(ctx.dpy, m_surfaces[i], EGL_BACK_BUFFER);
+                eglDestroySurface(ctx.dpy, m_surfaces[i]);
+                nativeDestroyPixmap(ctx.nativeDisplay, m_pixmaps[i]);
+                XFreeGC(ctx.nativeDisplay, m_gc[i]);
+	    }
+        }
+        break;
+    default:
+	assert(0);
+	return;
+    }
+
+    BlitTest::teardown();
+}
+
+std::string CPUInterleavingTest::name() const
+{
+    std::stringstream s;
+
+    s << "blit_cpu_";
+
+    switch (m_method)
+    {
+    case CPUI_TEXTURE_UPLOAD:
+	s << "texupload";
+	break;
+    case CPUI_XSHM_IMAGE:
+	s << "shmimage";
+	break;
+    case CPUI_IMG_TEXTURE_STREAMING:
+	s << "texstream";
+        break;
+    case CPUI_PIXEL_BUFFER_OBJECT:
+	s << "pbo";
+	break;
+    case CPUI_EGL_LOCK_SURFACE:
+	s << "locksurf";
+	break;
+    }
+
+    switch (m_dataBitsPerPixel)
+    {
+    case 16:
+        s << "_16bpp";
+        break;
+    case 32:
+        s << "_32bpp";
+        break;
+    }
+
+    s << "_" << m_buffers << "x" << m_width << "x" << m_height;
+
+    return s.str();
+}
+
+void CPUInterleavingTest::operator()(int frame)
+{
+    switch (m_dataBitsPerPixel)
+    {
+    case 16:
+	fillTexture(reinterpret_cast<uint16_t*>(m_textureData[m_writeBuffer]),
+		    m_width, m_height, m_dataStride, frame);
+	break;
+    case 32:
+	fillTexture(reinterpret_cast<uint32_t*>(m_textureData[m_writeBuffer]),
+		    m_width, m_height, m_dataStride, frame);
+	break;
+    }
+
+    glBindTexture(GL_TEXTURE_2D, m_textures[m_writeBuffer]);
+
+    switch (m_method)
+    {
+    case CPUI_TEXTURE_UPLOAD:
+	if (m_dataBitsPerPixel == 32)
+	{
+	    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0,
+		         GL_RGBA, GL_UNSIGNED_BYTE, m_textureData[m_writeBuffer]);
+	}
+	else
+	{
+	    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_width, m_height, 0,
+		         GL_RGB, GL_UNSIGNED_SHORT_5_6_5, m_textureData[m_writeBuffer]);
+	}
+	break;
+    case CPUI_XSHM_IMAGE:
+        {
+            // Wait for the completion event for this buffer
+            while (XEventsQueued(ctx.nativeDisplay, QueuedAfterReading) > 0 ||
+                   !m_writeCompleted[m_writeBuffer])
+            {
+                XEvent event;
+                XNextEvent(ctx.nativeDisplay, &event);
+                if (event.type == m_completionEvent)
+                {
+                    XShmCompletionEvent* e = reinterpret_cast<XShmCompletionEvent*>(&event);
+                    int i = m_drawableIndex[e->drawable];
+                    m_writeCompleted[i] = true;
+                }
+            }
+            XShmPutImage(ctx.nativeDisplay, m_pixmaps[m_writeBuffer], m_gc[m_writeBuffer],
+                         m_ximage[m_writeBuffer], 0, 0, 0, 0, m_width, m_height, True);
+            m_writeCompleted[m_writeBuffer] = false;
+        }
+        break;
+    default:
+        assert(0);
+        break;
+    }
+
+    glBindTexture(GL_TEXTURE_2D, m_textures[m_readBuffer]);
+    m_writeBuffer = (m_writeBuffer + 1) % m_buffers;
+    m_readBuffer  = (m_readBuffer  + 1) % m_buffers;
+
+    BlitTest::operator()(frame);
+}

=== added file '.pc/exception_instead_of_assert.patch/util.h'
--- .pc/exception_instead_of_assert.patch/util.h	1970-01-01 00:00:00 +0000
+++ .pc/exception_instead_of_assert.patch/util.h	2010-08-04 08:33:44 +0000
@@ -0,0 +1,154 @@
+/**
+ * OpenGL ES 2.0 memory performance estimator
+ * Copyright (C) 2009 Nokia
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * \author Sami Kyöstilä <[e-mail]>
+ *
+ * EGL and OpenGL ES utility functions
+ */
+#ifndef UTIL_H
+#define UTIL_H
+
+#include <string>
+#include <GLES2/gl2.h>
+#include <EGL/egl.h>
+#include <assert.h>
+
+/**
+ *  Verify that GL commands up to this point have not produced any errors.
+ */
+#define ASSERT_GL() \
+    do \
+    { \
+        GLint err = glGetError(); \
+        if (err) \
+        { \
+            printf("GL error 0x%x (%d) at %s:%d\n", err, err, __FILE__, __LINE__); \
+            assert(!err); \
+        } \
+    } while (0)
+
+/**
+ *  Verify that EGL commands up to this point have not produced any errors.
+ */
+#define ASSERT_EGL() \
+    do \
+    { \
+        EGLint err = eglGetError(); \
+        if (err != EGL_SUCCESS) \
+        { \
+            printf("EGL error 0x%x (%d) at %s:%d\n", err, err, __FILE__, __LINE__); \
+            assert(!err); \
+        } \
+    } while (0)
+
+/**
+ *  EGL context objects available to all tests
+ */
+struct Context
+{
+    EGLNativeDisplayType nativeDisplay;
+    EGLConfig config;
+    EGLNativeWindowType win;
+    EGLDisplay dpy;
+    EGLContext context;
+    EGLSurface surface;
+};
+
+extern struct Context ctx;
+
+/**
+ *  Indicate that a frame is complete
+ */
+void swapBuffers();
+
+/**
+ *  Load a texture from a binary file
+ *
+ *  @param target               Texture target (usually GL_TEXTURE_2D)
+ *  @param level                Mipmap level
+ *  @param internalFormat       Internal texture format
+ *  @param width                Texture width in pixels
+ *  @param height               Texture height in pixels
+ *  @param type                 Data type
+ *  @param fileName             File containing the texture data
+ *
+ *  @returns true on success, false on failure
+ */
+bool loadRawTexture(GLenum target, int level, GLenum internalFormat, int width,
+                    int height, GLenum format, GLenum type, const std::string& fileName);
+
+/**
+ *  Load a compressed texture from a binary file
+ *
+ *  @param target               Texture target (usually GL_TEXTURE_2D)
+ *  @param internalFormat       Internal texture format
+ *  @param width                Texture width in pixels
+ *  @param height               Texture height in pixels
+ *  @param fileName             File containing the texture data
+ *
+ *  @returns true on success, false on failure
+ */
+bool loadCompressedTexture(GLenum target, int level, GLenum internalFormat, int width,
+                           int height, const std::string& fileName);
+
+/**
+ *  Check whether an EGL extension is supported
+ *
+ *  @param name                 Extension name
+ *
+ *  @returns true if extension is supported
+ */
+bool isEGLExtensionSupported(const std::string& name);
+
+/**
+ *  Check whether an OpenGL ES extension is supported
+ *
+ *  @param name                 Extension name
+ *
+ *  @returns true if extension is supported
+ */
+bool isGLExtensionSupported(const std::string& name);
+
+/**
+ *  Compile a vertex and fragment shader and create a new program from the
+ *  result
+ *
+ *  @param vertSrc              Vertex program source
+ *  @param fragSrc              Fragment program source
+ *
+ *  @returns new program handle
+ */
+GLint createProgram(const std::string& vertSrc, const std::string& fragSrc);
+
+/**
+ *  Describe a texture format and type combination
+ *
+ *  @param format               Texture format
+ *  @param type                 Texture type
+ */
+std::string textureFormatName(GLenum format, GLenum type);
+
+/**
+ *  Print EGL config attributes on the terminal
+ *
+ *  @param dpy                  EGL display
+ *  @param config               EGL config
+ */
+void dumpConfig(EGLDisplay dpy, EGLConfig config);
+
+#endif // UTIL_H

=== modified file 'cpuinterleavingtest.cpp'
--- cpuinterleavingtest.cpp	2010-06-30 11:17:12 +0000
+++ cpuinterleavingtest.cpp	2010-08-04 08:33:44 +0000
@@ -112,7 +112,8 @@
             EGLint configCount = 0;
 
             eglChooseConfig(ctx.dpy, pixmapConfigAttrs, &m_config, 1, &configCount);
-            assert(configCount);
+            if (configCount == 0)
+                throw GLException("No EGLConfig found");
 
 	    for (i = 0; i < m_buffers; i++)
 	    {

=== modified file 'debian/changelog'
--- debian/changelog	2010-06-30 11:17:12 +0000
+++ debian/changelog	2010-08-04 08:33:44 +0000
@@ -1,3 +1,15 @@
+glmemperf (0.1-0ubuntu2) maverick; urgency=low
+
+  * Ignore problematic benchmarks instead of aborting (LP: #605429)
+    - debian/patches/do_not_use_invalid_egl_config.patch:
+      - Use an EGL config only if it is valid.
+    - debian/patches/exception_instead_of_assert.patch:
+      - Throw an exception instead of aborting when a GL call fails.
+  * debian/patches/*.patch: Add 'Bug' field for patches that have been
+    forwarded upstream.
+
+ -- Alexandros Frantzis <[e-mail]>  Wed, 04 Aug 2010 11:27:21 +0300
+
 glmemperf (0.1-0ubuntu1) maverick; urgency=low
 
   * Initial release to linaro/maverick (LP: #600148)

=== modified file 'debian/patches/add_missing_includes.patch'
--- debian/patches/add_missing_includes.patch	2010-06-30 11:17:12 +0000
+++ debian/patches/add_missing_includes.patch	2010-08-04 08:33:44 +0000
@@ -1,6 +1,7 @@
 Description: Add missing includes that prevent compilation.
 Author: Alexandros Frantzis <[e-mail]>
-Last-Update: 2010-06-29
+Bug: https://garage.maemo.org/tracker/index.php?func=detail&aid=6168&group_id=1130&atid=4244
+Last-Update: 2010-08-04
 --- a/glmemperf.cpp
 +++ b/glmemperf.cpp
 @@ -30,6 +30,7 @@

=== added file 'debian/patches/do_not_use_invalid_egl_config.patch'
--- debian/patches/do_not_use_invalid_egl_config.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/do_not_use_invalid_egl_config.patch	2010-08-04 08:33:44 +0000
@@ -0,0 +1,26 @@
+Description: Use an EGL config only if it is valid
+Author: Alexandros Frantzis <[e-mail]>
+Bug: https://garage.maemo.org/tracker/index.php?func=detail&aid=6166&group_id=1130&atid=4244
+Last-Update: 2010-08-04
+--- a/glmemperf.cpp
++++ b/glmemperf.cpp
+@@ -423,7 +423,8 @@
+ #endif
+     ADD_TEST(BlitTest(GL_ETC1_RGB8_OES,                   0, 1024, 512, "data/abstract3_1024x512_etc1.raw", false, 800.0 / 1024, 480.0 / 512));
+     ADD_TEST(PixmapBlitTest(w, h, ctx.config));
+-    ADD_TEST(PixmapBlitTest(w, h, config32));
++    if (config32)
++        ADD_TEST(PixmapBlitTest(w, h, config32));
+     ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,          w, h));
+     ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,          1024, 512, false, w / 1024, h / 512));
+     ADD_TEST(FBOBlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5,   w, h));
+@@ -443,7 +444,8 @@
+ #endif
+     ADD_TEST(BlitTest(GL_ETC1_RGB8_OES,                   0,  512, 1024, "data/abstract3_512x1024_etc1.raw", true, 480.0 / 512, 800.0 / 1024));
+     ADD_TEST(PixmapBlitTest(h, w, ctx.config, true));
+-    ADD_TEST(PixmapBlitTest(h, w, config32,   true));
++    if (config32)
++        ADD_TEST(PixmapBlitTest(h, w, config32,   true));
+     ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,        w, h, true, h / w, w / h));
+     ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,        1024, 512, true, h / 512, w / 1024));
+     ADD_TEST(FBOBlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5, w, h, true, h / w, w / h));

=== added file 'debian/patches/exception_instead_of_assert.patch'
--- debian/patches/exception_instead_of_assert.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/exception_instead_of_assert.patch	2010-08-04 08:33:44 +0000
@@ -0,0 +1,59 @@
+Description: Throw an exception instead of aborting the program when a GL call fails
+Author: Alexandros Frantzis <[e-mail]>
+Bug: https://garage.maemo.org/tracker/index.php?func=detail&aid=6166&group_id=1130&atid=4244
+Last-Update: 2010-08-04
+--- a/cpuinterleavingtest.cpp
++++ b/cpuinterleavingtest.cpp
+@@ -112,7 +112,8 @@
+             EGLint configCount = 0;
+ 
+             eglChooseConfig(ctx.dpy, pixmapConfigAttrs, &m_config, 1, &configCount);
+-            assert(configCount);
++            if (configCount == 0)
++                throw GLException("No EGLConfig found");
+ 
+ 	    for (i = 0; i < m_buffers; i++)
+ 	    {
+--- a/util.h
++++ b/util.h
+@@ -28,6 +28,16 @@
+ #include <EGL/egl.h>
+ #include <assert.h>
+ 
++class GLException : public std::exception {
++public:
++    GLException(const char *what) : m_what(what) { }
++    ~GLException() throw() { }
++    const char *what() const throw() { return m_what.c_str(); }
++
++private:
++    std::string m_what;
++};
++
+ /**
+  *  Verify that GL commands up to this point have not produced any errors.
+  */
+@@ -37,8 +47,9 @@
+         GLint err = glGetError(); \
+         if (err) \
+         { \
+-            printf("GL error 0x%x (%d) at %s:%d\n", err, err, __FILE__, __LINE__); \
+-            assert(!err); \
++            char msg[100]; \
++            snprintf(msg, 100, "GL error 0x%x (%d) at %s:%d", err, err, __FILE__, __LINE__); \
++            throw GLException(msg); \
+         } \
+     } while (0)
+ 
+@@ -51,8 +62,9 @@
+         EGLint err = eglGetError(); \
+         if (err != EGL_SUCCESS) \
+         { \
+-            printf("EGL error 0x%x (%d) at %s:%d\n", err, err, __FILE__, __LINE__); \
+-            assert(!err); \
++            char msg[100]; \
++            snprintf(msg, 100, "EGL error 0x%x (%d) at %s:%d", err, err, __FILE__, __LINE__); \
++            throw GLException(msg); \
+         } \
+     } while (0)
+ 

=== modified file 'debian/patches/optional_gles2_defines.patch'
--- debian/patches/optional_gles2_defines.patch	2010-06-30 11:17:12 +0000
+++ debian/patches/optional_gles2_defines.patch	2010-08-04 08:33:44 +0000
@@ -1,6 +1,7 @@
 Description: Don't add certain tests if the relevant GL texture format is missing.
 Author: Alexandros Frantzis <[e-mail]>
-Last-Update: 2010-06-29
+Bug: https://garage.maemo.org/tracker/index.php?func=detail&aid=6169&group_id=1130&atid=4244
+Last-Update: 2010-08-04
 --- a/glmemperf.cpp
 +++ b/glmemperf.cpp
 @@ -414,8 +414,12 @@

=== modified file 'debian/patches/series'
--- debian/patches/series	2010-06-30 11:17:12 +0000
+++ debian/patches/series	2010-08-04 08:33:44 +0000
@@ -1,4 +1,6 @@
 optional_gles2_defines.patch
 add_missing_includes.patch
+exception_instead_of_assert.patch
+do_not_use_invalid_egl_config.patch
 no_makefile_in_debian_dir.patch
 autoreconf.patch

=== modified file 'glmemperf.cpp'
--- glmemperf.cpp	2010-06-30 11:17:12 +0000
+++ glmemperf.cpp	2010-08-04 08:33:44 +0000
@@ -423,7 +423,8 @@
 #endif
     ADD_TEST(BlitTest(GL_ETC1_RGB8_OES,                   0, 1024, 512, "data/abstract3_1024x512_etc1.raw", false, 800.0 / 1024, 480.0 / 512));
     ADD_TEST(PixmapBlitTest(w, h, ctx.config));
-    ADD_TEST(PixmapBlitTest(w, h, config32));
+    if (config32)
+        ADD_TEST(PixmapBlitTest(w, h, config32));
     ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,          w, h));
     ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,          1024, 512, false, w / 1024, h / 512));
     ADD_TEST(FBOBlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5,   w, h));
@@ -443,7 +444,8 @@
 #endif
     ADD_TEST(BlitTest(GL_ETC1_RGB8_OES,                   0,  512, 1024, "data/abstract3_512x1024_etc1.raw", true, 480.0 / 512, 800.0 / 1024));
     ADD_TEST(PixmapBlitTest(h, w, ctx.config, true));
-    ADD_TEST(PixmapBlitTest(h, w, config32,   true));
+    if (config32)
+        ADD_TEST(PixmapBlitTest(h, w, config32,   true));
     ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,        w, h, true, h / w, w / h));
     ADD_TEST(FBOBlitTest(GL_RGBA, GL_UNSIGNED_BYTE,        1024, 512, true, h / 512, w / 1024));
     ADD_TEST(FBOBlitTest(GL_RGB,  GL_UNSIGNED_SHORT_5_6_5, w, h, true, h / w, w / h));

=== modified file 'util.h'
--- util.h	2010-06-30 11:17:12 +0000
+++ util.h	2010-08-04 08:33:44 +0000
@@ -28,6 +28,16 @@
 #include <EGL/egl.h>
 #include <assert.h>
 
+class GLException : public std::exception {
+public:
+    GLException(const char *what) : m_what(what) { }
+    ~GLException() throw() { }
+    const char *what() const throw() { return m_what.c_str(); }
+
+private:
+    std::string m_what;
+};
+
 /**
  *  Verify that GL commands up to this point have not produced any errors.
  */
@@ -37,8 +47,9 @@
         GLint err = glGetError(); \
         if (err) \
         { \
-            printf("GL error 0x%x (%d) at %s:%d\n", err, err, __FILE__, __LINE__); \
-            assert(!err); \
+            char msg[100]; \
+            snprintf(msg, 100, "GL error 0x%x (%d) at %s:%d", err, err, __FILE__, __LINE__); \
+            throw GLException(msg); \
         } \
     } while (0)
 
@@ -51,8 +62,9 @@
         EGLint err = eglGetError(); \
         if (err != EGL_SUCCESS) \
         { \
-            printf("EGL error 0x%x (%d) at %s:%d\n", err, err, __FILE__, __LINE__); \
-            assert(!err); \
+            char msg[100]; \
+            snprintf(msg, 100, "EGL error 0x%x (%d) at %s:%d", err, err, __FILE__, __LINE__); \
+            throw GLException(msg); \
         } \
     } while (0)