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