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