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