/* * Copyright (C) 2010 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include <stdlib.h> #include <stdio.h> #include <time.h> #include <sched.h> #include <sys/resource.h> #include <EGL/egl.h> #include <EGL/eglext.h> #include <GLES2/gl2.h> #include <GLES2/gl2ext.h> #include <utils/Timers.h> #include <WindowSurface.h> #include <ui/GraphicBuffer.h> #include <EGLUtils.h> using namespace android; static void printGLString(const char *name, GLenum s) { // fprintf(stderr, "printGLString %s, %d\n", name, s); const char *v = (const char *) glGetString(s); // int error = glGetError(); // fprintf(stderr, "glGetError() = %d, result of glGetString = %x\n", error, // (unsigned int) v); // if ((v < (const char*) 0) || (v > (const char*) 0x10000)) // fprintf(stderr, "GL %s = %s\n", name, v); // else // fprintf(stderr, "GL %s = (null) 0x%08x\n", name, (unsigned int) v); fprintf(stderr, "GL %s = %s\n", name, v); } static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) { if (returnVal != EGL_TRUE) { fprintf(stderr, "%s() returned %d\n", op, returnVal); } for (EGLint error = eglGetError(); error != EGL_SUCCESS; error = eglGetError()) { fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, EGLUtils::strerror(error), error); } } static void checkGlError(const char* op) { for (GLint error = glGetError(); error; error = glGetError()) { fprintf(stderr, "after %s() glError (0x%x)\n", op, error); } } static const char gVertexShader[] = "attribute vec4 vPosition;\n" "varying vec2 yuvTexCoords;\n" "void main() {\n" " yuvTexCoords = vPosition.xy + vec2(0.5, 0.5);\n" " gl_Position = vPosition;\n" "}\n"; static const char gFragmentShader[] = "#extension GL_OES_EGL_image_external : require\n" "precision mediump float;\n" "uniform samplerExternalOES yuvTexSampler;\n" "varying vec2 yuvTexCoords;\n" "void main() {\n" " gl_FragColor = texture2D(yuvTexSampler, yuvTexCoords);\n" "}\n"; GLuint loadShader(GLenum shaderType, const char* pSource) { GLuint shader = glCreateShader(shaderType); if (shader) { glShaderSource(shader, 1, &pSource, NULL); glCompileShader(shader); GLint compiled = 0; glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled); if (!compiled) { GLint infoLen = 0; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen); if (infoLen) { char* buf = (char*) malloc(infoLen); if (buf) { glGetShaderInfoLog(shader, infoLen, NULL, buf); fprintf(stderr, "Could not compile shader %d:\n%s\n", shaderType, buf); free(buf); } } else { fprintf(stderr, "Guessing at GL_INFO_LOG_LENGTH size\n"); char* buf = (char*) malloc(0x1000); if (buf) { glGetShaderInfoLog(shader, 0x1000, NULL, buf); fprintf(stderr, "Could not compile shader %d:\n%s\n", shaderType, buf); free(buf); } } glDeleteShader(shader); shader = 0; } } return shader; } GLuint createProgram(const char* pVertexSource, const char* pFragmentSource) { GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource); if (!vertexShader) { return 0; } GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource); if (!pixelShader) { return 0; } GLuint program = glCreateProgram(); if (program) { glAttachShader(program, vertexShader); checkGlError("glAttachShader"); glAttachShader(program, pixelShader); checkGlError("glAttachShader"); glLinkProgram(program); GLint linkStatus = GL_FALSE; glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); if (linkStatus != GL_TRUE) { GLint bufLength = 0; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength); if (bufLength) { char* buf = (char*) malloc(bufLength); if (buf) { glGetProgramInfoLog(program, bufLength, NULL, buf); fprintf(stderr, "Could not link program:\n%s\n", buf); free(buf); } } glDeleteProgram(program); program = 0; } } return program; } GLuint gProgram; GLint gvPositionHandle; GLint gYuvTexSamplerHandle; bool setupGraphics(int w, int h) { gProgram = createProgram(gVertexShader, gFragmentShader); if (!gProgram) { return false; } gvPositionHandle = glGetAttribLocation(gProgram, "vPosition"); checkGlError("glGetAttribLocation"); fprintf(stderr, "glGetAttribLocation(\"vPosition\") = %d\n", gvPositionHandle); gYuvTexSamplerHandle = glGetUniformLocation(gProgram, "yuvTexSampler"); checkGlError("glGetUniformLocation"); fprintf(stderr, "glGetUniformLocation(\"yuvTexSampler\") = %d\n", gYuvTexSamplerHandle); glViewport(0, 0, w, h); checkGlError("glViewport"); return true; } int align(int x, int a) { return (x + (a-1)) & (~(a-1)); } const int yuvTexWidth = 608; const int yuvTexHeight = 480; const int yuvTexUsage = GraphicBuffer::USAGE_HW_TEXTURE | GraphicBuffer::USAGE_SW_WRITE_RARELY; const int yuvTexFormat = HAL_PIXEL_FORMAT_YV12; const int yuvTexOffsetY = 0; const bool yuvTexSameUV = false; static sp<GraphicBuffer> yuvTexBuffer; static GLuint yuvTex; bool setupYuvTexSurface(EGLDisplay dpy, EGLContext context) { int blockWidth = yuvTexWidth > 16 ? yuvTexWidth / 16 : 1; int blockHeight = yuvTexHeight > 16 ? yuvTexHeight / 16 : 1; yuvTexBuffer = new GraphicBuffer(yuvTexWidth, yuvTexHeight, yuvTexFormat, yuvTexUsage); int yuvTexStrideY = yuvTexBuffer->getStride(); int yuvTexOffsetV = yuvTexStrideY * yuvTexHeight; int yuvTexStrideV = (yuvTexStrideY/2 + 0xf) & ~0xf; int yuvTexOffsetU = yuvTexOffsetV + yuvTexStrideV * yuvTexHeight/2; int yuvTexStrideU = yuvTexStrideV; char* buf = NULL; status_t err = yuvTexBuffer->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&buf)); if (err != 0) { fprintf(stderr, "yuvTexBuffer->lock(...) failed: %d\n", err); return false; } for (int x = 0; x < yuvTexWidth; x++) { for (int y = 0; y < yuvTexHeight; y++) { int parityX = (x / blockWidth) & 1; int parityY = (y / blockHeight) & 1; unsigned char intensity = (parityX ^ parityY) ? 63 : 191; buf[yuvTexOffsetY + (y * yuvTexStrideY) + x] = intensity; if (x < yuvTexWidth / 2 && y < yuvTexHeight / 2) { buf[yuvTexOffsetU + (y * yuvTexStrideU) + x] = intensity; if (yuvTexSameUV) { buf[yuvTexOffsetV + (y * yuvTexStrideV) + x] = intensity; } else if (x < yuvTexWidth / 4 && y < yuvTexHeight / 4) { buf[yuvTexOffsetV + (y*2 * yuvTexStrideV) + x*2 + 0] = buf[yuvTexOffsetV + (y*2 * yuvTexStrideV) + x*2 + 1] = buf[yuvTexOffsetV + ((y*2+1) * yuvTexStrideV) + x*2 + 0] = buf[yuvTexOffsetV + ((y*2+1) * yuvTexStrideV) + x*2 + 1] = intensity; } } } } err = yuvTexBuffer->unlock(); if (err != 0) { fprintf(stderr, "yuvTexBuffer->unlock() failed: %d\n", err); return false; } EGLClientBuffer clientBuffer = (EGLClientBuffer)yuvTexBuffer->getNativeBuffer(); EGLImageKHR img = eglCreateImageKHR(dpy, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, clientBuffer, 0); checkEglError("eglCreateImageKHR"); if (img == EGL_NO_IMAGE_KHR) { return false; } glGenTextures(1, &yuvTex); checkGlError("glGenTextures"); glBindTexture(GL_TEXTURE_EXTERNAL_OES, yuvTex); checkGlError("glBindTexture"); glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, (GLeglImageOES)img); checkGlError("glEGLImageTargetTexture2DOES"); return true; } const GLfloat gTriangleVertices[] = { -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, }; void renderFrame() { glClearColor(0.0f, 0.0f, 1.0f, 1.0f); checkGlError("glClearColor"); glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); checkGlError("glClear"); glUseProgram(gProgram); checkGlError("glUseProgram"); glVertexAttribPointer(gvPositionHandle, 2, GL_FLOAT, GL_FALSE, 0, gTriangleVertices); checkGlError("glVertexAttribPointer"); glEnableVertexAttribArray(gvPositionHandle); checkGlError("glEnableVertexAttribArray"); glUniform1i(gYuvTexSamplerHandle, 0); checkGlError("glUniform1i"); glBindTexture(GL_TEXTURE_EXTERNAL_OES, yuvTex); checkGlError("glBindTexture"); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); checkGlError("glDrawArrays"); } void printEGLConfiguration(EGLDisplay dpy, EGLConfig config) { #define X(VAL) {VAL, #VAL} struct {EGLint attribute; const char* name;} names[] = { X(EGL_BUFFER_SIZE), X(EGL_ALPHA_SIZE), X(EGL_BLUE_SIZE), X(EGL_GREEN_SIZE), X(EGL_RED_SIZE), X(EGL_DEPTH_SIZE), X(EGL_STENCIL_SIZE), X(EGL_CONFIG_CAVEAT), X(EGL_CONFIG_ID), X(EGL_LEVEL), X(EGL_MAX_PBUFFER_HEIGHT), X(EGL_MAX_PBUFFER_PIXELS), X(EGL_MAX_PBUFFER_WIDTH), X(EGL_NATIVE_RENDERABLE), X(EGL_NATIVE_VISUAL_ID), X(EGL_NATIVE_VISUAL_TYPE), X(EGL_SAMPLES), X(EGL_SAMPLE_BUFFERS), X(EGL_SURFACE_TYPE), X(EGL_TRANSPARENT_TYPE), X(EGL_TRANSPARENT_RED_VALUE), X(EGL_TRANSPARENT_GREEN_VALUE), X(EGL_TRANSPARENT_BLUE_VALUE), X(EGL_BIND_TO_TEXTURE_RGB), X(EGL_BIND_TO_TEXTURE_RGBA), X(EGL_MIN_SWAP_INTERVAL), X(EGL_MAX_SWAP_INTERVAL), X(EGL_LUMINANCE_SIZE), X(EGL_ALPHA_MASK_SIZE), X(EGL_COLOR_BUFFER_TYPE), X(EGL_RENDERABLE_TYPE), X(EGL_CONFORMANT), }; #undef X for (size_t j = 0; j < sizeof(names) / sizeof(names[0]); j++) { EGLint value = -1; EGLint returnVal = eglGetConfigAttrib(dpy, config, names[j].attribute, &value); EGLint error = eglGetError(); if (returnVal && error == EGL_SUCCESS) { printf(" %s: ", names[j].name); printf("%d (0x%x)", value, value); } } printf("\n"); } int main(int argc, char** argv) { EGLBoolean returnValue; EGLConfig myConfig = {0}; EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; EGLint s_configAttribs[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_NONE }; EGLint majorVersion; EGLint minorVersion; EGLContext context; EGLSurface surface; EGLint w, h; EGLDisplay dpy; checkEglError("<init>"); dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); checkEglError("eglGetDisplay"); if (dpy == EGL_NO_DISPLAY) { printf("eglGetDisplay returned EGL_NO_DISPLAY.\n"); return 0; } returnValue = eglInitialize(dpy, &majorVersion, &minorVersion); checkEglError("eglInitialize", returnValue); fprintf(stderr, "EGL version %d.%d\n", majorVersion, minorVersion); if (returnValue != EGL_TRUE) { printf("eglInitialize failed\n"); return 0; } WindowSurface windowSurface; EGLNativeWindowType window = windowSurface.getSurface(); returnValue = EGLUtils::selectConfigForNativeWindow(dpy, s_configAttribs, window, &myConfig); if (returnValue) { printf("EGLUtils::selectConfigForNativeWindow() returned %d", returnValue); return 1; } checkEglError("EGLUtils::selectConfigForNativeWindow"); printf("Chose this configuration:\n"); printEGLConfiguration(dpy, myConfig); surface = eglCreateWindowSurface(dpy, myConfig, window, NULL); checkEglError("eglCreateWindowSurface"); if (surface == EGL_NO_SURFACE) { printf("gelCreateWindowSurface failed.\n"); return 1; } context = eglCreateContext(dpy, myConfig, EGL_NO_CONTEXT, context_attribs); checkEglError("eglCreateContext"); if (context == EGL_NO_CONTEXT) { printf("eglCreateContext failed\n"); return 1; } returnValue = eglMakeCurrent(dpy, surface, surface, context); checkEglError("eglMakeCurrent", returnValue); if (returnValue != EGL_TRUE) { return 1; } eglQuerySurface(dpy, surface, EGL_WIDTH, &w); checkEglError("eglQuerySurface"); eglQuerySurface(dpy, surface, EGL_HEIGHT, &h); checkEglError("eglQuerySurface"); GLint dim = w < h ? w : h; fprintf(stderr, "Window dimensions: %d x %d\n", w, h); printGLString("Version", GL_VERSION); printGLString("Vendor", GL_VENDOR); printGLString("Renderer", GL_RENDERER); printGLString("Extensions", GL_EXTENSIONS); if(!setupYuvTexSurface(dpy, context)) { fprintf(stderr, "Could not set up texture surface.\n"); return 1; } if(!setupGraphics(w, h)) { fprintf(stderr, "Could not set up graphics.\n"); return 1; } for (;;) { renderFrame(); eglSwapBuffers(dpy, surface); checkEglError("eglSwapBuffers"); } return 0; }