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