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
GLHelper()27 GLHelper::GLHelper() :
28 mDisplay(EGL_NO_DISPLAY),
29 mContext(EGL_NO_CONTEXT),
30 mDummySurface(EGL_NO_SURFACE),
31 mConfig(0),
32 mShaderPrograms(NULL),
33 mDitherTexture(0) {
34 }
35
~GLHelper()36 GLHelper::~GLHelper() {
37 }
38
setUp(const ShaderDesc * shaderDescs,size_t numShaders)39 bool GLHelper::setUp(const ShaderDesc* shaderDescs, size_t numShaders) {
40 bool result;
41
42 mDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
43 if (mDisplay == EGL_NO_DISPLAY) {
44 fprintf(stderr, "eglGetDisplay error: %#x\n", eglGetError());
45 return false;
46 }
47
48 EGLint majorVersion;
49 EGLint minorVersion;
50 result = eglInitialize(mDisplay, &majorVersion, &minorVersion);
51 if (result != EGL_TRUE) {
52 fprintf(stderr, "eglInitialize error: %#x\n", eglGetError());
53 return false;
54 }
55
56 EGLint numConfigs = 0;
57 EGLint configAttribs[] = {
58 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
59 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
60 EGL_RED_SIZE, 8,
61 EGL_GREEN_SIZE, 8,
62 EGL_BLUE_SIZE, 8,
63 EGL_ALPHA_SIZE, 8,
64 EGL_NONE
65 };
66 result = eglChooseConfig(mDisplay, configAttribs, &mConfig, 1,
67 &numConfigs);
68 if (result != EGL_TRUE) {
69 fprintf(stderr, "eglChooseConfig error: %#x\n", eglGetError());
70 return false;
71 }
72
73 EGLint contextAttribs[] = {
74 EGL_CONTEXT_CLIENT_VERSION, 2,
75 EGL_NONE
76 };
77 mContext = eglCreateContext(mDisplay, mConfig, EGL_NO_CONTEXT,
78 contextAttribs);
79 if (mContext == EGL_NO_CONTEXT) {
80 fprintf(stderr, "eglCreateContext error: %#x\n", eglGetError());
81 return false;
82 }
83
84 bool resultb = createNamedSurfaceTexture(0, 1, 1, &mDummyGLConsumer,
85 &mDummySurface);
86 if (!resultb) {
87 return false;
88 }
89
90 resultb = makeCurrent(mDummySurface);
91 if (!resultb) {
92 return false;
93 }
94
95 resultb = setUpShaders(shaderDescs, numShaders);
96 if (!resultb) {
97 return false;
98 }
99
100 return true;
101 }
102
tearDown()103 void GLHelper::tearDown() {
104 if (mShaderPrograms != NULL) {
105 delete[] mShaderPrograms;
106 mShaderPrograms = NULL;
107 }
108
109 if (mSurfaceComposerClient != NULL) {
110 mSurfaceComposerClient->dispose();
111 mSurfaceComposerClient.clear();
112 }
113
114 if (mDisplay != EGL_NO_DISPLAY) {
115 eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
116 EGL_NO_CONTEXT);
117 }
118
119 if (mContext != EGL_NO_CONTEXT) {
120 eglDestroyContext(mDisplay, mContext);
121 }
122
123 if (mDummySurface != EGL_NO_SURFACE) {
124 eglDestroySurface(mDisplay, mDummySurface);
125 }
126
127 mDisplay = EGL_NO_DISPLAY;
128 mContext = EGL_NO_CONTEXT;
129 mDummySurface = EGL_NO_SURFACE;
130 mDummyGLConsumer.clear();
131 mConfig = 0;
132 }
133
makeCurrent(EGLSurface surface)134 bool GLHelper::makeCurrent(EGLSurface surface) {
135 EGLint result;
136
137 result = eglMakeCurrent(mDisplay, surface, surface, mContext);
138 if (result != EGL_TRUE) {
139 fprintf(stderr, "eglMakeCurrent error: %#x\n", eglGetError());
140 return false;
141 }
142
143 EGLint w, h;
144 eglQuerySurface(mDisplay, surface, EGL_WIDTH, &w);
145 eglQuerySurface(mDisplay, surface, EGL_HEIGHT, &h);
146 glViewport(0, 0, w, h);
147
148 return true;
149 }
150
createSurfaceTexture(uint32_t w,uint32_t h,sp<GLConsumer> * glConsumer,EGLSurface * surface,GLuint * name)151 bool GLHelper::createSurfaceTexture(uint32_t w, uint32_t h,
152 sp<GLConsumer>* glConsumer, EGLSurface* surface,
153 GLuint* name) {
154 if (!makeCurrent(mDummySurface)) {
155 return false;
156 }
157
158 *name = 0;
159 glGenTextures(1, name);
160 if (*name == 0) {
161 fprintf(stderr, "glGenTextures error: %#x\n", glGetError());
162 return false;
163 }
164
165 return createNamedSurfaceTexture(*name, w, h, glConsumer, surface);
166 }
167
destroySurface(EGLSurface * surface)168 void GLHelper::destroySurface(EGLSurface* surface) {
169 if (eglGetCurrentSurface(EGL_READ) == *surface ||
170 eglGetCurrentSurface(EGL_DRAW) == *surface) {
171 eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
172 EGL_NO_CONTEXT);
173 }
174 eglDestroySurface(mDisplay, *surface);
175 *surface = EGL_NO_SURFACE;
176 }
177
swapBuffers(EGLSurface surface)178 bool GLHelper::swapBuffers(EGLSurface surface) {
179 EGLint result;
180 result = eglSwapBuffers(mDisplay, surface);
181 if (result != EGL_TRUE) {
182 fprintf(stderr, "eglSwapBuffers error: %#x\n", eglGetError());
183 return false;
184 }
185 return true;
186 }
187
getShaderProgram(const char * name,GLuint * outPgm)188 bool GLHelper::getShaderProgram(const char* name, GLuint* outPgm) {
189 for (size_t i = 0; i < mNumShaders; i++) {
190 if (strcmp(mShaderDescs[i].name, name) == 0) {
191 *outPgm = mShaderPrograms[i];
192 return true;
193 }
194 }
195
196 fprintf(stderr, "unknown shader name: \"%s\"\n", name);
197
198 return false;
199 }
200
createNamedSurfaceTexture(GLuint name,uint32_t w,uint32_t h,sp<GLConsumer> * glConsumer,EGLSurface * surface)201 bool GLHelper::createNamedSurfaceTexture(GLuint name, uint32_t w, uint32_t h,
202 sp<GLConsumer>* glConsumer, EGLSurface* surface) {
203 sp<IGraphicBufferProducer> producer;
204 sp<IGraphicBufferConsumer> consumer;
205 BufferQueue::createBufferQueue(&producer, &consumer);
206 sp<GLConsumer> glc = new GLConsumer(consumer, name,
207 GL_TEXTURE_EXTERNAL_OES, false, true);
208 glc->setDefaultBufferSize(w, h);
209 producer->setMaxDequeuedBufferCount(2);
210 glc->setConsumerUsageBits(GRALLOC_USAGE_HW_COMPOSER);
211
212 sp<ANativeWindow> anw = new Surface(producer);
213 EGLSurface s = eglCreateWindowSurface(mDisplay, mConfig, anw.get(), NULL);
214 if (s == EGL_NO_SURFACE) {
215 fprintf(stderr, "eglCreateWindowSurface error: %#x\n", eglGetError());
216 return false;
217 }
218
219 *glConsumer = glc;
220 *surface = s;
221 return true;
222 }
223
computeWindowScale(uint32_t w,uint32_t h,float * scale)224 bool GLHelper::computeWindowScale(uint32_t w, uint32_t h, float* scale) {
225 sp<IBinder> dpy = mSurfaceComposerClient->getBuiltInDisplay(0);
226 if (dpy == NULL) {
227 fprintf(stderr, "SurfaceComposer::getBuiltInDisplay failed.\n");
228 return false;
229 }
230
231 DisplayInfo info;
232 status_t err = mSurfaceComposerClient->getDisplayInfo(dpy, &info);
233 if (err != NO_ERROR) {
234 fprintf(stderr, "SurfaceComposer::getDisplayInfo failed: %#x\n", err);
235 return false;
236 }
237
238 float scaleX = float(info.w) / float(w);
239 float scaleY = float(info.h) / float(h);
240 *scale = scaleX < scaleY ? scaleX : scaleY;
241
242 return true;
243 }
244
createWindowSurface(uint32_t w,uint32_t h,sp<SurfaceControl> * surfaceControl,EGLSurface * surface)245 bool GLHelper::createWindowSurface(uint32_t w, uint32_t h,
246 sp<SurfaceControl>* surfaceControl, EGLSurface* surface) {
247 bool result;
248 status_t err;
249
250 if (mSurfaceComposerClient == NULL) {
251 mSurfaceComposerClient = new SurfaceComposerClient;
252 }
253 err = mSurfaceComposerClient->initCheck();
254 if (err != NO_ERROR) {
255 fprintf(stderr, "SurfaceComposerClient::initCheck error: %#x\n", err);
256 return false;
257 }
258
259 sp<SurfaceControl> sc = mSurfaceComposerClient->createSurface(
260 String8("Benchmark"), w, h, PIXEL_FORMAT_RGBA_8888, 0);
261 if (sc == NULL || !sc->isValid()) {
262 fprintf(stderr, "Failed to create SurfaceControl.\n");
263 return false;
264 }
265
266 float scale;
267 result = computeWindowScale(w, h, &scale);
268 if (!result) {
269 return false;
270 }
271
272 SurfaceComposerClient::openGlobalTransaction();
273 err = sc->setLayer(0x7FFFFFFF);
274 if (err != NO_ERROR) {
275 fprintf(stderr, "SurfaceComposer::setLayer error: %#x\n", err);
276 return false;
277 }
278 err = sc->setMatrix(scale, 0.0f, 0.0f, scale);
279 if (err != NO_ERROR) {
280 fprintf(stderr, "SurfaceComposer::setMatrix error: %#x\n", err);
281 return false;
282 }
283
284 err = sc->show();
285 if (err != NO_ERROR) {
286 fprintf(stderr, "SurfaceComposer::show error: %#x\n", err);
287 return false;
288 }
289 SurfaceComposerClient::closeGlobalTransaction();
290
291 sp<ANativeWindow> anw = sc->getSurface();
292 EGLSurface s = eglCreateWindowSurface(mDisplay, mConfig, anw.get(), NULL);
293 if (s == EGL_NO_SURFACE) {
294 fprintf(stderr, "eglCreateWindowSurface error: %#x\n", eglGetError());
295 return false;
296 }
297
298 *surfaceControl = sc;
299 *surface = s;
300 return true;
301 }
302
compileShader(GLenum shaderType,const char * src,GLuint * outShader)303 static bool compileShader(GLenum shaderType, const char* src,
304 GLuint* outShader) {
305 GLuint shader = glCreateShader(shaderType);
306 if (shader == 0) {
307 fprintf(stderr, "glCreateShader error: %#x\n", glGetError());
308 return false;
309 }
310
311 glShaderSource(shader, 1, &src, NULL);
312 glCompileShader(shader);
313
314 GLint compiled = 0;
315 glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
316 if (!compiled) {
317 GLint infoLen = 0;
318 glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
319 if (infoLen) {
320 char* buf = new char[infoLen];
321 if (buf) {
322 glGetShaderInfoLog(shader, infoLen, NULL, buf);
323 fprintf(stderr, "Shader compile log:\n%s\n", buf);
324 delete[] buf;
325 }
326 }
327 glDeleteShader(shader);
328 return false;
329 }
330 *outShader = shader;
331 return true;
332 }
333
printShaderSource(const char * const * src)334 static void printShaderSource(const char* const* src) {
335 for (size_t i = 0; i < MAX_SHADER_LINES && src[i] != NULL; i++) {
336 fprintf(stderr, "%3zu: %s\n", i+1, src[i]);
337 }
338 }
339
makeShaderString(const char * const * src)340 static const char* makeShaderString(const char* const* src) {
341 size_t len = 0;
342 for (size_t i = 0; i < MAX_SHADER_LINES && src[i] != NULL; i++) {
343 // The +1 is for the '\n' that will be added.
344 len += strlen(src[i]) + 1;
345 }
346
347 char* result = new char[len+1];
348 char* end = result;
349 for (size_t i = 0; i < MAX_SHADER_LINES && src[i] != NULL; i++) {
350 strcpy(end, src[i]);
351 end += strlen(src[i]);
352 *end = '\n';
353 end++;
354 }
355 *end = '\0';
356
357 return result;
358 }
359
compileShaderLines(GLenum shaderType,const char * const * lines,GLuint * outShader)360 static bool compileShaderLines(GLenum shaderType, const char* const* lines,
361 GLuint* outShader) {
362 const char* src = makeShaderString(lines);
363 bool result = compileShader(shaderType, src, outShader);
364 if (!result) {
365 fprintf(stderr, "Shader source:\n");
366 printShaderSource(lines);
367 delete[] src;
368 return false;
369 }
370 delete[] src;
371
372 return true;
373 }
374
linkShaderProgram(GLuint vs,GLuint fs,GLuint * outPgm)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
setUpShaders(const ShaderDesc * shaderDescs,size_t numShaders)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
getDitherTexture(GLuint * outTexName)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 }
465