cmds/flatland/GLHelper.cpp

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <GLES2/gl2.h>
  18 #include <GLES2/gl2ext.h>
  19
  20 #include <ui/DisplayInfo.h>
  21 #include <gui/SurfaceComposerClient.h>
  22
  23 #include "GLHelper.h"
  24
  25  namespace android {
  26
  27 GLHelper::GLHelper() :
  28     mGraphicBufferAlloc(new GraphicBufferAlloc()),
  29     mDisplay(EGL_NO_DISPLAY),
  30     mContext(EGL_NO_CONTEXT),
  31     mDummySurface(EGL_NO_SURFACE),
  32     mConfig(0),
  33     mShaderPrograms(NULL),
  34     mDitherTexture(0) {
  35 }
  36
  37 GLHelper::~GLHelper() {
  38 }
  39
  40 bool GLHelper::setUp(const ShaderDesc* shaderDescs, size_t numShaders) {
  41     bool result;
  42
  43     mDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  44     if (mDisplay == EGL_NO_DISPLAY) {
  45         fprintf(stderr, "eglGetDisplay error: %#x\n", eglGetError());
  46         return false;
  47     }
  48
  49     EGLint majorVersion;
  50     EGLint minorVersion;
  51     result = eglInitialize(mDisplay, &majorVersion, &minorVersion);
  52     if (result != EGL_TRUE) {
  53         fprintf(stderr, "eglInitialize error: %#x\n", eglGetError());
  54         return false;
  55     }
  56
  57     EGLint numConfigs = 0;
  58     EGLint configAttribs[] = {
  59         EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
  60         EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
  61         EGL_RED_SIZE, 8,
  62         EGL_GREEN_SIZE, 8,
  63         EGL_BLUE_SIZE, 8,
  64         EGL_ALPHA_SIZE, 8,
  65         EGL_NONE
  66     };
  67     result = eglChooseConfig(mDisplay, configAttribs, &mConfig, 1,
  68             &numConfigs);
  69     if (result != EGL_TRUE) {
  70         fprintf(stderr, "eglChooseConfig error: %#x\n", eglGetError());
  71         return false;
  72     }
  73
  74     EGLint contextAttribs[] = {
  75         EGL_CONTEXT_CLIENT_VERSION, 2,
  76         EGL_NONE
  77     };
  78     mContext = eglCreateContext(mDisplay, mConfig, EGL_NO_CONTEXT,
  79             contextAttribs);
  80     if (mContext == EGL_NO_CONTEXT) {
  81         fprintf(stderr, "eglCreateContext error: %#x\n", eglGetError());
  82         return false;
  83     }
  84
  85     bool resultb = createNamedSurfaceTexture(0, 1, 1, &mDummyGLConsumer,
  86             &mDummySurface);
  87     if (!resultb) {
  88         return false;
  89     }
  90
  91     resultb = makeCurrent(mDummySurface);
  92     if (!resultb) {
  93         return false;
  94     }
  95
  96     resultb = setUpShaders(shaderDescs, numShaders);
  97     if (!resultb) {
  98         return false;
  99     }
 100
 101     return true;
 102 }
 103
 104 void GLHelper::tearDown() {
 105     if (mShaderPrograms != NULL) {
 106         delete[] mShaderPrograms;
 107         mShaderPrograms = NULL;
 108     }
 109
 110     if (mSurfaceComposerClient != NULL) {
 111         mSurfaceComposerClient->dispose();
 112         mSurfaceComposerClient.clear();
 113     }
 114
 115     if (mDisplay != EGL_NO_DISPLAY) {
 116         eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
 117                 EGL_NO_CONTEXT);
 118     }
 119
 120     if (mContext != EGL_NO_CONTEXT) {
 121         eglDestroyContext(mDisplay, mContext);
 122     }
 123
 124     if (mDummySurface != EGL_NO_SURFACE) {
 125         eglDestroySurface(mDisplay, mDummySurface);
 126     }
 127
 128     mDisplay = EGL_NO_DISPLAY;
 129     mContext = EGL_NO_CONTEXT;
 130     mDummySurface = EGL_NO_SURFACE;
 131     mDummyGLConsumer.clear();
 132     mConfig = 0;
 133 }
 134
 135 bool GLHelper::makeCurrent(EGLSurface surface) {
 136     EGLint result;
 137
 138     result = eglMakeCurrent(mDisplay, surface, surface, mContext);
 139     if (result != EGL_TRUE) {
 140         fprintf(stderr, "eglMakeCurrent error: %#x\n", eglGetError());
 141         return false;
 142     }
 143
 144     EGLint w, h;
 145     eglQuerySurface(mDisplay, surface, EGL_WIDTH, &w);
 146     eglQuerySurface(mDisplay, surface, EGL_HEIGHT, &h);
 147     glViewport(0, 0, w, h);
 148
 149     return true;
 150 }
 151
 152 bool GLHelper::createSurfaceTexture(uint32_t w, uint32_t h,
 153         sp<GLConsumer>* glConsumer, EGLSurface* surface,
 154         GLuint* name) {
 155     if (!makeCurrent(mDummySurface)) {
 156         return false;
 157     }
 158
 159     *name = 0;
 160     glGenTextures(1, name);
 161     if (*name == 0) {
 162         fprintf(stderr, "glGenTextures error: %#x\n", glGetError());
 163         return false;
 164     }
 165
 166     return createNamedSurfaceTexture(*name, w, h, glConsumer, surface);
 167 }
 168
 169 void GLHelper::destroySurface(EGLSurface* surface) {
 170     if (eglGetCurrentSurface(EGL_READ) == *surface ||
 171             eglGetCurrentSurface(EGL_DRAW) == *surface) {
 172         eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
 173                 EGL_NO_CONTEXT);
 174     }
 175     eglDestroySurface(mDisplay, *surface);
 176     *surface = EGL_NO_SURFACE;
 177 }
 178
 179 bool GLHelper::swapBuffers(EGLSurface surface) {
 180     EGLint result;
 181     result = eglSwapBuffers(mDisplay, surface);
 182     if (result != EGL_TRUE) {
 183         fprintf(stderr, "eglSwapBuffers error: %#x\n", eglGetError());
 184         return false;
 185     }
 186     return true;
 187 }
 188
 189 bool GLHelper::getShaderProgram(const char* name, GLuint* outPgm) {
 190     for (size_t i = 0; i < mNumShaders; i++) {
 191         if (strcmp(mShaderDescs[i].name, name) == 0) {
 192             *outPgm = mShaderPrograms[i];
 193             return true;
 194         }
 195     }
 196
 197     fprintf(stderr, "unknown shader name: \"%s\"\n", name);
 198
 199     return false;
 200 }
 201
 202 bool GLHelper::createNamedSurfaceTexture(GLuint name, uint32_t w, uint32_t h,
 203         sp<GLConsumer>* glConsumer, EGLSurface* surface) {
 204     sp<IGraphicBufferProducer> producer;
 205     sp<IGraphicBufferConsumer> consumer;
 206     BufferQueue::createBufferQueue(&producer, &consumer, mGraphicBufferAlloc);
 207     sp<GLConsumer> glc = new GLConsumer(consumer, name,
 208             GL_TEXTURE_EXTERNAL_OES, false, true);
 209     glc->setDefaultBufferSize(w, h);
 210     glc->setDefaultMaxBufferCount(3);
 211     glc->setConsumerUsageBits(GRALLOC_USAGE_HW_COMPOSER);
 212
 213     sp<ANativeWindow> anw = new Surface(producer);
 214     EGLSurface s = eglCreateWindowSurface(mDisplay, mConfig, anw.get(), NULL);
 215     if (s == EGL_NO_SURFACE) {
 216         fprintf(stderr, "eglCreateWindowSurface error: %#x\n", eglGetError());
 217         return false;
 218     }
 219
 220     *glConsumer = glc;
 221     *surface = s;
 222     return true;
 223 }
 224
 225 bool GLHelper::computeWindowScale(uint32_t w, uint32_t h, float* scale) {
 226     sp<IBinder> dpy = mSurfaceComposerClient->getBuiltInDisplay(0);
 227     if (dpy == NULL) {
 228         fprintf(stderr, "SurfaceComposer::getBuiltInDisplay failed.\n");
 229         return false;
 230     }
 231
 232     DisplayInfo info;
 233     status_t err = mSurfaceComposerClient->getDisplayInfo(dpy, &info);
 234     if (err != NO_ERROR) {
 235         fprintf(stderr, "SurfaceComposer::getDisplayInfo failed: %#x\n", err);
 236         return false;
 237     }
 238
 239     float scaleX = float(info.w) / float(w);
 240     float scaleY = float(info.h) / float(h);
 241     *scale = scaleX < scaleY ? scaleX : scaleY;
 242
 243     return true;
 244 }
 245
 246 bool GLHelper::createWindowSurface(uint32_t w, uint32_t h,
 247         sp<SurfaceControl>* surfaceControl, EGLSurface* surface) {
 248     bool result;
 249     status_t err;
 250
 251     if (mSurfaceComposerClient == NULL) {
 252         mSurfaceComposerClient = new SurfaceComposerClient;
 253     }
 254     err = mSurfaceComposerClient->initCheck();
 255     if (err != NO_ERROR) {
 256         fprintf(stderr, "SurfaceComposerClient::initCheck error: %#x\n", err);
 257         return false;
 258     }
 259
 260     sp<SurfaceControl> sc = mSurfaceComposerClient->createSurface(
 261             String8("Benchmark"), w, h, PIXEL_FORMAT_RGBA_8888, 0);
 262     if (sc == NULL || !sc->isValid()) {
 263         fprintf(stderr, "Failed to create SurfaceControl.\n");
 264         return false;
 265     }
 266
 267     float scale;
 268     result = computeWindowScale(w, h, &scale);
 269     if (!result) {
 270         return false;
 271     }
 272
 273     SurfaceComposerClient::openGlobalTransaction();
 274     err = sc->setLayer(0x7FFFFFFF);
 275     if (err != NO_ERROR) {
 276         fprintf(stderr, "SurfaceComposer::setLayer error: %#x\n", err);
 277         return false;
 278     }
 279     err = sc->setMatrix(scale, 0.0f, 0.0f, scale);
 280     if (err != NO_ERROR) {
 281         fprintf(stderr, "SurfaceComposer::setMatrix error: %#x\n", err);
 282         return false;
 283     }
 284
 285     err = sc->show();
 286     if (err != NO_ERROR) {
 287         fprintf(stderr, "SurfaceComposer::show error: %#x\n", err);
 288         return false;
 289     }
 290     SurfaceComposerClient::closeGlobalTransaction();
 291
 292     sp<ANativeWindow> anw = sc->getSurface();
 293     EGLSurface s = eglCreateWindowSurface(mDisplay, mConfig, anw.get(), NULL);
 294     if (s == EGL_NO_SURFACE) {
 295         fprintf(stderr, "eglCreateWindowSurface error: %#x\n", eglGetError());
 296         return false;
 297     }
 298
 299     *surfaceControl = sc;
 300     *surface = s;
 301     return true;
 302 }
 303
 304 static bool compileShader(GLenum shaderType, const char* src,
 305         GLuint* outShader) {
 306     GLuint shader = glCreateShader(shaderType);
 307     if (shader == 0) {
 308         fprintf(stderr, "glCreateShader error: %#x\n", glGetError());
 309         return false;
 310     }
 311
 312     glShaderSource(shader, 1, &src, NULL);
 313     glCompileShader(shader);
 314
 315     GLint compiled = 0;
 316     glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
 317     if (!compiled) {
 318         GLint infoLen = 0;
 319         glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
 320         if (infoLen) {
 321             char* buf = new char[infoLen];
 322             if (buf) {
 323                 glGetShaderInfoLog(shader, infoLen, NULL, buf);
 324                 fprintf(stderr, "Shader compile log:\n%s\n", buf);
 325                 delete[] buf;
 326             }
 327         }
 328         glDeleteShader(shader);
 329         return false;
 330     }
 331     *outShader = shader;
 332     return true;
 333 }
 334
 335 static void printShaderSource(const char* const* src) {
 336     for (size_t i = 0; i < MAX_SHADER_LINES && src[i] != NULL; i++) {
 337         fprintf(stderr, "%3zu: %s\n", i+1, src[i]);
 338     }
 339 }
 340
 341 static const char* makeShaderString(const char* const* src) {
 342     size_t len = 0;
 343     for (size_t i = 0; i < MAX_SHADER_LINES && src[i] != NULL; i++) {
 344         // The +1 is for the '\n' that will be added.
 345         len += strlen(src[i]) + 1;
 346     }
 347
 348     char* result = new char[len+1];
 349     char* end = result;
 350     for (size_t i = 0; i < MAX_SHADER_LINES && src[i] != NULL; i++) {
 351         strcpy(end, src[i]);
 352         end += strlen(src[i]);
 353         *end = '\n';
 354         end++;
 355     }
 356     *end = '\0';
 357
 358     return result;
 359 }
 360
 361 static bool compileShaderLines(GLenum shaderType, const char* const* lines,
 362         GLuint* outShader) {
 363     const char* src = makeShaderString(lines);
 364     bool result = compileShader(shaderType, src, outShader);
 365     if (!result) {
 366         fprintf(stderr, "Shader source:\n");
 367         printShaderSource(lines);
 368         return false;
 369     }
 370     delete[] src;
 371
 372     return true;
 373 }
 374
 375 static bool linkShaderProgram(GLuint vs, GLuint fs, GLuint* outPgm) {
 376     GLuint program = glCreateProgram();
 377     if (program == 0) {
 378         fprintf(stderr, "glCreateProgram error: %#x\n", glGetError());
 379         return false;
 380     }
 381
 382     glAttachShader(program, vs);
 383     glAttachShader(program, fs);
 384     glLinkProgram(program);
 385     GLint linkStatus = GL_FALSE;
 386     glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
 387     if (linkStatus != GL_TRUE) {
 388         GLint bufLength = 0;
 389         glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
 390         if (bufLength) {
 391             char* buf = new char[bufLength];
 392             if (buf) {
 393                 glGetProgramInfoLog(program, bufLength, NULL, buf);
 394                 fprintf(stderr, "Program link log:\n%s\n", buf);
 395                 delete[] buf;
 396             }
 397         }
 398         glDeleteProgram(program);
 399         program = 0;
 400     }
 401
 402     *outPgm = program;
 403     return program != 0;
 404 }
 405
 406 bool GLHelper::setUpShaders(const ShaderDesc* shaderDescs, size_t numShaders) {
 407     mShaderPrograms = new GLuint[numShaders];
 408     bool result = true;
 409
 410     for (size_t i = 0; i < numShaders && result; i++) {
 411         GLuint vs, fs;
 412
 413         result = compileShaderLines(GL_VERTEX_SHADER,
 414                 shaderDescs[i].vertexShader, &vs);
 415         if (!result) {
 416             return false;
 417         }
 418
 419         result = compileShaderLines(GL_FRAGMENT_SHADER,
 420                 shaderDescs[i].fragmentShader, &fs);
 421         if (!result) {
 422             glDeleteShader(vs);
 423             return false;
 424         }
 425
 426         result = linkShaderProgram(vs, fs, &mShaderPrograms[i]);
 427         glDeleteShader(vs);
 428         glDeleteShader(fs);
 429     }
 430
 431     mNumShaders = numShaders;
 432     mShaderDescs = shaderDescs;
 433
 434     return result;
 435 }
 436
 437 bool GLHelper::getDitherTexture(GLuint* outTexName) {
 438     if (mDitherTexture == 0) {
 439         const uint8_t pattern[] = {
 440              0,  8,  2, 10,
 441             12,  4, 14,  6,
 442              3, 11,  1,  9,
 443             15,  7, 13,  5
 444         };
 445
 446         glGenTextures(1, &mDitherTexture);
 447         glBindTexture(GL_TEXTURE_2D, mDitherTexture);
 448
 449         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 450         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 451
 452         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 453         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 454
 455         glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, DITHER_KERNEL_SIZE,
 456                 DITHER_KERNEL_SIZE, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &pattern);
 457     }
 458
 459     *outTexName = mDitherTexture;
 460
 461     return true;
 462 }
 463
 464 }