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