git.maemo.org Git - glmemperf/blob - util.cpp

   1 /**
   2  * OpenGL ES 2.0 memory performance estimator
   3  * Copyright (C) 2009 Nokia
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * \author Sami Kyöstilä <sami.kyostila@nokia.com>
  20  *
  21  * EGL and OpenGL ES utility functions
  22  */
  23 #include "util.h"
  24 #include <sys/mman.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <fcntl.h>
  30 #include <GLES2/gl2ext.h>
  31
  32 void swapBuffers()
  33 {
  34 #if 1
  35     eglSwapBuffers(ctx.dpy, ctx.surface);
  36 #else
  37     GLint pixel[4];
  38     glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixel);
  39 #endif
  40 }
  41
  42 bool loadRawTexture(GLenum target, int level, GLenum internalFormat, int width,
  43                     int height, GLenum format, GLenum type, const std::string& fileName)
  44 {
  45     int fd = open(fileName.c_str(), O_RDONLY);
  46
  47     if (fd == -1)
  48     {
  49         perror("open");
  50         return false;
  51     }
  52
  53     struct stat sb;
  54     if (fstat(fd, &sb) == -1)
  55     {
  56         perror("stat");
  57         return false;
  58     }
  59
  60     void* pixels = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
  61     glTexImage2D(target, level, internalFormat, width, height, 0, format, type, pixels);
  62
  63     munmap(pixels, sb.st_size);
  64     close(fd);
  65
  66     ASSERT_GL();
  67     return true;
  68 }
  69
  70 bool loadCompressedTexture(GLenum target, int level, GLenum internalFormat, int width,
  71                            int height, const std::string& fileName)
  72 {
  73     int fd = open(fileName.c_str(), O_RDONLY);
  74
  75     if (fd == -1)
  76     {
  77         perror("open");
  78         return false;
  79     }
  80
  81     struct stat sb;
  82     if (fstat(fd, &sb) == -1)
  83     {
  84         perror("stat");
  85         return false;
  86     }
  87
  88     void* pixels = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
  89     glCompressedTexImage2D(target, level, internalFormat, width, height, 0, sb.st_size, pixels);
  90
  91     munmap(pixels, sb.st_size);
  92     close(fd);
  93
  94     ASSERT_GL();
  95     return true;
  96 }
  97
  98 GLint createProgram(const std::string& vertSrc, const std::string& fragSrc)
  99 {
 100     GLint success = 0;
 101     GLint logLength = 0;
 102     char infoLog[1024];
 103     const char* vs = vertSrc.c_str();
 104     const char* fs = fragSrc.c_str();
 105
 106     GLint vertexShader = glCreateShader(GL_VERTEX_SHADER);
 107     glShaderSource(vertexShader, 1, &vs, 0);
 108     glCompileShader(vertexShader);
 109     glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
 110     if (!success)
 111     {
 112         glGetShaderInfoLog(vertexShader, sizeof(infoLog), &logLength, infoLog);
 113         printf("Vertex shader compilation failed:\n%s\n", infoLog);
 114     }
 115     assert(success);
 116
 117     GLint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
 118     glShaderSource(fragmentShader, 1, &fs, 0);
 119     glCompileShader(fragmentShader);
 120     glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
 121     if (!success)
 122     {
 123         glGetShaderInfoLog(fragmentShader, sizeof(infoLog), &logLength, infoLog);
 124         printf("Fragment shader compilation failed:\n%s\n", infoLog);
 125     }
 126     assert(success);
 127
 128     GLint program = glCreateProgram();
 129     glAttachShader(program, fragmentShader);
 130     glAttachShader(program, vertexShader);
 131     glLinkProgram(program);
 132     glGetProgramiv(program, GL_LINK_STATUS, &success);
 133     if (!success)
 134     {
 135         glGetProgramInfoLog(program, sizeof(infoLog), &logLength, infoLog);
 136         printf("Program linking failed:\n%s\n", infoLog);
 137     }
 138     assert(success);
 139     return program;
 140 }
 141
 142 std::string textureFormatName(GLenum format, GLenum type)
 143 {
 144     switch (type)
 145     {
 146     case GL_UNSIGNED_BYTE:
 147         return ((format == GL_RGB) ? "rgb888" : "rgba8888");
 148     case GL_UNSIGNED_SHORT_5_6_5:
 149         return "rgb565";
 150     case GL_UNSIGNED_SHORT_4_4_4_4:
 151         return "rgba4444";
 152     case GL_UNSIGNED_SHORT_5_5_5_1:
 153         return "rgba5551";
 154     case GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG:
 155         return "rgb_pvrtc4";
 156     case GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG:
 157         return "rgb_pvrtc2";
 158     case GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:
 159         return "rgba_pvrtc4";
 160     case GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:
 161         return "rgba_pvrtc2";
 162     case GL_ETC1_RGB8_OES:
 163         return "rgb_etc1";
 164     default:
 165         return "unknown";
 166     }
 167 }
 168
 169 #define DUMP_CFG_ATTRIB(attr, consts, bits) \
 170     do \
 171     { \
 172         EGLint value; \
 173         eglGetConfigAttrib(dpy, config, attr, &value); \
 174         ASSERT_EGL(); \
 175         printf("%-32s: %10d (0x%x)\n", #attr, value, value); \
 176         { \
 177             unsigned i; \
 178             for (i = 0; i < sizeof(consts) / sizeof(consts[0]); i++) \
 179             { \
 180                 if (value == consts[i].value) \
 181                 { \
 182                     printf("%-44s %s\n", "", consts[i].name); \
 183                 } \
 184             } \
 185         } \
 186         { \
 187             unsigned i; \
 188             for (i = 0; i < sizeof(bits) / sizeof(bits[0]); i++) \
 189             { \
 190                 if (value & bits[i].value) \
 191                 { \
 192                     printf("%-44s %s\n", "", bits[i].name); \
 193                 } \
 194             } \
 195         } \
 196     } while (0)
 197
 198 #define DECLARE_CONSTANTS(NAME) \
 199     static const struct { const char* name; EGLint value; } NAME[] =
 200
 201 #define C(constant) {#constant, constant}
 202
 203 #define DECLARE_BITFIELD(NAME) \
 204     static const struct { const char* name; EGLint value; } NAME[] =
 205
 206 #define B(bit) {#bit, bit}
 207
 208 DECLARE_CONSTANTS(defaultConsts)
 209 {
 210 };
 211
 212 DECLARE_BITFIELD(defaultBits)
 213 {
 214 };
 215
 216 DECLARE_CONSTANTS(configCaveatConsts)
 217 {
 218     C(EGL_NONE),
 219     C(EGL_SLOW_CONFIG),
 220     C(EGL_NON_CONFORMANT_CONFIG),
 221 };
 222
 223 DECLARE_CONSTANTS(transparentTypeConsts)
 224 {
 225     C(EGL_NONE),
 226     C(EGL_TRANSPARENT_RGB),
 227 };
 228
 229 DECLARE_CONSTANTS(colorBufferTypeConsts)
 230 {
 231     C(EGL_NONE),
 232     C(EGL_RGB_BUFFER),
 233     C(EGL_LUMINANCE_BUFFER),
 234 };
 235
 236 DECLARE_BITFIELD(surfaceTypeBits)
 237 {
 238     B(EGL_PBUFFER_BIT),
 239     B(EGL_PIXMAP_BIT),
 240     B(EGL_WINDOW_BIT),
 241     B(EGL_VG_COLORSPACE_LINEAR_BIT),
 242     B(EGL_VG_ALPHA_FORMAT_PRE_BIT),
 243     B(EGL_MULTISAMPLE_RESOLVE_BOX_BIT),
 244     B(EGL_SWAP_BEHAVIOR_PRESERVED_BIT),
 245 };
 246
 247 DECLARE_BITFIELD(renderableTypeBits)
 248 {
 249     B(EGL_OPENGL_ES_BIT),
 250     B(EGL_OPENVG_BIT),
 251     B(EGL_OPENGL_ES2_BIT),
 252     B(EGL_OPENGL_BIT),
 253 };
 254
 255 #undef C
 256 #undef DECLARE_CONSTANTS
 257 #undef B
 258 #undef DECLARE_BITFIELD
 259
 260 void dumpConfig(EGLDisplay dpy, EGLConfig config)
 261 {
 262     DUMP_CFG_ATTRIB(EGL_BUFFER_SIZE, defaultConsts, defaultBits);
 263     DUMP_CFG_ATTRIB(EGL_ALPHA_SIZE, defaultConsts, defaultBits);
 264     DUMP_CFG_ATTRIB(EGL_BLUE_SIZE, defaultConsts, defaultBits);
 265     DUMP_CFG_ATTRIB(EGL_GREEN_SIZE, defaultConsts, defaultBits);
 266     DUMP_CFG_ATTRIB(EGL_RED_SIZE, defaultConsts, defaultBits);
 267     DUMP_CFG_ATTRIB(EGL_DEPTH_SIZE, defaultConsts, defaultBits);
 268     DUMP_CFG_ATTRIB(EGL_STENCIL_SIZE, defaultConsts, defaultBits);
 269     DUMP_CFG_ATTRIB(EGL_CONFIG_CAVEAT, configCaveatConsts, defaultBits);
 270     DUMP_CFG_ATTRIB(EGL_CONFIG_ID, defaultConsts, defaultBits);
 271     DUMP_CFG_ATTRIB(EGL_LEVEL, defaultConsts, defaultBits);
 272     DUMP_CFG_ATTRIB(EGL_MAX_PBUFFER_HEIGHT, defaultConsts, defaultBits);
 273     DUMP_CFG_ATTRIB(EGL_MAX_PBUFFER_PIXELS, defaultConsts, defaultBits);
 274     DUMP_CFG_ATTRIB(EGL_MAX_PBUFFER_WIDTH, defaultConsts, defaultBits);
 275     DUMP_CFG_ATTRIB(EGL_NATIVE_RENDERABLE, defaultConsts, defaultBits);
 276     DUMP_CFG_ATTRIB(EGL_NATIVE_VISUAL_ID, defaultConsts, defaultBits);
 277     DUMP_CFG_ATTRIB(EGL_NATIVE_VISUAL_TYPE, defaultConsts, defaultBits);
 278     DUMP_CFG_ATTRIB(EGL_SAMPLES, defaultConsts, defaultBits);
 279     DUMP_CFG_ATTRIB(EGL_SAMPLE_BUFFERS, defaultConsts, defaultBits);
 280     DUMP_CFG_ATTRIB(EGL_SURFACE_TYPE, defaultConsts, surfaceTypeBits);
 281     DUMP_CFG_ATTRIB(EGL_TRANSPARENT_TYPE, transparentTypeConsts, defaultBits);
 282     DUMP_CFG_ATTRIB(EGL_TRANSPARENT_BLUE_VALUE, defaultConsts, defaultBits);
 283     DUMP_CFG_ATTRIB(EGL_TRANSPARENT_GREEN_VALUE, defaultConsts, defaultBits);
 284     DUMP_CFG_ATTRIB(EGL_TRANSPARENT_RED_VALUE, defaultConsts, defaultBits);
 285     DUMP_CFG_ATTRIB(EGL_BIND_TO_TEXTURE_RGB, defaultConsts, defaultBits);
 286     DUMP_CFG_ATTRIB(EGL_BIND_TO_TEXTURE_RGBA, defaultConsts, defaultBits);
 287     DUMP_CFG_ATTRIB(EGL_MIN_SWAP_INTERVAL, defaultConsts, defaultBits);
 288     DUMP_CFG_ATTRIB(EGL_MAX_SWAP_INTERVAL, defaultConsts, defaultBits);
 289     DUMP_CFG_ATTRIB(EGL_LUMINANCE_SIZE, defaultConsts, defaultBits);
 290     DUMP_CFG_ATTRIB(EGL_ALPHA_MASK_SIZE, defaultConsts, defaultBits);
 291     DUMP_CFG_ATTRIB(EGL_COLOR_BUFFER_TYPE, colorBufferTypeConsts, defaultBits);
 292     DUMP_CFG_ATTRIB(EGL_RENDERABLE_TYPE, defaultConsts, renderableTypeBits);
 293     DUMP_CFG_ATTRIB(EGL_CONFORMANT, defaultConsts, renderableTypeBits);
 294 }
 295
 296 #undef DUMP_CFG_ATTRIB
 297
 298 /* This is after http://www.opengl.org/resources/features/OGLextensions/ */
 299 static bool isExtensionSupported(const std::string& extensions, const std::string& name)
 300 {
 301     const char *start;
 302     const char *where, *terminator;
 303
 304     /* Extension names should not have spaces. */
 305     where = strchr(name.c_str(), ' ');
 306     if (where || !name.size())
 307     {
 308         return 0;
 309     }
 310
 311     /* It takes a bit of care to be fool-proof about parsing the
 312      OpenGL extensions string. Don't be fooled by sub-strings,
 313      etc. */
 314     start = extensions.c_str();
 315     for (;;)
 316     {
 317         where = strstr(start, name.c_str());
 318         if (!where)
 319             break;
 320         terminator = where + strlen(name.c_str());
 321         if (where == start || *(where - 1) == ' ')
 322             if (*terminator == ' ' || *terminator == '\0')
 323                 return 1;
 324         start = terminator;
 325     }
 326     return 0;
 327 }
 328
 329 bool isEGLExtensionSupported(const std::string& name)
 330 {
 331     return isExtensionSupported(eglQueryString(ctx.dpy, EGL_EXTENSIONS), name);
 332 }
 333
 334 bool isGLExtensionSupported(const std::string& name)
 335 {
 336     return isExtensionSupported((const char*)glGetString(GL_EXTENSIONS), name);
 337 }