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