gl_compositor.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 LOG_TAG "GLCompositor"
  18
  19 #include <sstream>
  20 #include <string>
  21 #include <vector>
  22
  23 #include <cutils/log.h>
  24
  25 #define EGL_EGLEXT_PROTOTYPES
  26 #define GL_GLEXT_PROTOTYPES
  27
  28 #include <EGL/egl.h>
  29 #include <EGL/eglext.h>
  30 #include <GLES2/gl2.h>
  31 #include <GLES2/gl2ext.h>
  32
  33 #include <hardware/hardware.h>
  34 #include <hardware/hwcomposer.h>
  35
  36 #include <ui/GraphicBuffer.h>
  37 #include <ui/PixelFormat.h>
  38
  39 #include <cutils/properties.h>
  40 #include <sync/sync.h>
  41 #include <sw_sync.h>
  42
  43 #include "drm_hwcomposer.h"
  44
  45 #include "gl_compositor.h"
  46 #include "seperate_rects.h"
  47
  48 // TODO(zachr): use hwc_drm_bo to turn buffer handles into textures
  49 #ifndef EGL_NATIVE_HANDLE_ANDROID_NVX
  50 #define EGL_NATIVE_HANDLE_ANDROID_NVX 0x322A
  51 #endif
  52
  53 #define MAX_OVERLAPPING_LAYERS 64
  54
  55 namespace android {
  56
  57 struct GLCompositor::texture_from_handle {
  58   EGLImageKHR image;
  59   GLuint texture;
  60 };
  61
  62 static const char *get_gl_error(void);
  63 static const char *get_egl_error(void);
  64 static bool has_extension(const char *extension, const char *extensions);
  65
  66 template <typename T>
  67 int AllocResource(std::vector<T> &array) {
  68   for (typename std::vector<T>::iterator it = array.begin(); it != array.end();
  69        ++it) {
  70     if (!it->is_some()) {
  71       return std::distance(array.begin(), it);
  72     }
  73   }
  74
  75   array.push_back(T());
  76   return array.size() - 1;
  77 }
  78
  79 template <typename T>
  80 void FreeResource(std::vector<T> &array, int index) {
  81   if (index == (int)array.size() - 1) {
  82     array.pop_back();
  83   } else if (index >= 0 && (unsigned)index < array.size()) {
  84     array[index].Reset();
  85   }
  86 }
  87
  88 struct GLTarget {
  89   sp<GraphicBuffer> fb;
  90   EGLImageKHR egl_fb_image;
  91   GLuint gl_fb;
  92   GLuint gl_fb_tex;
  93   bool forgotten;
  94   unsigned composition_count;
  95
  96   GLTarget()
  97       : egl_fb_image(EGL_NO_IMAGE_KHR),
  98         gl_fb(0),
  99         gl_fb_tex(0),
 100         forgotten(true),
 101         composition_count(0) {
 102   }
 103
 104   void Reset() {
 105     fb.clear();
 106     egl_fb_image = EGL_NO_IMAGE_KHR;
 107     gl_fb = 0;
 108     gl_fb_tex = 0;
 109     forgotten = true;
 110     composition_count = 0;
 111   }
 112
 113   bool is_some() const {
 114     return egl_fb_image != EGL_NO_IMAGE_KHR;
 115   }
 116 };
 117
 118 struct GLCompositor::priv_data {
 119   EGLDisplay egl_display;
 120   EGLContext egl_ctx;
 121
 122   EGLDisplay saved_egl_display;
 123   EGLContext saved_egl_ctx;
 124   EGLSurface saved_egl_read;
 125   EGLSurface saved_egl_draw;
 126
 127   int current_target;
 128   std::vector<GLTarget> targets;
 129   std::vector<GLComposition *> compositions;
 130
 131   std::vector<GLint> blend_programs;
 132   GLuint vertex_buffer;
 133
 134   priv_data()
 135       : egl_display(EGL_NO_DISPLAY),
 136         egl_ctx(EGL_NO_CONTEXT),
 137         saved_egl_display(EGL_NO_DISPLAY),
 138         saved_egl_ctx(EGL_NO_CONTEXT),
 139         saved_egl_read(EGL_NO_SURFACE),
 140         saved_egl_draw(EGL_NO_SURFACE),
 141         current_target(-1) {
 142   }
 143 };
 144
 145 class GLComposition : public Composition {
 146  public:
 147   struct LayerData {
 148     hwc_layer_1 layer;
 149     hwc_drm_bo bo;
 150   };
 151
 152   GLComposition(GLCompositor *owner) : compositor(owner), target_handle(-1) {
 153   }
 154
 155   virtual ~GLComposition() {
 156     if (compositor == NULL) {
 157       return;
 158     }
 159
 160     // Removes this composition from the owning compositor automatically.
 161     std::vector<GLComposition *> &compositions =
 162         compositor->priv_->compositions;
 163     std::vector<GLComposition *>::iterator it =
 164         std::find(compositions.begin(), compositions.end(), this);
 165     if (it != compositions.end()) {
 166       compositions.erase(it);
 167     }
 168
 169     GLTarget *target = &compositor->priv_->targets[target_handle];
 170     target->composition_count--;
 171     compositor->CheckAndDestroyTarget(target_handle);
 172   }
 173
 174   virtual int AddLayer(int display, hwc_layer_1 *layer, hwc_drm_bo *bo) {
 175     (void)display;
 176     if (layer->compositionType != HWC_OVERLAY) {
 177       ALOGE("Must add layers with compositionType == HWC_OVERLAY");
 178       return 1;
 179     }
 180
 181     if (layer->handle == 0) {
 182       ALOGE("Must add layers with valid buffer handle");
 183       return 1;
 184     }
 185
 186     layer_data.push_back(LayerData());
 187     LayerData &layer_datum = layer_data.back();
 188     layer_datum.layer = *layer;
 189     layer_datum.bo = *bo;
 190
 191     return 0;
 192   }
 193
 194   virtual unsigned GetRemainingLayers(int display, unsigned num_needed) const {
 195     (void)display;
 196     return num_needed;
 197   }
 198
 199   GLCompositor *compositor;
 200   int target_handle;
 201   std::vector<LayerData> layer_data;
 202 };
 203
 204 struct RenderingCommand {
 205   struct TextureSource {
 206     unsigned texture_index;
 207     float crop_bounds[4];
 208     float alpha;
 209   };
 210
 211   float bounds[4];
 212   unsigned texture_count;
 213   TextureSource textures[MAX_OVERLAPPING_LAYERS];
 214
 215   RenderingCommand() : texture_count(0) {
 216   }
 217 };
 218
 219 static void ConstructCommands(const GLComposition &composition,
 220                               std::vector<RenderingCommand> *commands) {
 221   std::vector<seperate_rects::Rect<float> > in_rects;
 222   std::vector<seperate_rects::RectSet<uint64_t, float> > out_rects;
 223   int i;
 224
 225   for (unsigned rect_index = 0; rect_index < composition.layer_data.size();
 226        rect_index++) {
 227     const struct hwc_layer_1 &layer = composition.layer_data[rect_index].layer;
 228     seperate_rects::Rect<float> rect;
 229     in_rects.push_back(seperate_rects::Rect<float>(
 230         layer.displayFrame.left, layer.displayFrame.top,
 231         layer.displayFrame.right, layer.displayFrame.bottom));
 232   }
 233
 234   seperate_frects_64(in_rects, &out_rects);
 235
 236   for (unsigned rect_index = 0; rect_index < out_rects.size(); rect_index++) {
 237     const seperate_rects::RectSet<uint64_t, float> &out_rect =
 238         out_rects[rect_index];
 239     commands->push_back(RenderingCommand());
 240     RenderingCommand &cmd = commands->back();
 241
 242     memcpy(cmd.bounds, out_rect.rect.bounds, sizeof(cmd.bounds));
 243
 244     uint64_t tex_set = out_rect.id_set.getBits();
 245     for (unsigned i = composition.layer_data.size() - 1; tex_set != 0x0; i--) {
 246       if (tex_set & (0x1 << i)) {
 247         tex_set &= ~(0x1 << i);
 248
 249         const struct hwc_layer_1 &layer = composition.layer_data[i].layer;
 250
 251         seperate_rects::Rect<float> display_rect(
 252             layer.displayFrame.left, layer.displayFrame.top,
 253             layer.displayFrame.right, layer.displayFrame.bottom);
 254         float display_size[2] = {
 255             display_rect.bounds[2] - display_rect.bounds[0],
 256             display_rect.bounds[3] - display_rect.bounds[1]};
 257
 258         seperate_rects::Rect<float> crop_rect(
 259             layer.sourceCropf.left, layer.sourceCropf.top,
 260             layer.sourceCropf.right, layer.sourceCropf.bottom);
 261         float crop_size[2] = {crop_rect.bounds[2] - crop_rect.bounds[0],
 262                               crop_rect.bounds[3] - crop_rect.bounds[1]};
 263
 264         RenderingCommand::TextureSource &src = cmd.textures[cmd.texture_count];
 265         cmd.texture_count++;
 266         src.texture_index = i;
 267
 268         for (int b = 0; b < 4; b++) {
 269           float bound_percent = (cmd.bounds[b] - display_rect.bounds[b % 2]) /
 270                                 display_size[b % 2];
 271           src.crop_bounds[b] =
 272               crop_rect.bounds[b % 2] + bound_percent * crop_size[b % 2];
 273         }
 274
 275         if (layer.blending == HWC_BLENDING_NONE) {
 276           src.alpha = 1.0f;
 277           // This layer is opaque. There is no point in using layers below this
 278           // one.
 279           break;
 280         }
 281
 282         src.alpha = layer.planeAlpha / 255.0f;
 283       }
 284     }
 285   }
 286 }
 287
 288 GLCompositor::GLCompositor() {
 289   priv_ = new priv_data;
 290 }
 291
 292 GLCompositor::~GLCompositor() {
 293   if (BeginContext()) {
 294     goto destroy_ctx;
 295   }
 296
 297   glBindFramebuffer(GL_FRAMEBUFFER, 0);
 298   glBindTexture(GL_TEXTURE_2D, 0);
 299
 300   for (std::vector<GLTarget>::iterator it = priv_->targets.end();
 301        it != priv_->targets.begin(); it = priv_->targets.end()) {
 302     --it;
 303     glDeleteFramebuffers(1, &it->gl_fb);
 304     glDeleteTextures(1, &it->gl_fb_tex);
 305     eglDestroyImageKHR(priv_->egl_display, it->egl_fb_image);
 306     priv_->targets.erase(it);
 307   }
 308
 309   for (std::vector<GLComposition *>::iterator it = priv_->compositions.end();
 310        it != priv_->compositions.begin(); it = priv_->compositions.end()) {
 311     --it;
 312
 313     // Prevents compositor from trying to erase itself
 314     (*it)->compositor = NULL;
 315     delete *it;
 316     priv_->compositions.erase(it);
 317   }
 318
 319 destroy_ctx:
 320   eglMakeCurrent(priv_->egl_display,
 321                  EGL_NO_SURFACE /* No default draw surface */,
 322                  EGL_NO_SURFACE /* No default draw read */, EGL_NO_CONTEXT);
 323   eglDestroyContext(priv_->egl_display, priv_->egl_ctx);
 324
 325   EndContext();
 326   delete priv_;
 327 }
 328
 329 int GLCompositor::Init() {
 330   int ret = 0;
 331   const char *egl_extensions;
 332   const char *gl_extensions;
 333   EGLint num_configs;
 334   EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE, EGL_NONE};
 335   EGLConfig egl_config;
 336
 337   // clang-format off
 338   const GLfloat verts[] = {
 339     0.0f,  0.0f,    0.0f, 0.0f,
 340     0.0f,  1.0f,    0.0f, 1.0f,
 341     1.0f,  0.0f,    1.0f, 0.0f,
 342     1.0f,  1.0f,    1.0f, 1.0f
 343   };
 344   // clang-format on
 345
 346   const EGLint config_attribs[] = {EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
 347                                    EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8,
 348                                    EGL_BLUE_SIZE, 8, EGL_NONE};
 349
 350   const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
 351
 352   priv_->egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 353   if (priv_->egl_display == EGL_NO_DISPLAY) {
 354     ALOGE("Failed to get egl display");
 355     ret = 1;
 356     goto out;
 357   }
 358
 359   if (!eglInitialize(priv_->egl_display, NULL, NULL)) {
 360     ALOGE("Failed to initialize egl: %s", get_egl_error());
 361     ret = 1;
 362     goto out;
 363   }
 364
 365   egl_extensions = eglQueryString(priv_->egl_display, EGL_EXTENSIONS);
 366
 367   // These extensions are all technically required but not always reported due
 368   // to meta EGL filtering them out.
 369   if (!has_extension("EGL_KHR_image_base", egl_extensions))
 370     ALOGW("EGL_KHR_image_base extension not supported");
 371
 372   if (!has_extension("EGL_ANDROID_image_native_buffer", egl_extensions))
 373     ALOGW("EGL_ANDROID_image_native_buffer extension not supported");
 374
 375   if (!has_extension("EGL_ANDROID_native_fence_sync", egl_extensions))
 376     ALOGW("EGL_ANDROID_native_fence_sync extension not supported");
 377
 378   if (!eglChooseConfig(priv_->egl_display, config_attribs, &egl_config, 1,
 379                        &num_configs)) {
 380     ALOGE("eglChooseConfig() failed with error: %s", get_egl_error());
 381     goto out;
 382   }
 383
 384   priv_->egl_ctx =
 385       eglCreateContext(priv_->egl_display, egl_config,
 386                        EGL_NO_CONTEXT /* No shared context */, context_attribs);
 387
 388   if (priv_->egl_ctx == EGL_NO_CONTEXT) {
 389     ALOGE("Failed to create OpenGL ES Context: %s", get_egl_error());
 390     ret = 1;
 391     goto out;
 392   }
 393
 394   ret = BeginContext();
 395   if (ret)
 396     goto out;
 397
 398   gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
 399
 400   if (!has_extension("GL_OES_EGL_image", gl_extensions))
 401     ALOGW("GL_OES_EGL_image extension not supported");
 402
 403   glGenBuffers(1, &priv_->vertex_buffer);
 404   glBindBuffer(GL_ARRAY_BUFFER, priv_->vertex_buffer);
 405   glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
 406   glBindBuffer(GL_ARRAY_BUFFER, 0);
 407
 408   if (GenerateShaders()) {
 409     ret = 1;
 410     goto end_ctx;
 411   }
 412
 413 end_ctx:
 414   EndContext();
 415
 416 out:
 417   return ret;
 418 }
 419
 420 Targeting *GLCompositor::targeting() {
 421   return (Targeting *)this;
 422 }
 423
 424 int GLCompositor::CreateTarget(sp<GraphicBuffer> &buffer) {
 425   int ret;
 426
 427   ret = BeginContext();
 428   if (ret)
 429     return -1;
 430
 431   int target_handle = AllocResource(priv_->targets);
 432   GLTarget *target = &priv_->targets[target_handle];
 433
 434   target->fb = buffer;
 435
 436   target->egl_fb_image = eglCreateImageKHR(
 437       priv_->egl_display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
 438       (EGLClientBuffer)target->fb->getNativeBuffer(), NULL /* no attribs */);
 439
 440   if (target->egl_fb_image == EGL_NO_IMAGE_KHR) {
 441     ALOGE("Failed to make image from target buffer: %s", get_egl_error());
 442     ret = -1;
 443     goto fail_create_image;
 444   }
 445
 446   glGenTextures(1, &target->gl_fb_tex);
 447   glBindTexture(GL_TEXTURE_2D, target->gl_fb_tex);
 448   glEGLImageTargetTexture2DOES(GL_TEXTURE_2D,
 449                                (GLeglImageOES)target->egl_fb_image);
 450   glBindTexture(GL_TEXTURE_2D, 0);
 451
 452   glGenFramebuffers(1, &target->gl_fb);
 453   glBindFramebuffer(GL_FRAMEBUFFER, target->gl_fb);
 454   glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
 455                          target->gl_fb_tex, 0);
 456
 457   if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
 458     ALOGE("Failed framebuffer check for created target buffer");
 459     ret = 1;
 460     goto fail_framebuffer_status;
 461   }
 462
 463   target->forgotten = false;
 464
 465   ret = target_handle;
 466   goto out;
 467
 468 fail_framebuffer_status:
 469   glBindFramebuffer(GL_FRAMEBUFFER, 0);
 470   glDeleteFramebuffers(1, &target->gl_fb);
 471   glDeleteTextures(1, &target->gl_fb_tex);
 472   eglDestroyImageKHR(priv_->egl_display, target->egl_fb_image);
 473   target->gl_fb = 0;
 474   target->gl_fb_tex = 0;
 475   target->egl_fb_image = EGL_NO_IMAGE_KHR;
 476
 477 fail_create_image:
 478   target->fb.clear();
 479   FreeResource(priv_->targets, target_handle);
 480
 481 out:
 482   EndContext();
 483   return ret;
 484 }
 485
 486 void GLCompositor::SetTarget(int target_handle) {
 487   if (target_handle >= 0 && (unsigned)target_handle < priv_->targets.size()) {
 488     GLTarget *target = &priv_->targets[target_handle];
 489     if (target->is_some()) {
 490       priv_->current_target = target_handle;
 491       return;
 492     }
 493   }
 494
 495   priv_->current_target = -1;
 496 }
 497
 498 void GLCompositor::ForgetTarget(int target_handle) {
 499   if (target_handle >= 0 && (unsigned)target_handle < priv_->targets.size()) {
 500     if (target_handle == priv_->current_target) {
 501       priv_->current_target = -1;
 502     }
 503
 504     GLTarget *target = &priv_->targets[target_handle];
 505     if (target->is_some()) {
 506       target->forgotten = true;
 507       CheckAndDestroyTarget(target_handle);
 508       return;
 509     }
 510   }
 511
 512   ALOGE("Failed to forget target because of invalid handle");
 513 }
 514
 515 void GLCompositor::CheckAndDestroyTarget(int target_handle) {
 516   GLTarget *target = &priv_->targets[target_handle];
 517   if (target->composition_count == 0 && target->forgotten) {
 518     if (BeginContext() == 0) {
 519       glDeleteFramebuffers(1, &target->gl_fb);
 520       glDeleteTextures(1, &target->gl_fb_tex);
 521       eglDestroyImageKHR(priv_->egl_display, target->egl_fb_image);
 522       EndContext();
 523     }
 524
 525     FreeResource(priv_->targets, target_handle);
 526   }
 527 }
 528
 529 Composition *GLCompositor::CreateComposition() {
 530   if (priv_->current_target >= 0 &&
 531       (unsigned)priv_->current_target < priv_->targets.size()) {
 532     GLTarget *target = &priv_->targets[priv_->current_target];
 533     if (target->is_some()) {
 534       GLComposition *composition = new GLComposition(this);
 535       composition->target_handle = priv_->current_target;
 536       target->composition_count++;
 537       priv_->compositions.push_back(composition);
 538       return composition;
 539     }
 540   }
 541
 542   ALOGE("Failed to create composition because of invalid target handle %d",
 543         priv_->current_target);
 544
 545   return NULL;
 546 }
 547
 548 int GLCompositor::QueueComposition(Composition *composition) {
 549   if (composition) {
 550     int ret = DoComposition(*(GLComposition *)composition);
 551     delete composition;
 552     return ret;
 553   }
 554
 555   ALOGE("Failed to queue composition because of invalid composition handle");
 556
 557   return -EINVAL;
 558 }
 559
 560 int GLCompositor::Composite() {
 561   return 0;
 562 }
 563
 564 int GLCompositor::BeginContext() {
 565   priv_->saved_egl_display = eglGetCurrentDisplay();
 566   priv_->saved_egl_ctx = eglGetCurrentContext();
 567
 568   if (priv_->saved_egl_display != priv_->egl_display ||
 569       priv_->saved_egl_ctx != priv_->egl_ctx) {
 570     priv_->saved_egl_read = eglGetCurrentSurface(EGL_READ);
 571     priv_->saved_egl_draw = eglGetCurrentSurface(EGL_DRAW);
 572   } else {
 573     return 0;
 574   }
 575
 576   if (!eglMakeCurrent(priv_->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
 577                       priv_->egl_ctx)) {
 578     ALOGE("Failed to make the OpenGL ES Context current: %s", get_egl_error());
 579     return 1;
 580   }
 581   return 0;
 582 }
 583
 584 int GLCompositor::EndContext() {
 585   if (priv_->saved_egl_display != eglGetCurrentDisplay() ||
 586       priv_->saved_egl_ctx != eglGetCurrentContext()) {
 587     if (!eglMakeCurrent(priv_->saved_egl_display, priv_->saved_egl_read,
 588                         priv_->saved_egl_draw, priv_->saved_egl_ctx)) {
 589       ALOGE("Failed to make the OpenGL ES Context current: %s",
 590             get_egl_error());
 591       return 1;
 592     }
 593   }
 594
 595   return 0;
 596 }
 597
 598 GLint CompileAndCheckShader(GLenum type, unsigned source_count,
 599                             const GLchar **sources, std::string *shader_log) {
 600   GLint status;
 601   GLint shader = glCreateShader(type);
 602   if (!shader) {
 603     *shader_log = "glCreateShader failed";
 604     return 0;
 605   }
 606   glShaderSource(shader, source_count, sources, NULL);
 607   glCompileShader(shader);
 608   glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
 609   if (!status) {
 610     if (shader_log) {
 611       GLint log_length;
 612       glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
 613       shader_log->resize(log_length);
 614       glGetShaderInfoLog(shader, log_length, NULL, &(*shader_log)[0]);
 615     }
 616     glDeleteShader(shader);
 617     return 0;
 618   }
 619
 620   return shader;
 621 }
 622
 623 int GLCompositor::GenerateShaders() {
 624   // Limits: GL_MAX_VARYING_COMPONENTS, GL_MAX_TEXTURE_IMAGE_UNITS,
 625   // GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
 626   // clang-format off
 627   const GLchar *shader_preamble = "#version 300 es\n#define LAYER_COUNT ";
 628
 629   const GLchar *vertex_shader_source =
 630 "\n"
 631 "precision mediump int;                                                     \n"
 632 "uniform vec4 uViewport;                                                    \n"
 633 "uniform sampler2D uLayerTextures[LAYER_COUNT];                             \n"
 634 "uniform vec4 uLayerCrop[LAYER_COUNT];                                      \n"
 635 "in vec2 vPosition;                                                         \n"
 636 "in vec2 vTexCoords;                                                        \n"
 637 "out vec2 fTexCoords[LAYER_COUNT];                                          \n"
 638 "void main() {                                                              \n"
 639 "  for (int i = 0; i < LAYER_COUNT; i++) {                                  \n"
 640 "    fTexCoords[i] = (uLayerCrop[i].xy + vTexCoords * uLayerCrop[i].zw) /   \n"
 641 "                     vec2(textureSize(uLayerTextures[i], 0));              \n"
 642 "  }                                                                        \n"
 643 "  vec2 scaledPosition = uViewport.xy + vPosition * uViewport.zw;           \n"
 644 "  gl_Position = vec4(scaledPosition * vec2(2.0) - vec2(1.0), 0.0, 1.0);    \n"
 645 "}                                                                          \n";
 646
 647   const GLchar *fragment_shader_source =
 648 "\n"
 649 "precision mediump float;                                                   \n"
 650 "uniform sampler2D uLayerTextures[LAYER_COUNT];                             \n"
 651 "uniform float uLayerAlpha[LAYER_COUNT];                                    \n"
 652 "in vec2 fTexCoords[LAYER_COUNT];                                           \n"
 653 "out vec4 oFragColor;                                                       \n"
 654 "void main() {                                                              \n"
 655 "  vec3 color = vec3(0.0, 0.0, 0.0);                                        \n"
 656 "  float alphaCover = 1.0;                                                  \n"
 657 "  for (int i = 0; i < LAYER_COUNT; i++) {                                  \n"
 658 "    vec4 texSample = texture(uLayerTextures[i], fTexCoords[i]);            \n"
 659 "    float a = texSample.a * uLayerAlpha[i];                                \n"
 660 "    color += a * alphaCover * texSample.rgb;                               \n"
 661 "    alphaCover *= 1.0 - a;                                                 \n"
 662 "    if (alphaCover <= 0.5/255.0)                                           \n"
 663 "      break;                                                               \n"
 664 "  }                                                                        \n"
 665 "  oFragColor = vec4(color, 1.0);                                           \n"
 666 "}                                                                          \n";
 667   // clang-format on
 668
 669   int i, ret = 1;
 670   GLint max_texture_images, vertex_shader, fragment_shader, program, status;
 671   std::string shader_log;
 672
 673   glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_images);
 674
 675   for (i = 1; i <= max_texture_images; i++) {
 676     std::ostringstream layer_count_formatter;
 677     layer_count_formatter << i;
 678     std::string layer_count(layer_count_formatter.str());
 679     const GLchar *shader_sources[3] = {shader_preamble, layer_count.c_str(),
 680                                        NULL};
 681
 682     shader_sources[2] = vertex_shader_source;
 683     vertex_shader = CompileAndCheckShader(GL_VERTEX_SHADER, 3, shader_sources,
 684                                           ret ? &shader_log : NULL);
 685     if (!vertex_shader) {
 686       if (ret) {
 687         ALOGE("Failed to make vertex shader:\n%s", shader_log.c_str());
 688       }
 689       break;
 690     }
 691
 692     shader_sources[2] = fragment_shader_source;
 693     fragment_shader = CompileAndCheckShader(
 694         GL_FRAGMENT_SHADER, 3, shader_sources, ret ? &shader_log : NULL);
 695     if (!fragment_shader) {
 696       if (ret) {
 697         ALOGE("Failed to make fragment shader:\n%s", shader_log.c_str());
 698       }
 699       goto delete_vs;
 700     }
 701
 702     program = glCreateProgram();
 703     if (!program) {
 704       if (ret)
 705         ALOGE("Failed to create program %s", get_gl_error());
 706       goto delete_fs;
 707     }
 708
 709     glAttachShader(program, vertex_shader);
 710     glAttachShader(program, fragment_shader);
 711     glBindAttribLocation(program, 0, "vPosition");
 712     glBindAttribLocation(program, 1, "vTexCoords");
 713     glLinkProgram(program);
 714     glDetachShader(program, vertex_shader);
 715     glDeleteShader(vertex_shader);
 716     glDetachShader(program, fragment_shader);
 717     glDeleteShader(fragment_shader);
 718
 719     glGetProgramiv(program, GL_LINK_STATUS, &status);
 720     if (!status) {
 721       if (ret) {
 722         GLint log_length;
 723         glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);
 724         std::string program_log(log_length, ' ');
 725         glGetProgramInfoLog(program, log_length, NULL, &program_log[0]);
 726         ALOGE("Failed to link program: \n%s", program_log.c_str());
 727       }
 728       glDeleteProgram(program);
 729       break;
 730     }
 731
 732     ret = 0;
 733     priv_->blend_programs.push_back(program);
 734
 735     continue;
 736
 737   delete_fs:
 738     glDeleteShader(fragment_shader);
 739
 740   delete_vs:
 741     glDeleteShader(vertex_shader);
 742
 743     if (ret)
 744       break;
 745   }
 746
 747   return ret;
 748 }
 749
 750 int GLCompositor::DoComposition(const GLComposition &composition) {
 751   int ret = 0;
 752   size_t i;
 753   std::vector<struct texture_from_handle> layer_textures;
 754   std::vector<RenderingCommand> commands;
 755
 756   if (composition.layer_data.size() == 0) {
 757     return -EALREADY;
 758   }
 759
 760   if (BeginContext()) {
 761     return -EINVAL;
 762   }
 763
 764   GLTarget *target = &priv_->targets[composition.target_handle];
 765   GLint frame_width = target->fb->getWidth();
 766   GLint frame_height = target->fb->getHeight();
 767   EGLSyncKHR finished_sync;
 768
 769   for (i = 0; i < composition.layer_data.size(); i++) {
 770     const struct hwc_layer_1 *layer = &composition.layer_data[i].layer;
 771
 772     if (ret) {
 773       if (layer->acquireFenceFd >= 0)
 774         close(layer->acquireFenceFd);
 775       continue;
 776     }
 777
 778     layer_textures.push_back(texture_from_handle());
 779     ret = CreateTextureFromHandle(layer->handle, &layer_textures.back());
 780     if (!ret) {
 781       ret = DoFenceWait(layer->acquireFenceFd);
 782     }
 783     if (ret) {
 784       layer_textures.pop_back();
 785       ret = -EINVAL;
 786     }
 787   }
 788
 789   if (ret) {
 790     goto destroy_textures;
 791   }
 792
 793   ConstructCommands(composition, &commands);
 794
 795   glBindFramebuffer(GL_FRAMEBUFFER, target->gl_fb);
 796
 797   glViewport(0, 0, frame_width, frame_height);
 798
 799   glClearColor(1.0f, 1.0f, 0.0f, 1.0f);
 800   glClear(GL_COLOR_BUFFER_BIT);
 801
 802   glBindBuffer(GL_ARRAY_BUFFER, priv_->vertex_buffer);
 803   glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, NULL);
 804   glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4,
 805                         (void *)(sizeof(float) * 2));
 806   glEnableVertexAttribArray(0);
 807   glEnableVertexAttribArray(1);
 808
 809   for (std::vector<RenderingCommand>::iterator it = commands.begin();
 810        it != commands.end(); ++it) {
 811     const RenderingCommand &cmd = *it;
 812
 813     if (cmd.texture_count <= 0) {
 814       continue;
 815     }
 816
 817     // TODO(zachr): handle the case of too many overlapping textures for one
 818     // area by falling back to rendering as many layers as possible using
 819     // multiple blending passes.
 820     if (cmd.texture_count > priv_->blend_programs.size()) {
 821       ALOGE("Too many layers to render in one area");
 822       continue;
 823     }
 824
 825     GLint program = priv_->blend_programs[cmd.texture_count - 1];
 826     glUseProgram(program);
 827     GLint gl_viewport_loc = glGetUniformLocation(program, "uViewport");
 828     GLint gl_tex_loc = glGetUniformLocation(program, "uLayerTextures");
 829     GLint gl_crop_loc = glGetUniformLocation(program, "uLayerCrop");
 830     GLint gl_alpha_loc = glGetUniformLocation(program, "uLayerAlpha");
 831     glUniform4f(gl_viewport_loc, cmd.bounds[0] / (float)frame_width,
 832                 cmd.bounds[1] / (float)frame_height,
 833                 (cmd.bounds[2] - cmd.bounds[0]) / (float)frame_width,
 834                 (cmd.bounds[3] - cmd.bounds[1]) / (float)frame_height);
 835
 836     for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
 837       const RenderingCommand::TextureSource &src = cmd.textures[src_index];
 838       glUniform1f(gl_alpha_loc + src_index, src.alpha);
 839       glUniform4f(gl_crop_loc + src_index, src.crop_bounds[0],
 840                   src.crop_bounds[1], src.crop_bounds[2] - src.crop_bounds[0],
 841                   src.crop_bounds[3] - src.crop_bounds[1]);
 842
 843       glUniform1i(gl_tex_loc + src_index, src_index);
 844       glActiveTexture(GL_TEXTURE0 + src_index);
 845       glBindTexture(GL_TEXTURE_2D, layer_textures[src.texture_index].texture);
 846     }
 847
 848     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 849
 850     for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
 851       glActiveTexture(GL_TEXTURE0 + src_index);
 852       glBindTexture(GL_TEXTURE_2D, 0);
 853     }
 854   }
 855
 856   glActiveTexture(GL_TEXTURE0);
 857   glDisableVertexAttribArray(0);
 858   glDisableVertexAttribArray(1);
 859   glBindBuffer(GL_ARRAY_BUFFER, 0);
 860   glUseProgram(0);
 861
 862   glBindFramebuffer(GL_FRAMEBUFFER, 0);
 863
 864   finished_sync =
 865       eglCreateSyncKHR(priv_->egl_display, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
 866   if (finished_sync != EGL_NO_SYNC_KHR) {
 867     glFlush();  // Creates the syncpoint
 868     ret = eglDupNativeFenceFDANDROID(priv_->egl_display, finished_sync);
 869     eglDestroySyncKHR(priv_->egl_display, finished_sync);
 870     if (ret != EGL_NO_NATIVE_FENCE_FD_ANDROID) {
 871       goto destroy_textures;
 872     }
 873   }
 874
 875   // Used as a fallback if the native sync fence fails.
 876   ret = -EALREADY;
 877   glFinish();
 878
 879 destroy_textures:
 880   for (i = 0; i < layer_textures.size(); i++)
 881     DestroyTextureFromHandle(layer_textures[i]);
 882
 883   EndContext();
 884
 885   return ret;
 886 }
 887
 888 int GLCompositor::DoFenceWait(int acquireFenceFd) {
 889   int ret = 0;
 890
 891   EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, acquireFenceFd,
 892                       EGL_NONE};
 893   EGLSyncKHR egl_sync = eglCreateSyncKHR(
 894       priv_->egl_display, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
 895   if (egl_sync == EGL_NO_SYNC_KHR) {
 896     ALOGE("Failed to make EGLSyncKHR from acquireFenceFd: %s", get_egl_error());
 897     close(acquireFenceFd);
 898     return 1;
 899   }
 900
 901   EGLint success = eglWaitSyncKHR(priv_->egl_display, egl_sync, 0);
 902   if (success == EGL_FALSE) {
 903     ALOGE("Failed to wait for acquire: %s", get_egl_error());
 904     ret = 1;
 905   }
 906   eglDestroySyncKHR(priv_->egl_display, egl_sync);
 907
 908   return ret;
 909 }
 910
 911 int GLCompositor::CreateTextureFromHandle(buffer_handle_t handle,
 912                                           struct texture_from_handle *tex) {
 913   EGLImageKHR image = eglCreateImageKHR(
 914       priv_->egl_display, EGL_NO_CONTEXT, EGL_NATIVE_HANDLE_ANDROID_NVX,
 915       (EGLClientBuffer)handle, NULL /* no attribs */);
 916
 917   if (image == EGL_NO_IMAGE_KHR) {
 918     ALOGE("Failed to make image %s %p", get_egl_error(), handle);
 919     return 1;
 920   }
 921
 922   glGenTextures(1, &tex->texture);
 923   glBindTexture(GL_TEXTURE_2D, tex->texture);
 924   glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
 925   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 926   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 927   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 928   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 929
 930   tex->image = image;
 931
 932   return 0;
 933 }
 934
 935 void GLCompositor::DestroyTextureFromHandle(
 936     const struct texture_from_handle &tex) {
 937   glDeleteTextures(1, &tex.texture);
 938   eglDestroyImageKHR(priv_->egl_display, tex.image);
 939 }
 940
 941 static const char *get_gl_error(void) {
 942   switch (glGetError()) {
 943     case GL_NO_ERROR:
 944       return "GL_NO_ERROR";
 945     case GL_INVALID_ENUM:
 946       return "GL_INVALID_ENUM";
 947     case GL_INVALID_VALUE:
 948       return "GL_INVALID_VALUE";
 949     case GL_INVALID_OPERATION:
 950       return "GL_INVALID_OPERATION";
 951     case GL_INVALID_FRAMEBUFFER_OPERATION:
 952       return "GL_INVALID_FRAMEBUFFER_OPERATION";
 953     case GL_OUT_OF_MEMORY:
 954       return "GL_OUT_OF_MEMORY";
 955     default:
 956       return "Unknown error";
 957   }
 958 }
 959
 960 static const char *get_egl_error(void) {
 961   switch (eglGetError()) {
 962     case EGL_SUCCESS:
 963       return "EGL_SUCCESS";
 964     case EGL_NOT_INITIALIZED:
 965       return "EGL_NOT_INITIALIZED";
 966     case EGL_BAD_ACCESS:
 967       return "EGL_BAD_ACCESS";
 968     case EGL_BAD_ALLOC:
 969       return "EGL_BAD_ALLOC";
 970     case EGL_BAD_ATTRIBUTE:
 971       return "EGL_BAD_ATTRIBUTE";
 972     case EGL_BAD_CONTEXT:
 973       return "EGL_BAD_CONTEXT";
 974     case EGL_BAD_CONFIG:
 975       return "EGL_BAD_CONFIG";
 976     case EGL_BAD_CURRENT_SURFACE:
 977       return "EGL_BAD_CURRENT_SURFACE";
 978     case EGL_BAD_DISPLAY:
 979       return "EGL_BAD_DISPLAY";
 980     case EGL_BAD_SURFACE:
 981       return "EGL_BAD_SURFACE";
 982     case EGL_BAD_MATCH:
 983       return "EGL_BAD_MATCH";
 984     case EGL_BAD_PARAMETER:
 985       return "EGL_BAD_PARAMETER";
 986     case EGL_BAD_NATIVE_PIXMAP:
 987       return "EGL_BAD_NATIVE_PIXMAP";
 988     case EGL_BAD_NATIVE_WINDOW:
 989       return "EGL_BAD_NATIVE_WINDOW";
 990     case EGL_CONTEXT_LOST:
 991       return "EGL_CONTEXT_LOST";
 992     default:
 993       return "Unknown error";
 994   }
 995 }
 996
 997 static bool has_extension(const char *extension, const char *extensions) {
 998   const char *start, *where, *terminator;
 999   start = extensions;
1000   for (;;) {
1001     where = (char *)strstr((const char *)start, extension);
1002     if (!where)
1003       break;
1004     terminator = where + strlen(extension);
1005     if (where == start || *(where - 1) == ' ')
1006       if (*terminator == ' ' || *terminator == '\0')
1007         return true;
1008     start = terminator;
1009   }
1010   return false;
1011 }
1012
1013 }  // namespace android