• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
GetGLError(void)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 
GetGLFramebufferError(void)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 
GetEGLError(void)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 
HasExtension(const char * extension,const char * extensions)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 
CompileAndCheckShader(GLenum type,unsigned source_count,const GLchar ** sources,std::ostringstream * shader_log)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 
GenerateVertexShader(int layer_count)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 
GenerateFragmentShader(int layer_count)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 
GenerateProgram(unsigned num_textures,std::ostringstream * shader_log)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 
ConstructCommand(const DrmHwcLayer * layers,const DrmCompositionRegion & region,RenderingCommand & cmd)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 = false;
336     bool flip_xy[2] = { false, false };
337 
338     if (layer.transform == DrmHwcTransform::kRotate180) {
339       swap_xy = false;
340       flip_xy[0] = true;
341       flip_xy[1] = true;
342     } else if (layer.transform == DrmHwcTransform::kRotate270) {
343       swap_xy = true;
344       flip_xy[0] = true;
345       flip_xy[1] = false;
346     } else if (layer.transform & DrmHwcTransform::kRotate90) {
347       swap_xy = true;
348       if (layer.transform & DrmHwcTransform::kFlipH) {
349         flip_xy[0] = true;
350         flip_xy[1] = true;
351       } else if (layer.transform & DrmHwcTransform::kFlipV) {
352         flip_xy[0] = false;
353         flip_xy[1] = false;
354       } else {
355         flip_xy[0] = false;
356         flip_xy[1] = true;
357       }
358     } else {
359       if (layer.transform & DrmHwcTransform::kFlipH)
360         flip_xy[0] = true;
361       if (layer.transform & DrmHwcTransform::kFlipV)
362         flip_xy[1] = true;
363     }
364 
365     if (swap_xy)
366       std::copy_n(&kTextureTransformMatrices[4], 4, src.texture_matrix);
367     else
368       std::copy_n(&kTextureTransformMatrices[0], 4, src.texture_matrix);
369 
370     for (int j = 0; j < 4; j++) {
371       int b = j ^ (swap_xy ? 1 : 0);
372       float bound_percent =
373           (cmd.bounds[b] - display_rect.bounds[b % 2]) / display_size[b % 2];
374       if (flip_xy[j % 2]) {
375         src.crop_bounds[j] =
376             crop_rect.bounds[j % 2 + 2] - bound_percent * crop_size[j % 2];
377       } else {
378         src.crop_bounds[j] =
379             crop_rect.bounds[j % 2] + bound_percent * crop_size[j % 2];
380       }
381     }
382 
383     if (layer.blending == DrmHwcBlending::kNone) {
384       src.alpha = src.premult = 1.0f;
385       // This layer is opaque. There is no point in using layers below this one.
386       break;
387     }
388 
389     src.alpha = layer.alpha / 255.0f;
390     src.premult = (layer.blending == DrmHwcBlending::kPreMult) ? 1.0f : 0.0f;
391   }
392 }
393 
EGLFenceWait(EGLDisplay egl_display,int acquireFenceFd)394 static int EGLFenceWait(EGLDisplay egl_display, int acquireFenceFd) {
395   int ret = 0;
396 
397   EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, acquireFenceFd,
398                       EGL_NONE};
399   EGLSyncKHR egl_sync =
400       eglCreateSyncKHR(egl_display, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
401   if (egl_sync == EGL_NO_SYNC_KHR) {
402     ALOGE("Failed to make EGLSyncKHR from acquireFenceFd: %s", GetEGLError());
403     close(acquireFenceFd);
404     return 1;
405   }
406 
407   EGLint success = eglWaitSyncKHR(egl_display, egl_sync, 0);
408   if (success == EGL_FALSE) {
409     ALOGE("Failed to wait for acquire: %s", GetEGLError());
410     ret = 1;
411   }
412   eglDestroySyncKHR(egl_display, egl_sync);
413 
414   return ret;
415 }
416 
CreateTextureFromHandle(EGLDisplay egl_display,buffer_handle_t handle,AutoEGLImageAndGLTexture * out)417 static int CreateTextureFromHandle(EGLDisplay egl_display,
418                                    buffer_handle_t handle,
419                                    AutoEGLImageAndGLTexture *out) {
420   EGLImageKHR image = eglCreateImageKHR(
421       egl_display, EGL_NO_CONTEXT, EGL_NATIVE_HANDLE_ANDROID_NVX,
422       (EGLClientBuffer)handle, NULL /* no attribs */);
423 
424   if (image == EGL_NO_IMAGE_KHR) {
425     ALOGE("Failed to make image %s %p", GetEGLError(), handle);
426     return -EINVAL;
427   }
428 
429   GLuint texture;
430   glGenTextures(1, &texture);
431   glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
432   glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, (GLeglImageOES)image);
433   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
434   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
435   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_REPEAT);
436   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_REPEAT);
437   glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
438 
439   out->image.reset(egl_display, image);
440   out->texture.reset(texture);
441 
442   return 0;
443 }
444 
GLWorkerCompositor()445 GLWorkerCompositor::GLWorkerCompositor()
446     : egl_display_(EGL_NO_DISPLAY), egl_ctx_(EGL_NO_CONTEXT) {
447 }
448 
Init()449 int GLWorkerCompositor::Init() {
450   int ret = 0;
451   const char *egl_extensions;
452   const char *gl_extensions;
453   EGLint num_configs;
454   EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE, EGL_NONE};
455   EGLConfig egl_config;
456 
457   // clang-format off
458   const GLfloat verts[] = {
459     0.0f,  0.0f,    0.0f, 0.0f,
460     0.0f,  2.0f,    0.0f, 2.0f,
461     2.0f,  0.0f,    2.0f, 0.0f
462   };
463   // clang-format on
464 
465   const EGLint config_attribs[] = {EGL_RENDERABLE_TYPE,
466                                    EGL_OPENGL_ES2_BIT,
467                                    EGL_RED_SIZE,
468                                    8,
469                                    EGL_GREEN_SIZE,
470                                    8,
471                                    EGL_BLUE_SIZE,
472                                    8,
473                                    EGL_NONE};
474 
475   const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
476 
477   egl_display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
478   if (egl_display_ == EGL_NO_DISPLAY) {
479     ALOGE("Failed to get egl display");
480     return 1;
481   }
482 
483   if (!eglInitialize(egl_display_, NULL, NULL)) {
484     ALOGE("Failed to initialize egl: %s", GetEGLError());
485     return 1;
486   }
487 
488   egl_extensions = eglQueryString(egl_display_, EGL_EXTENSIONS);
489 
490   // These extensions are all technically required but not always reported due
491   // to meta EGL filtering them out.
492   if (!HasExtension("EGL_KHR_image_base", egl_extensions))
493     ALOGW("EGL_KHR_image_base extension not supported");
494 
495   if (!HasExtension("EGL_ANDROID_image_native_buffer", egl_extensions))
496     ALOGW("EGL_ANDROID_image_native_buffer extension not supported");
497 
498   if (!HasExtension("EGL_ANDROID_native_fence_sync", egl_extensions))
499     ALOGW("EGL_ANDROID_native_fence_sync extension not supported");
500 
501   if (!eglChooseConfig(egl_display_, config_attribs, &egl_config, 1,
502                        &num_configs)) {
503     ALOGE("eglChooseConfig() failed with error: %s", GetEGLError());
504     return 1;
505   }
506 
507   egl_ctx_ =
508       eglCreateContext(egl_display_, egl_config,
509                        EGL_NO_CONTEXT /* No shared context */, context_attribs);
510 
511   if (egl_ctx_ == EGL_NO_CONTEXT) {
512     ALOGE("Failed to create OpenGL ES Context: %s", GetEGLError());
513     return 1;
514   }
515 
516   if (!eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_ctx_)) {
517     ALOGE("Failed to make the OpenGL ES Context current: %s", GetEGLError());
518     return 1;
519   }
520 
521   gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
522 
523   if (!HasExtension("GL_OES_EGL_image", gl_extensions))
524     ALOGW("GL_OES_EGL_image extension not supported");
525 
526   if (!HasExtension("GL_OES_EGL_image_external", gl_extensions))
527     ALOGW("GL_OES_EGL_image_external extension not supported");
528 
529   GLuint vertex_buffer;
530   glGenBuffers(1, &vertex_buffer);
531   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
532   glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
533   glBindBuffer(GL_ARRAY_BUFFER, 0);
534   vertex_buffer_.reset(vertex_buffer);
535 
536   std::ostringstream shader_log;
537   blend_programs_.emplace_back(GenerateProgram(1, &shader_log));
538   if (blend_programs_.back().get() == 0) {
539     ALOGE("%s", shader_log.str().c_str());
540     return 1;
541   }
542 
543   return 0;
544 }
545 
~GLWorkerCompositor()546 GLWorkerCompositor::~GLWorkerCompositor() {
547   if (egl_display_ != EGL_NO_DISPLAY && egl_ctx_ != EGL_NO_CONTEXT)
548     if (eglDestroyContext(egl_display_, egl_ctx_) == EGL_FALSE)
549       ALOGE("Failed to destroy OpenGL ES Context: %s", GetEGLError());
550 }
551 
Composite(DrmHwcLayer * layers,DrmCompositionRegion * regions,size_t num_regions,const sp<GraphicBuffer> & framebuffer)552 int GLWorkerCompositor::Composite(DrmHwcLayer *layers,
553                                   DrmCompositionRegion *regions,
554                                   size_t num_regions,
555                                   const sp<GraphicBuffer> &framebuffer) {
556   ATRACE_CALL();
557   int ret = 0;
558   std::vector<AutoEGLImageAndGLTexture> layer_textures;
559   std::vector<RenderingCommand> commands;
560 
561   if (num_regions == 0) {
562     return -EALREADY;
563   }
564 
565   GLint frame_width = framebuffer->getWidth();
566   GLint frame_height = framebuffer->getHeight();
567   CachedFramebuffer *cached_framebuffer =
568       PrepareAndCacheFramebuffer(framebuffer);
569   if (cached_framebuffer == NULL) {
570     ALOGE("Composite failed because of failed framebuffer");
571     return -EINVAL;
572   }
573 
574   std::unordered_set<size_t> layers_used_indices;
575   for (size_t region_index = 0; region_index < num_regions; region_index++) {
576     DrmCompositionRegion &region = regions[region_index];
577     layers_used_indices.insert(region.source_layers.begin(),
578                                region.source_layers.end());
579     commands.emplace_back();
580     ConstructCommand(layers, region, commands.back());
581   }
582 
583   for (size_t layer_index = 0; layer_index < MAX_OVERLAPPING_LAYERS;
584        layer_index++) {
585     DrmHwcLayer *layer = &layers[layer_index];
586 
587     layer_textures.emplace_back();
588 
589     if (layers_used_indices.count(layer_index) == 0)
590       continue;
591 
592     ret = CreateTextureFromHandle(egl_display_, layer->get_usable_handle(),
593                                   &layer_textures.back());
594 
595     if (!ret) {
596       ret = EGLFenceWait(egl_display_, layer->acquire_fence.Release());
597     }
598     if (ret) {
599       layer_textures.pop_back();
600       ret = -EINVAL;
601     }
602   }
603 
604   if (ret)
605     return ret;
606 
607   glViewport(0, 0, frame_width, frame_height);
608 
609   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
610   glClear(GL_COLOR_BUFFER_BIT);
611 
612   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_.get());
613   glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, NULL);
614   glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4,
615                         (void *)(sizeof(float) * 2));
616   glEnableVertexAttribArray(0);
617   glEnableVertexAttribArray(1);
618   glEnable(GL_SCISSOR_TEST);
619 
620   for (const RenderingCommand &cmd : commands) {
621     if (cmd.texture_count == 0)
622       continue;
623 
624     // TODO(zachr): handle the case of too many overlapping textures for one
625     // area by falling back to rendering as many layers as possible using
626     // multiple blending passes.
627     GLint program = PrepareAndCacheProgram(cmd.texture_count);
628     if (program == 0) {
629       ALOGE("Too many layers to render in one area");
630       continue;
631     }
632 
633     glUseProgram(program);
634     GLint gl_viewport_loc = glGetUniformLocation(program, "uViewport");
635     GLint gl_crop_loc = glGetUniformLocation(program, "uLayerCrop");
636     GLint gl_alpha_loc = glGetUniformLocation(program, "uLayerAlpha");
637     GLint gl_premult_loc = glGetUniformLocation(program, "uLayerPremult");
638     GLint gl_tex_matrix_loc = glGetUniformLocation(program, "uTexMatrix");
639     glUniform4f(gl_viewport_loc, cmd.bounds[0] / (float)frame_width,
640                 cmd.bounds[1] / (float)frame_height,
641                 (cmd.bounds[2] - cmd.bounds[0]) / (float)frame_width,
642                 (cmd.bounds[3] - cmd.bounds[1]) / (float)frame_height);
643 
644     for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
645       std::ostringstream texture_name_formatter;
646       texture_name_formatter << "uLayerTexture" << src_index;
647       GLint gl_tex_loc =
648           glGetUniformLocation(program, texture_name_formatter.str().c_str());
649 
650       const RenderingCommand::TextureSource &src = cmd.textures[src_index];
651       glUniform1f(gl_alpha_loc + src_index, src.alpha);
652       glUniform1f(gl_premult_loc + src_index, src.premult);
653       glUniform4f(gl_crop_loc + src_index, src.crop_bounds[0],
654                   src.crop_bounds[1], src.crop_bounds[2] - src.crop_bounds[0],
655                   src.crop_bounds[3] - src.crop_bounds[1]);
656       glUniform1i(gl_tex_loc, src_index);
657       glUniformMatrix2fv(gl_tex_matrix_loc + src_index, 1, GL_FALSE,
658                          src.texture_matrix);
659       glActiveTexture(GL_TEXTURE0 + src_index);
660       glBindTexture(GL_TEXTURE_EXTERNAL_OES,
661                     layer_textures[src.texture_index].texture.get());
662     }
663 
664     glScissor(cmd.bounds[0], cmd.bounds[1], cmd.bounds[2] - cmd.bounds[0],
665               cmd.bounds[3] - cmd.bounds[1]);
666     glDrawArrays(GL_TRIANGLES, 0, 3);
667 
668     for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
669       glActiveTexture(GL_TEXTURE0 + src_index);
670       glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
671     }
672   }
673 
674   glDisable(GL_SCISSOR_TEST);
675   glActiveTexture(GL_TEXTURE0);
676   glDisableVertexAttribArray(0);
677   glDisableVertexAttribArray(1);
678   glBindBuffer(GL_ARRAY_BUFFER, 0);
679   glUseProgram(0);
680 
681   glBindFramebuffer(GL_FRAMEBUFFER, 0);
682 
683   return ret;
684 }
685 
Finish()686 void GLWorkerCompositor::Finish() {
687   ATRACE_CALL();
688   glFinish();
689 
690   char use_framebuffer_cache_opt[PROPERTY_VALUE_MAX];
691   property_get("hwc.drm.use_framebuffer_cache", use_framebuffer_cache_opt, "1");
692   bool use_framebuffer_cache = atoi(use_framebuffer_cache_opt);
693 
694   if (use_framebuffer_cache) {
695     for (auto &fb : cached_framebuffers_)
696       fb.strong_framebuffer.clear();
697   } else {
698     cached_framebuffers_.clear();
699   }
700 }
701 
CachedFramebuffer(const sp<GraphicBuffer> & gb,AutoEGLDisplayImage && image,AutoGLTexture && tex,AutoGLFramebuffer && fb)702 GLWorkerCompositor::CachedFramebuffer::CachedFramebuffer(
703     const sp<GraphicBuffer> &gb, AutoEGLDisplayImage &&image,
704     AutoGLTexture &&tex, AutoGLFramebuffer &&fb)
705     : strong_framebuffer(gb),
706       weak_framebuffer(gb),
707       egl_fb_image(std::move(image)),
708       gl_fb_tex(std::move(tex)),
709       gl_fb(std::move(fb)) {
710 }
711 
Promote()712 bool GLWorkerCompositor::CachedFramebuffer::Promote() {
713   if (strong_framebuffer.get() != NULL)
714     return true;
715   strong_framebuffer = weak_framebuffer.promote();
716   return strong_framebuffer.get() != NULL;
717 }
718 
719 GLWorkerCompositor::CachedFramebuffer *
FindCachedFramebuffer(const sp<GraphicBuffer> & framebuffer)720 GLWorkerCompositor::FindCachedFramebuffer(
721     const sp<GraphicBuffer> &framebuffer) {
722   for (auto &fb : cached_framebuffers_)
723     if (fb.weak_framebuffer == framebuffer)
724       return &fb;
725   return NULL;
726 }
727 
728 GLWorkerCompositor::CachedFramebuffer *
PrepareAndCacheFramebuffer(const sp<GraphicBuffer> & framebuffer)729 GLWorkerCompositor::PrepareAndCacheFramebuffer(
730     const sp<GraphicBuffer> &framebuffer) {
731   CachedFramebuffer *cached_framebuffer = FindCachedFramebuffer(framebuffer);
732   if (cached_framebuffer != NULL) {
733     if (cached_framebuffer->Promote()) {
734       glBindFramebuffer(GL_FRAMEBUFFER, cached_framebuffer->gl_fb.get());
735       return cached_framebuffer;
736     }
737 
738     for (auto it = cached_framebuffers_.begin();
739          it != cached_framebuffers_.end(); ++it) {
740       if (it->weak_framebuffer == framebuffer) {
741         cached_framebuffers_.erase(it);
742         break;
743       }
744     }
745   }
746 
747   AutoEGLDisplayImage egl_fb_image(
748       egl_display_,
749       eglCreateImageKHR(egl_display_, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
750                         (EGLClientBuffer)framebuffer->getNativeBuffer(),
751                         NULL /* no attribs */));
752 
753   if (egl_fb_image.image() == EGL_NO_IMAGE_KHR) {
754     ALOGE("Failed to make image from target buffer: %s", GetEGLError());
755     return NULL;
756   }
757 
758   GLuint gl_fb_tex;
759   glGenTextures(1, &gl_fb_tex);
760   AutoGLTexture gl_fb_tex_auto(gl_fb_tex);
761   glBindTexture(GL_TEXTURE_2D, gl_fb_tex);
762   glEGLImageTargetTexture2DOES(GL_TEXTURE_2D,
763                                (GLeglImageOES)egl_fb_image.image());
764   glBindTexture(GL_TEXTURE_2D, 0);
765 
766   GLuint gl_fb;
767   glGenFramebuffers(1, &gl_fb);
768   AutoGLFramebuffer gl_fb_auto(gl_fb);
769   glBindFramebuffer(GL_FRAMEBUFFER, gl_fb);
770   glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
771                          gl_fb_tex, 0);
772 
773   if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
774     ALOGE("Failed framebuffer check for created target buffer: %s",
775           GetGLFramebufferError());
776     return NULL;
777   }
778 
779   cached_framebuffers_.emplace_back(framebuffer, std::move(egl_fb_image),
780                                     std::move(gl_fb_tex_auto),
781                                     std::move(gl_fb_auto));
782   return &cached_framebuffers_.back();
783 }
784 
PrepareAndCacheProgram(unsigned texture_count)785 GLint GLWorkerCompositor::PrepareAndCacheProgram(unsigned texture_count) {
786   if (blend_programs_.size() >= texture_count) {
787     GLint program = blend_programs_[texture_count - 1].get();
788     if (program != 0)
789       return program;
790   }
791 
792   AutoGLProgram program = GenerateProgram(texture_count, NULL);
793   if (program.get() != 0) {
794     if (blend_programs_.size() < texture_count)
795       blend_programs_.resize(texture_count);
796     blend_programs_[texture_count - 1] = std::move(program);
797     return blend_programs_[texture_count - 1].get();
798   }
799 
800   return 0;
801 }
802 
803 }  // namespace android
804