glworker.cpp

   1 /*
   2  * Copyright (C) 2015 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 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
  18 #define LOG_TAG "GLWorker"
  19
  20 #include <algorithm>
  21 #include <string>
  22 #include <sstream>
  23
  24 #include <sys/resource.h>
  25
  26 #include <sync/sync.h>
  27 #include <sw_sync.h>
  28
  29 #include <hardware/hardware.h>
  30 #include <hardware/hwcomposer.h>
  31
  32 #include <ui/GraphicBuffer.h>
  33 #include <ui/PixelFormat.h>
  34
  35 #include <utils/Trace.h>
  36
  37 #include "glworker.h"
  38
  39 #include "seperate_rects.h"
  40
  41 // TODO(zachr): use hwc_drm_bo to turn buffer handles into textures
  42 #ifndef EGL_NATIVE_HANDLE_ANDROID_NVX
  43 #define EGL_NATIVE_HANDLE_ANDROID_NVX 0x322A
  44 #endif
  45
  46 #define MAX_OVERLAPPING_LAYERS 64
  47
  48 namespace android {
  49
  50 typedef seperate_rects::Rect<float> FRect;
  51 typedef seperate_rects::RectSet<uint64_t, float> FRectSet;
  52
  53 // clang-format off
  54 // Column-major order:
  55 // float mat[4] = { 1, 2, 3, 4 } ===
  56 // [ 1 3 ]
  57 // [ 2 4 ]
  58 float kTextureTransformMatrices[] = {
  59    1.0f,  0.0f,  0.0f,  1.0f, // identity matrix
  60   -1.0f,  0.0f,  0.0f,  1.0f, // HWC_TRANSFORM_FLIP_H;
  61    1.0f,  0.0f,  0.0f, -1.0f, // HWC_TRANSFORM_FLIP_V;
  62    0.0f,  1.0f, -1.0f,  0.0f, // HWC_TRANSFORM_ROT_90;
  63   -1.0f,  0.0f,  0.0f, -1.0f, // HWC_TRANSFORM_ROT_180;
  64    0.0f, -1.0f,  1.0f,  0.0f, // HWC_TRANSFORM_ROT_270;
  65 };
  66 // clang-format on
  67
  68 static const char *GetGLError(void) {
  69   switch (glGetError()) {
  70     case GL_NO_ERROR:
  71       return "GL_NO_ERROR";
  72     case GL_INVALID_ENUM:
  73       return "GL_INVALID_ENUM";
  74     case GL_INVALID_VALUE:
  75       return "GL_INVALID_VALUE";
  76     case GL_INVALID_OPERATION:
  77       return "GL_INVALID_OPERATION";
  78     case GL_INVALID_FRAMEBUFFER_OPERATION:
  79       return "GL_INVALID_FRAMEBUFFER_OPERATION";
  80     case GL_OUT_OF_MEMORY:
  81       return "GL_OUT_OF_MEMORY";
  82     default:
  83       return "Unknown error";
  84   }
  85 }
  86
  87 static const char *GetGLFramebufferError(void) {
  88   switch (glCheckFramebufferStatus(GL_FRAMEBUFFER)) {
  89     case GL_FRAMEBUFFER_COMPLETE:
  90       return "GL_FRAMEBUFFER_COMPLETE";
  91     case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
  92       return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
  93     case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
  94       return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
  95     case GL_FRAMEBUFFER_UNSUPPORTED:
  96       return "GL_FRAMEBUFFER_UNSUPPORTED";
  97     case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
  98       return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
  99     default:
 100       return "Unknown error";
 101   }
 102 }
 103
 104 static const char *GetEGLError(void) {
 105   switch (eglGetError()) {
 106     case EGL_SUCCESS:
 107       return "EGL_SUCCESS";
 108     case EGL_NOT_INITIALIZED:
 109       return "EGL_NOT_INITIALIZED";
 110     case EGL_BAD_ACCESS:
 111       return "EGL_BAD_ACCESS";
 112     case EGL_BAD_ALLOC:
 113       return "EGL_BAD_ALLOC";
 114     case EGL_BAD_ATTRIBUTE:
 115       return "EGL_BAD_ATTRIBUTE";
 116     case EGL_BAD_CONTEXT:
 117       return "EGL_BAD_CONTEXT";
 118     case EGL_BAD_CONFIG:
 119       return "EGL_BAD_CONFIG";
 120     case EGL_BAD_CURRENT_SURFACE:
 121       return "EGL_BAD_CURRENT_SURFACE";
 122     case EGL_BAD_DISPLAY:
 123       return "EGL_BAD_DISPLAY";
 124     case EGL_BAD_SURFACE:
 125       return "EGL_BAD_SURFACE";
 126     case EGL_BAD_MATCH:
 127       return "EGL_BAD_MATCH";
 128     case EGL_BAD_PARAMETER:
 129       return "EGL_BAD_PARAMETER";
 130     case EGL_BAD_NATIVE_PIXMAP:
 131       return "EGL_BAD_NATIVE_PIXMAP";
 132     case EGL_BAD_NATIVE_WINDOW:
 133       return "EGL_BAD_NATIVE_WINDOW";
 134     case EGL_CONTEXT_LOST:
 135       return "EGL_CONTEXT_LOST";
 136     default:
 137       return "Unknown error";
 138   }
 139 }
 140
 141 static bool HasExtension(const char *extension, const char *extensions) {
 142   const char *start, *where, *terminator;
 143   start = extensions;
 144   for (;;) {
 145     where = (char *)strstr((const char *)start, extension);
 146     if (!where)
 147       break;
 148     terminator = where + strlen(extension);
 149     if (where == start || *(where - 1) == ' ')
 150       if (*terminator == ' ' || *terminator == '\0')
 151         return true;
 152     start = terminator;
 153   }
 154   return false;
 155 }
 156
 157 static AutoGLShader CompileAndCheckShader(GLenum type, unsigned source_count,
 158                                           const GLchar **sources,
 159                                           std::string *shader_log) {
 160   GLint status;
 161   AutoGLShader shader(glCreateShader(type));
 162   if (shader.get() == 0) {
 163     *shader_log = "glCreateShader failed";
 164     return 0;
 165   }
 166   glShaderSource(shader.get(), source_count, sources, NULL);
 167   glCompileShader(shader.get());
 168   glGetShaderiv(shader.get(), GL_COMPILE_STATUS, &status);
 169   if (!status) {
 170     if (shader_log) {
 171       GLint log_length;
 172       glGetShaderiv(shader.get(), GL_INFO_LOG_LENGTH, &log_length);
 173       shader_log->resize(log_length);
 174       glGetShaderInfoLog(shader.get(), log_length, NULL, &(*shader_log)[0]);
 175     }
 176     return 0;
 177   }
 178
 179   return shader;
 180 }
 181
 182 static int GenerateShaders(std::vector<AutoGLProgram> *blend_programs) {
 183   // Limits: GL_MAX_VARYING_COMPONENTS, GL_MAX_TEXTURE_IMAGE_UNITS,
 184   // GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
 185   // clang-format off
 186   const GLchar *shader_preamble = "#version 300 es\n#define LAYER_COUNT ";
 187
 188   const GLchar *vertex_shader_source =
 189 "\n"
 190 "precision mediump int;                                                     \n"
 191 "uniform vec4 uViewport;                                                    \n"
 192 "uniform sampler2D uLayerTextures[LAYER_COUNT];                             \n"
 193 "uniform vec4 uLayerCrop[LAYER_COUNT];                                      \n"
 194 "uniform mat2 uTexMatrix[LAYER_COUNT];                                      \n"
 195 "in vec2 vPosition;                                                         \n"
 196 "in vec2 vTexCoords;                                                        \n"
 197 "out vec2 fTexCoords[LAYER_COUNT];                                          \n"
 198 "void main() {                                                              \n"
 199 "  for (int i = 0; i < LAYER_COUNT; i++) {                                  \n"
 200 "    fTexCoords[i] = (uLayerCrop[i].xy + vTexCoords * uLayerCrop[i].zw) /   \n"
 201 "                     vec2(textureSize(uLayerTextures[i], 0));              \n"
 202 "    fTexCoords[i] *= uTexMatrix[i];                                        \n"
 203 "  }                                                                        \n"
 204 "  vec2 scaledPosition = uViewport.xy + vPosition * uViewport.zw;           \n"
 205 "  gl_Position = vec4(scaledPosition * vec2(2.0) - vec2(1.0), 0.0, 1.0);    \n"
 206 "}                                                                          \n";
 207
 208   const GLchar *fragment_shader_source =
 209 "\n"
 210 "precision mediump float;                                                   \n"
 211 "uniform sampler2D uLayerTextures[LAYER_COUNT];                             \n"
 212 "uniform float uLayerAlpha[LAYER_COUNT];                                    \n"
 213 "in vec2 fTexCoords[LAYER_COUNT];                                           \n"
 214 "out vec4 oFragColor;                                                       \n"
 215 "void main() {                                                              \n"
 216 "  vec3 color = vec3(0.0, 0.0, 0.0);                                        \n"
 217 "  float alphaCover = 1.0;                                                  \n"
 218 "  for (int i = 0; i < LAYER_COUNT; i++) {                                  \n"
 219 "    vec4 texSample = texture(uLayerTextures[i], fTexCoords[i]);            \n"
 220 "    float a = texSample.a * uLayerAlpha[i];                                \n"
 221 "    color += a * alphaCover * texSample.rgb;                               \n"
 222 "    alphaCover *= 1.0 - a;                                                 \n"
 223 "    if (alphaCover <= 0.5/255.0)                                           \n"
 224 "      break;                                                               \n"
 225 "  }                                                                        \n"
 226 "  oFragColor = vec4(color, 1.0 - alphaCover);                              \n"
 227 "}                                                                          \n";
 228   // clang-format on
 229
 230   int i, ret = 1;
 231   GLint max_texture_images, status;
 232   AutoGLShader vertex_shader, fragment_shader;
 233   AutoGLProgram program;
 234   std::string shader_log;
 235
 236   glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_images);
 237
 238   for (i = 1; i <= max_texture_images; i++) {
 239     std::ostringstream layer_count_formatter;
 240     layer_count_formatter << i;
 241     std::string layer_count(layer_count_formatter.str());
 242     const GLchar *shader_sources[3] = {shader_preamble, layer_count.c_str(),
 243                                        NULL};
 244
 245     shader_sources[2] = vertex_shader_source;
 246     vertex_shader = CompileAndCheckShader(GL_VERTEX_SHADER, 3, shader_sources,
 247                                           ret ? &shader_log : NULL);
 248     if (!vertex_shader.get()) {
 249       if (ret)
 250         ALOGE("Failed to make vertex shader:\n%s", shader_log.c_str());
 251       break;
 252     }
 253
 254     shader_sources[2] = fragment_shader_source;
 255     fragment_shader = CompileAndCheckShader(
 256         GL_FRAGMENT_SHADER, 3, shader_sources, ret ? &shader_log : NULL);
 257     if (!fragment_shader.get()) {
 258       if (ret)
 259         ALOGE("Failed to make fragment shader:\n%s", shader_log.c_str());
 260       break;
 261     }
 262
 263     program = AutoGLProgram(glCreateProgram());
 264     if (!program.get()) {
 265       if (ret)
 266         ALOGE("Failed to create program %s", GetGLError());
 267       break;
 268     }
 269
 270     glAttachShader(program.get(), vertex_shader.get());
 271     glAttachShader(program.get(), fragment_shader.get());
 272     glBindAttribLocation(program.get(), 0, "vPosition");
 273     glBindAttribLocation(program.get(), 1, "vTexCoords");
 274     glLinkProgram(program.get());
 275     glDetachShader(program.get(), vertex_shader.get());
 276     glDetachShader(program.get(), fragment_shader.get());
 277
 278     glGetProgramiv(program.get(), GL_LINK_STATUS, &status);
 279     if (!status) {
 280       if (ret) {
 281         GLint log_length;
 282         glGetProgramiv(program.get(), GL_INFO_LOG_LENGTH, &log_length);
 283         std::string program_log(log_length, ' ');
 284         glGetProgramInfoLog(program.get(), log_length, NULL, &program_log[0]);
 285         ALOGE("Failed to link program: \n%s", program_log.c_str());
 286       }
 287       break;
 288     }
 289
 290     ret = 0;
 291     blend_programs->emplace_back(std::move(program));
 292   }
 293
 294   return ret;
 295 }
 296
 297 struct RenderingCommand {
 298   struct TextureSource {
 299     unsigned texture_index;
 300     float crop_bounds[4];
 301     float alpha;
 302     float texture_matrix[4];
 303   };
 304
 305   float bounds[4];
 306   unsigned texture_count;
 307   TextureSource textures[MAX_OVERLAPPING_LAYERS];
 308
 309   RenderingCommand() : texture_count(0) {
 310   }
 311 };
 312
 313 static void ConstructCommands(const hwc_layer_1 *layers, size_t num_layers,
 314                               std::vector<RenderingCommand> *commands) {
 315   std::vector<FRect> in_rects;
 316   std::vector<FRectSet> out_rects;
 317   int i;
 318
 319   for (unsigned rect_index = 0; rect_index < num_layers; rect_index++) {
 320     const hwc_layer_1 &layer = layers[rect_index];
 321     FRect rect;
 322     in_rects.push_back(FRect(layer.displayFrame.left, layer.displayFrame.top,
 323                              layer.displayFrame.right,
 324                              layer.displayFrame.bottom));
 325   }
 326
 327   seperate_frects_64(in_rects, &out_rects);
 328
 329   for (unsigned rect_index = 0; rect_index < out_rects.size(); rect_index++) {
 330     const FRectSet &out_rect = out_rects[rect_index];
 331     commands->push_back(RenderingCommand());
 332     RenderingCommand &cmd = commands->back();
 333
 334     memcpy(cmd.bounds, out_rect.rect.bounds, sizeof(cmd.bounds));
 335
 336     uint64_t tex_set = out_rect.id_set.getBits();
 337     for (unsigned i = num_layers - 1; tex_set != 0x0; i--) {
 338       if (tex_set & (0x1 << i)) {
 339         tex_set &= ~(0x1 << i);
 340
 341         const hwc_layer_1 &layer = layers[i];
 342
 343         FRect display_rect(layer.displayFrame.left, layer.displayFrame.top,
 344                            layer.displayFrame.right, layer.displayFrame.bottom);
 345         float display_size[2] = {
 346             display_rect.bounds[2] - display_rect.bounds[0],
 347             display_rect.bounds[3] - display_rect.bounds[1]};
 348
 349         FRect crop_rect(layer.sourceCropf.left, layer.sourceCropf.top,
 350                         layer.sourceCropf.right, layer.sourceCropf.bottom);
 351         float crop_size[2] = {crop_rect.bounds[2] - crop_rect.bounds[0],
 352                               crop_rect.bounds[3] - crop_rect.bounds[1]};
 353
 354         RenderingCommand::TextureSource &src = cmd.textures[cmd.texture_count];
 355         cmd.texture_count++;
 356         src.texture_index = i;
 357
 358         for (int b = 0; b < 4; b++) {
 359           float bound_percent = (cmd.bounds[b] - display_rect.bounds[b % 2]) /
 360                                 display_size[b % 2];
 361           src.crop_bounds[b] =
 362               crop_rect.bounds[b % 2] + bound_percent * crop_size[b % 2];
 363         }
 364
 365         float *src_tex_mat;
 366         switch (layer.transform) {
 367           case HWC_TRANSFORM_FLIP_H:
 368             src_tex_mat = &kTextureTransformMatrices[4];
 369             break;
 370           case HWC_TRANSFORM_FLIP_V:
 371             src_tex_mat = &kTextureTransformMatrices[8];
 372             break;
 373           case HWC_TRANSFORM_ROT_90:
 374             src_tex_mat = &kTextureTransformMatrices[12];
 375             break;
 376           case HWC_TRANSFORM_ROT_180:
 377             src_tex_mat = &kTextureTransformMatrices[16];
 378             break;
 379           case HWC_TRANSFORM_ROT_270:
 380             src_tex_mat = &kTextureTransformMatrices[20];
 381             break;
 382           default:
 383             ALOGE(
 384                 "Unknown transform for layer: defaulting to identity "
 385                 "transform");
 386           case 0:
 387             src_tex_mat = &kTextureTransformMatrices[0];
 388             break;
 389         }
 390         std::copy_n(src_tex_mat, 4, src.texture_matrix);
 391
 392         if (layer.blending == HWC_BLENDING_NONE) {
 393           src.alpha = 1.0f;
 394           // This layer is opaque. There is no point in using layers below this
 395           // one.
 396           break;
 397         }
 398
 399         src.alpha = layer.planeAlpha / 255.0f;
 400       }
 401     }
 402   }
 403 }
 404
 405 static int EGLFenceWait(EGLDisplay egl_display, int acquireFenceFd) {
 406   int ret = 0;
 407
 408   EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, acquireFenceFd,
 409                       EGL_NONE};
 410   EGLSyncKHR egl_sync =
 411       eglCreateSyncKHR(egl_display, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
 412   if (egl_sync == EGL_NO_SYNC_KHR) {
 413     ALOGE("Failed to make EGLSyncKHR from acquireFenceFd: %s", GetEGLError());
 414     close(acquireFenceFd);
 415     return 1;
 416   }
 417
 418   EGLint success = eglWaitSyncKHR(egl_display, egl_sync, 0);
 419   if (success == EGL_FALSE) {
 420     ALOGE("Failed to wait for acquire: %s", GetEGLError());
 421     ret = 1;
 422   }
 423   eglDestroySyncKHR(egl_display, egl_sync);
 424
 425   return ret;
 426 }
 427
 428 static int CreateTextureFromHandle(EGLDisplay egl_display,
 429                                    buffer_handle_t handle,
 430                                    AutoEGLImageAndGLTexture *out) {
 431   EGLImageKHR image = eglCreateImageKHR(
 432       egl_display, EGL_NO_CONTEXT, EGL_NATIVE_HANDLE_ANDROID_NVX,
 433       (EGLClientBuffer)handle, NULL /* no attribs */);
 434
 435   if (image == EGL_NO_IMAGE_KHR) {
 436     ALOGE("Failed to make image %s %p", GetEGLError(), handle);
 437     return -EINVAL;
 438   }
 439
 440   GLuint texture;
 441   glGenTextures(1, &texture);
 442   glBindTexture(GL_TEXTURE_2D, texture);
 443   glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
 444   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 445   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 446   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 447   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 448   glBindTexture(GL_TEXTURE_2D, 0);
 449
 450   out->image.reset(image);
 451   out->texture.reset(texture);
 452
 453   return 0;
 454 }
 455
 456 GLWorkerCompositor::GLWorkerCompositor()
 457     : egl_display_(EGL_NO_DISPLAY), egl_ctx_(EGL_NO_CONTEXT) {
 458 }
 459
 460 int GLWorkerCompositor::Init() {
 461   int ret = 0;
 462   const char *egl_extensions;
 463   const char *gl_extensions;
 464   EGLint num_configs;
 465   EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE, EGL_NONE};
 466   EGLConfig egl_config;
 467
 468   // clang-format off
 469   const GLfloat verts[] = {
 470     0.0f,  0.0f,    0.0f, 0.0f,
 471     0.0f,  2.0f,    0.0f, 2.0f,
 472     2.0f,  0.0f,    2.0f, 0.0f
 473   };
 474   // clang-format on
 475
 476   const EGLint config_attribs[] = {EGL_RENDERABLE_TYPE,
 477                                    EGL_OPENGL_ES2_BIT,
 478                                    EGL_RED_SIZE,
 479                                    8,
 480                                    EGL_GREEN_SIZE,
 481                                    8,
 482                                    EGL_BLUE_SIZE,
 483                                    8,
 484                                    EGL_NONE};
 485
 486   const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
 487
 488   egl_display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 489   if (egl_display_ == EGL_NO_DISPLAY) {
 490     ALOGE("Failed to get egl display");
 491     return 1;
 492   }
 493
 494   if (!eglInitialize(egl_display_, NULL, NULL)) {
 495     ALOGE("Failed to initialize egl: %s", GetEGLError());
 496     return 1;
 497   }
 498
 499   egl_extensions = eglQueryString(egl_display_, EGL_EXTENSIONS);
 500
 501   // These extensions are all technically required but not always reported due
 502   // to meta EGL filtering them out.
 503   if (!HasExtension("EGL_KHR_image_base", egl_extensions))
 504     ALOGW("EGL_KHR_image_base extension not supported");
 505
 506   if (!HasExtension("EGL_ANDROID_image_native_buffer", egl_extensions))
 507     ALOGW("EGL_ANDROID_image_native_buffer extension not supported");
 508
 509   if (!HasExtension("EGL_ANDROID_native_fence_sync", egl_extensions))
 510     ALOGW("EGL_ANDROID_native_fence_sync extension not supported");
 511
 512   if (!eglChooseConfig(egl_display_, config_attribs, &egl_config, 1,
 513                        &num_configs)) {
 514     ALOGE("eglChooseConfig() failed with error: %s", GetEGLError());
 515     return 1;
 516   }
 517
 518   egl_ctx_ =
 519       eglCreateContext(egl_display_, egl_config,
 520                        EGL_NO_CONTEXT /* No shared context */, context_attribs);
 521
 522   if (egl_ctx_ == EGL_NO_CONTEXT) {
 523     ALOGE("Failed to create OpenGL ES Context: %s", GetEGLError());
 524     return 1;
 525   }
 526
 527   if (!eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_ctx_)) {
 528     ALOGE("Failed to make the OpenGL ES Context current: %s", GetEGLError());
 529     return 1;
 530   }
 531
 532   gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
 533
 534   if (!HasExtension("GL_OES_EGL_image", gl_extensions))
 535     ALOGW("GL_OES_EGL_image extension not supported");
 536
 537   GLuint vertex_buffer;
 538   glGenBuffers(1, &vertex_buffer);
 539   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
 540   glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
 541   glBindBuffer(GL_ARRAY_BUFFER, 0);
 542   vertex_buffer_.reset(vertex_buffer);
 543
 544   if (GenerateShaders(&blend_programs_)) {
 545     return 1;
 546   }
 547
 548   return 0;
 549 }
 550
 551 GLWorkerCompositor::~GLWorkerCompositor() {
 552   if (egl_display_ != EGL_NO_DISPLAY && egl_ctx_ != EGL_NO_CONTEXT)
 553     if (eglDestroyContext(egl_display_, egl_ctx_) == EGL_FALSE)
 554       ALOGE("Failed to destroy OpenGL ES Context: %s", GetEGLError());
 555 }
 556
 557 int GLWorkerCompositor::Composite(hwc_layer_1 *layers, size_t num_layers,
 558                                   sp<GraphicBuffer> framebuffer) {
 559   ATRACE_CALL();
 560   int ret = 0;
 561   size_t i;
 562   std::vector<AutoEGLImageAndGLTexture> layer_textures;
 563   std::vector<RenderingCommand> commands;
 564
 565   if (num_layers == 0) {
 566     return -EALREADY;
 567   }
 568
 569   GLint frame_width = framebuffer->getWidth();
 570   GLint frame_height = framebuffer->getHeight();
 571   EGLSyncKHR finished_sync;
 572
 573   AutoEGLImageKHR egl_fb_image(
 574       eglCreateImageKHR(egl_display_, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
 575                         (EGLClientBuffer)framebuffer->getNativeBuffer(),
 576                         NULL /* no attribs */),
 577       EGLImageDeleter(egl_display_));
 578
 579   if (egl_fb_image.get() == EGL_NO_IMAGE_KHR) {
 580     ALOGE("Failed to make image from target buffer: %s", GetEGLError());
 581     return -EINVAL;
 582   }
 583
 584   GLuint gl_fb_tex;
 585   glGenTextures(1, &gl_fb_tex);
 586   AutoGLTexture gl_fb_tex_auto(gl_fb_tex);
 587   glBindTexture(GL_TEXTURE_2D, gl_fb_tex);
 588   glEGLImageTargetTexture2DOES(GL_TEXTURE_2D,
 589                                (GLeglImageOES)egl_fb_image.get());
 590   glBindTexture(GL_TEXTURE_2D, 0);
 591
 592   GLuint gl_fb;
 593   glGenFramebuffers(1, &gl_fb);
 594   AutoGLFramebuffer gl_fb_auto(gl_fb);
 595   glBindFramebuffer(GL_FRAMEBUFFER, gl_fb);
 596   glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
 597                          gl_fb_tex, 0);
 598
 599   if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
 600     ALOGE("Failed framebuffer check for created target buffer: %s",
 601           GetGLFramebufferError());
 602     return -EINVAL;
 603   }
 604
 605   for (i = 0; i < num_layers; i++) {
 606     const struct hwc_layer_1 *layer = &layers[i];
 607
 608     if (ret) {
 609       if (layer->acquireFenceFd >= 0)
 610         close(layer->acquireFenceFd);
 611       continue;
 612     }
 613
 614     layer_textures.emplace_back(egl_display_);
 615     ret = CreateTextureFromHandle(egl_display_, layer->handle,
 616                                   &layer_textures.back());
 617     if (!ret) {
 618       ret = EGLFenceWait(egl_display_, layer->acquireFenceFd);
 619     }
 620     if (ret) {
 621       layer_textures.pop_back();
 622       ret = -EINVAL;
 623     }
 624   }
 625
 626   if (ret)
 627     return ret;
 628
 629   ConstructCommands(layers, num_layers, &commands);
 630
 631   glViewport(0, 0, frame_width, frame_height);
 632
 633   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 634   glClear(GL_COLOR_BUFFER_BIT);
 635
 636   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_.get());
 637   glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, NULL);
 638   glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4,
 639                         (void *)(sizeof(float) * 2));
 640   glEnableVertexAttribArray(0);
 641   glEnableVertexAttribArray(1);
 642   glEnable(GL_SCISSOR_TEST);
 643
 644   for (const RenderingCommand &cmd : commands) {
 645     if (cmd.texture_count <= 0) {
 646       continue;
 647     }
 648
 649     // TODO(zachr): handle the case of too many overlapping textures for one
 650     // area by falling back to rendering as many layers as possible using
 651     // multiple blending passes.
 652     if (cmd.texture_count > blend_programs_.size()) {
 653       ALOGE("Too many layers to render in one area");
 654       continue;
 655     }
 656
 657     GLint program = blend_programs_[cmd.texture_count - 1].get();
 658     glUseProgram(program);
 659     GLint gl_viewport_loc = glGetUniformLocation(program, "uViewport");
 660     GLint gl_tex_loc = glGetUniformLocation(program, "uLayerTextures");
 661     GLint gl_crop_loc = glGetUniformLocation(program, "uLayerCrop");
 662     GLint gl_alpha_loc = glGetUniformLocation(program, "uLayerAlpha");
 663     GLint gl_tex_matrix_loc = glGetUniformLocation(program, "uTexMatrix");
 664     glUniform4f(gl_viewport_loc, cmd.bounds[0] / (float)frame_width,
 665                 cmd.bounds[1] / (float)frame_height,
 666                 (cmd.bounds[2] - cmd.bounds[0]) / (float)frame_width,
 667                 (cmd.bounds[3] - cmd.bounds[1]) / (float)frame_height);
 668
 669     for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
 670       const RenderingCommand::TextureSource &src = cmd.textures[src_index];
 671       glUniform1f(gl_alpha_loc + src_index, src.alpha);
 672       glUniform4f(gl_crop_loc + src_index, src.crop_bounds[0],
 673                   src.crop_bounds[1], src.crop_bounds[2] - src.crop_bounds[0],
 674                   src.crop_bounds[3] - src.crop_bounds[1]);
 675       glUniform1i(gl_tex_loc + src_index, src_index);
 676       glUniformMatrix2fv(gl_tex_matrix_loc + src_index, 1, GL_FALSE,
 677                          src.texture_matrix);
 678       glActiveTexture(GL_TEXTURE0 + src_index);
 679       glBindTexture(GL_TEXTURE_2D,
 680                     layer_textures[src.texture_index].texture.get());
 681     }
 682
 683     glScissor(cmd.bounds[0], cmd.bounds[1], cmd.bounds[2] - cmd.bounds[0],
 684               cmd.bounds[3] - cmd.bounds[1]);
 685     glDrawArrays(GL_TRIANGLES, 0, 3);
 686
 687     for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
 688       glActiveTexture(GL_TEXTURE0 + src_index);
 689       glBindTexture(GL_TEXTURE_2D, 0);
 690     }
 691   }
 692
 693   glDisable(GL_SCISSOR_TEST);
 694   glActiveTexture(GL_TEXTURE0);
 695   glDisableVertexAttribArray(0);
 696   glDisableVertexAttribArray(1);
 697   glBindBuffer(GL_ARRAY_BUFFER, 0);
 698   glUseProgram(0);
 699
 700   glBindFramebuffer(GL_FRAMEBUFFER, 0);
 701
 702   return ret;
 703 }
 704
 705 int GLWorkerCompositor::CompositeAndFinish(hwc_layer_1 *layers,
 706                                            size_t num_layers,
 707                                            sp<GraphicBuffer> framebuffer) {
 708   int ret = Composite(layers, num_layers, framebuffer);
 709   glFinish();
 710   return ret;
 711 }
 712
 713 int GLWorker::DoComposition(GLWorkerCompositor &compositor, Work *work) {
 714   int ret =
 715       compositor.Composite(work->layers, work->num_layers, work->framebuffer);
 716
 717   int timeline_fd = work->timeline_fd;
 718   work->timeline_fd = -1;
 719
 720   if (ret) {
 721     worker_ret_ = ret;
 722     glFinish();
 723     sw_sync_timeline_inc(timeline_fd, work->num_layers);
 724     close(timeline_fd);
 725     return pthread_cond_signal(&work_done_cond_);
 726   }
 727
 728   unsigned timeline_count = work->num_layers + 1;
 729   worker_ret_ = sw_sync_fence_create(timeline_fd, "GLComposition done fence",
 730                                      timeline_count);
 731   ret = pthread_cond_signal(&work_done_cond_);
 732
 733   glFinish();
 734
 735   sw_sync_timeline_inc(timeline_fd, timeline_count);
 736   close(timeline_fd);
 737
 738   return ret;
 739 }
 740
 741 GLWorker::GLWorker() : initialized_(false) {
 742 }
 743
 744 GLWorker::~GLWorker() {
 745   if (!initialized_)
 746     return;
 747
 748   if (SignalWorker(NULL, true) != 0 || pthread_join(thread_, NULL) != 0)
 749     pthread_kill(thread_, SIGTERM);
 750
 751   pthread_cond_destroy(&work_ready_cond_);
 752   pthread_cond_destroy(&work_done_cond_);
 753   pthread_mutex_destroy(&lock_);
 754 }
 755
 756 #define TRY(x, n, g)                  \
 757   ret = x;                            \
 758   if (ret) {                          \
 759     ALOGE("Failed to " n " %d", ret); \
 760     g;                                \
 761   }
 762
 763 #define TRY_RETURN(x, n) TRY(x, n, return ret)
 764
 765 int GLWorker::Init() {
 766   int ret = 0;
 767
 768   worker_work_ = NULL;
 769   worker_exit_ = false;
 770   worker_ret_ = -1;
 771
 772   ret = pthread_cond_init(&work_ready_cond_, NULL);
 773   if (ret) {
 774     ALOGE("Failed to int GLThread condition %d", ret);
 775     return ret;
 776   }
 777
 778   ret = pthread_cond_init(&work_done_cond_, NULL);
 779   if (ret) {
 780     ALOGE("Failed to int GLThread condition %d", ret);
 781     pthread_cond_destroy(&work_ready_cond_);
 782     return ret;
 783   }
 784
 785   ret = pthread_mutex_init(&lock_, NULL);
 786   if (ret) {
 787     ALOGE("Failed to init GLThread lock %d", ret);
 788     pthread_cond_destroy(&work_ready_cond_);
 789     pthread_cond_destroy(&work_done_cond_);
 790     return ret;
 791   }
 792
 793   ret = pthread_create(&thread_, NULL, StartRoutine, this);
 794   if (ret) {
 795     ALOGE("Failed to create GLThread %d", ret);
 796     pthread_cond_destroy(&work_ready_cond_);
 797     pthread_cond_destroy(&work_done_cond_);
 798     pthread_mutex_destroy(&lock_);
 799     return ret;
 800   }
 801
 802   initialized_ = true;
 803
 804   TRY_RETURN(pthread_mutex_lock(&lock_), "lock GLThread");
 805
 806   while (!worker_exit_ && worker_ret_ != 0)
 807     TRY(pthread_cond_wait(&work_done_cond_, &lock_), "wait on condition",
 808         goto out_unlock);
 809
 810   ret = worker_ret_;
 811
 812 out_unlock:
 813   int unlock_ret = pthread_mutex_unlock(&lock_);
 814   if (unlock_ret) {
 815     ret = unlock_ret;
 816     ALOGE("Failed to unlock GLThread %d", unlock_ret);
 817   }
 818   return ret;
 819 }
 820
 821 int GLWorker::SignalWorker(Work *work, bool worker_exit) {
 822   int ret = 0;
 823   if (worker_exit_)
 824     return -EINVAL;
 825   TRY_RETURN(pthread_mutex_lock(&lock_), "lock GLThread");
 826   worker_work_ = work;
 827   worker_exit_ = worker_exit;
 828   ret = pthread_cond_signal(&work_ready_cond_);
 829   if (ret) {
 830     ALOGE("Failed to signal GLThread caller %d", ret);
 831     pthread_mutex_unlock(&lock_);
 832     return ret;
 833   }
 834   ret = pthread_cond_wait(&work_done_cond_, &lock_);
 835   if (ret) {
 836     ALOGE("Failed to wait on GLThread %d", ret);
 837     pthread_mutex_unlock(&lock_);
 838     return ret;
 839   }
 840
 841   ret = worker_ret_;
 842   if (ret) {
 843     pthread_mutex_unlock(&lock_);
 844     return ret;
 845   }
 846   TRY_RETURN(pthread_mutex_unlock(&lock_), "unlock GLThread");
 847   return ret;
 848 }
 849
 850 int GLWorker::DoWork(Work *work) {
 851   return SignalWorker(work, false);
 852 }
 853
 854 void GLWorker::WorkerRoutine() {
 855   int ret = 0;
 856
 857   TRY(pthread_mutex_lock(&lock_), "lock GLThread", return );
 858
 859   GLWorkerCompositor compositor;
 860
 861   TRY(compositor.Init(), "initialize GL", goto out_signal_done);
 862
 863   worker_ret_ = 0;
 864   TRY(pthread_cond_signal(&work_done_cond_), "signal GLThread caller",
 865       goto out_signal_done);
 866
 867   while (true) {
 868     while (worker_work_ == NULL && !worker_exit_)
 869       TRY(pthread_cond_wait(&work_ready_cond_, &lock_), "wait on condition",
 870           goto out_signal_done);
 871
 872     if (worker_exit_) {
 873       ret = 0;
 874       break;
 875     }
 876
 877     ret = DoComposition(compositor, worker_work_);
 878
 879     worker_work_ = NULL;
 880     if (ret) {
 881       break;
 882     }
 883   }
 884
 885 out_signal_done:
 886   worker_exit_ = true;
 887   worker_ret_ = ret;
 888   TRY(pthread_cond_signal(&work_done_cond_), "signal GLThread caller",
 889       goto out_unlock);
 890 out_unlock:
 891   TRY(pthread_mutex_unlock(&lock_), "unlock GLThread", return );
 892 }
 893
 894 /* static */
 895 void *GLWorker::StartRoutine(void *arg) {
 896   setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
 897   GLWorker *worker = (GLWorker *)arg;
 898   worker->WorkerRoutine();
 899   return NULL;
 900 }
 901
 902 }  // namespace android