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