2 * Copyright (C) 2015 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
18 #define LOG_TAG "hwc-gl-worker"
23 #include <unordered_set>
25 #include <sys/resource.h>
27 #include <cutils/properties.h>
29 #include <hardware/hardware.h>
30 #include <hardware/hwcomposer.h>
32 #include <ui/GraphicBuffer.h>
33 #include <ui/PixelFormat.h>
35 #include <utils/Trace.h>
37 #include "drmdisplaycomposition.h"
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
46 #define MAX_OVERLAPPING_LAYERS 64
51 // Column-major order:
52 // float mat[4] = { 1, 2, 3, 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
61 static const char *GetGLError(void) {
62 switch (glGetError()) {
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";
76 return "Unknown error";
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";
93 return "Unknown error";
97 static const char *GetEGLError(void) {
98 switch (eglGetError()) {
100 return "EGL_SUCCESS";
101 case EGL_NOT_INITIALIZED:
102 return "EGL_NOT_INITIALIZED";
104 return "EGL_BAD_ACCESS";
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";
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";
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";
130 return "Unknown error";
134 static bool HasExtension(const char *extension, const char *extensions) {
135 const char *start, *where, *terminator;
138 where = (char *)strstr((const char *)start, extension);
141 terminator = where + strlen(extension);
142 if (where == start || *(where - 1) == ' ')
143 if (*terminator == ' ' || *terminator == '\0')
150 static AutoGLShader CompileAndCheckShader(GLenum type, unsigned source_count,
151 const GLchar **sources,
152 std::string *shader_log) {
154 AutoGLShader shader(glCreateShader(type));
155 if (shader.get() == 0) {
156 *shader_log = "glCreateShader failed";
159 glShaderSource(shader.get(), source_count, sources, NULL);
160 glCompileShader(shader.get());
161 glGetShaderiv(shader.get(), GL_COMPILE_STATUS, &status);
165 glGetShaderiv(shader.get(), GL_INFO_LOG_LENGTH, &log_length);
166 shader_log->resize(log_length);
167 glGetShaderInfoLog(shader.get(), log_length, NULL, &(*shader_log)[0]);
175 static std::string GenerateVertexShader(int layer_count) {
176 std::ostringstream vertex_shader_stream;
178 << "#version 300 es\n"
179 << "#define LAYER_COUNT " << layer_count << "\n"
180 << "precision mediump int;\n"
181 << "uniform vec4 uViewport;\n"
182 << "uniform vec4 uLayerCrop[LAYER_COUNT];\n"
183 << "uniform mat2 uTexMatrix[LAYER_COUNT];\n"
184 << "in vec2 vPosition;\n"
185 << "in vec2 vTexCoords;\n"
186 << "out vec2 fTexCoords[LAYER_COUNT];\n"
188 << " for (int i = 0; i < LAYER_COUNT; i++) {\n"
189 << " vec2 tempCoords = vTexCoords * uTexMatrix[i];\n"
190 << " fTexCoords[i] =\n"
191 << " uLayerCrop[i].xy + tempCoords * uLayerCrop[i].zw;\n"
193 << " vec2 scaledPosition = uViewport.xy + vPosition * uViewport.zw;\n"
194 << " gl_Position =\n"
195 << " vec4(scaledPosition * vec2(2.0) - vec2(1.0), 0.0, 1.0);\n"
197 return vertex_shader_stream.str();
200 static std::string GenerateFragmentShader(int layer_count) {
201 std::ostringstream fragment_shader_stream;
202 fragment_shader_stream << "#version 300 es\n"
203 << "#define LAYER_COUNT " << layer_count << "\n"
204 << "#extension GL_OES_EGL_image_external : require\n"
205 << "precision mediump float;\n";
206 for (int i = 0; i < layer_count; ++i) {
207 fragment_shader_stream << "uniform samplerExternalOES uLayerTexture" << i
210 fragment_shader_stream << "uniform float uLayerAlpha[LAYER_COUNT];\n"
211 << "uniform float uLayerPremult[LAYER_COUNT];\n"
212 << "in vec2 fTexCoords[LAYER_COUNT];\n"
213 << "out vec4 oFragColor;\n"
215 << " vec3 color = vec3(0.0, 0.0, 0.0);\n"
216 << " float alphaCover = 1.0;\n"
217 << " vec4 texSample;\n"
218 << " vec3 multRgb;\n";
219 for (int i = 0; i < layer_count; ++i) {
221 fragment_shader_stream << " if (alphaCover > 0.5/255.0) {\n";
223 fragment_shader_stream
224 << " texSample = texture2D(uLayerTexture" << i << ",\n"
225 << " fTexCoords[" << i << "]);\n"
226 << " multRgb = texSample.rgb *\n"
227 << " max(texSample.a, uLayerPremult[" << i << "]);\n"
228 << " color += multRgb * uLayerAlpha[" << i << "] * alphaCover;\n"
229 << " alphaCover *= 1.0 - texSample.a * uLayerAlpha[" << i << "];\n";
232 for (int i = 0; i < layer_count - 1; ++i)
233 fragment_shader_stream << " }\n";
234 fragment_shader_stream << " oFragColor = vec4(color, 1.0 - alphaCover);\n"
236 return fragment_shader_stream.str();
239 static int GenerateShaders(std::vector<AutoGLProgram> *blend_programs) {
240 // Limits: GL_MAX_VARYING_COMPONENTS, GL_MAX_TEXTURE_IMAGE_UNITS,
241 // GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
243 GLint max_texture_images, status;
244 AutoGLShader vertex_shader, fragment_shader;
245 AutoGLProgram program;
246 std::string shader_log;
248 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_images);
250 for (i = 1; i <= max_texture_images; i++) {
251 std::string vertex_shader_string = GenerateVertexShader(i);
252 const GLchar *vertex_shader_source = vertex_shader_string.c_str();
253 vertex_shader = CompileAndCheckShader(
254 GL_VERTEX_SHADER, 1, &vertex_shader_source, ret ? &shader_log : NULL);
255 if (!vertex_shader.get()) {
257 ALOGE("Failed to make vertex shader:\n%sshader source:\n%s",
258 shader_log.c_str(), vertex_shader_source);
262 std::string fragment_shader_string = GenerateFragmentShader(i);
263 const GLchar *fragment_shader_source = fragment_shader_string.c_str();
265 CompileAndCheckShader(GL_FRAGMENT_SHADER, 1, &fragment_shader_source,
266 ret ? &shader_log : NULL);
267 if (!fragment_shader.get()) {
269 ALOGE("Failed to make fragment shader:\n%sshader source:\n%s",
270 shader_log.c_str(), fragment_shader_source);
274 program = AutoGLProgram(glCreateProgram());
275 if (!program.get()) {
277 ALOGE("Failed to create program %s", GetGLError());
281 glAttachShader(program.get(), vertex_shader.get());
282 glAttachShader(program.get(), fragment_shader.get());
283 glBindAttribLocation(program.get(), 0, "vPosition");
284 glBindAttribLocation(program.get(), 1, "vTexCoords");
285 glLinkProgram(program.get());
286 glDetachShader(program.get(), vertex_shader.get());
287 glDetachShader(program.get(), fragment_shader.get());
289 glGetProgramiv(program.get(), GL_LINK_STATUS, &status);
293 glGetProgramiv(program.get(), GL_INFO_LOG_LENGTH, &log_length);
294 std::string program_log(log_length, ' ');
295 glGetProgramInfoLog(program.get(), log_length, NULL, &program_log[0]);
296 ALOGE("Failed to link program: \n%s", program_log.c_str());
302 blend_programs->emplace_back(std::move(program));
308 struct RenderingCommand {
309 struct TextureSource {
310 unsigned texture_index;
311 float crop_bounds[4];
314 float texture_matrix[4];
318 unsigned texture_count = 0;
319 TextureSource textures[MAX_OVERLAPPING_LAYERS];
322 static void ConstructCommand(const DrmHwcLayer *layers,
323 const DrmCompositionRegion ®ion,
324 RenderingCommand &cmd) {
325 std::copy_n(region.frame.bounds, 4, cmd.bounds);
327 for (size_t texture_index : region.source_layers) {
328 const DrmHwcLayer &layer = layers[texture_index];
330 DrmHwcRect<float> display_rect(layer.display_frame);
331 float display_size[2] = {display_rect.bounds[2] - display_rect.bounds[0],
332 display_rect.bounds[3] - display_rect.bounds[1]};
334 float tex_width = layer.buffer->width;
335 float tex_height = layer.buffer->height;
336 DrmHwcRect<float> crop_rect(layer.source_crop.left / tex_width,
337 layer.source_crop.top / tex_height,
338 layer.source_crop.right / tex_width,
339 layer.source_crop.bottom / tex_height);
341 float crop_size[2] = {crop_rect.bounds[2] - crop_rect.bounds[0],
342 crop_rect.bounds[3] - crop_rect.bounds[1]};
344 RenderingCommand::TextureSource &src = cmd.textures[cmd.texture_count];
346 src.texture_index = texture_index;
348 bool swap_xy, flip_xy[2];
349 switch (layer.transform) {
350 case DrmHwcTransform::kFlipH:
355 case DrmHwcTransform::kFlipV:
360 case DrmHwcTransform::kRotate90:
365 case DrmHwcTransform::kRotate180:
370 case DrmHwcTransform::kRotate270:
376 ALOGE("Unknown transform for layer: defaulting to identity transform");
377 case DrmHwcTransform::kIdentity:
385 std::copy_n(&kTextureTransformMatrices[4], 4, src.texture_matrix);
387 std::copy_n(&kTextureTransformMatrices[0], 4, src.texture_matrix);
389 for (int j = 0; j < 4; j++) {
390 int b = j ^ (swap_xy ? 1 : 0);
391 float bound_percent =
392 (cmd.bounds[b] - display_rect.bounds[b % 2]) / display_size[b % 2];
393 if (flip_xy[j % 2]) {
395 crop_rect.bounds[j % 2 + 2] - bound_percent * crop_size[j % 2];
398 crop_rect.bounds[j % 2] + bound_percent * crop_size[j % 2];
402 if (layer.blending == DrmHwcBlending::kNone) {
403 src.alpha = src.premult = 1.0f;
404 // This layer is opaque. There is no point in using layers below this one.
408 src.alpha = layer.alpha / 255.0f;
412 static int EGLFenceWait(EGLDisplay egl_display, int acquireFenceFd) {
415 EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, acquireFenceFd,
417 EGLSyncKHR egl_sync =
418 eglCreateSyncKHR(egl_display, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
419 if (egl_sync == EGL_NO_SYNC_KHR) {
420 ALOGE("Failed to make EGLSyncKHR from acquireFenceFd: %s", GetEGLError());
421 close(acquireFenceFd);
425 EGLint success = eglWaitSyncKHR(egl_display, egl_sync, 0);
426 if (success == EGL_FALSE) {
427 ALOGE("Failed to wait for acquire: %s", GetEGLError());
430 eglDestroySyncKHR(egl_display, egl_sync);
435 static int CreateTextureFromHandle(EGLDisplay egl_display,
436 buffer_handle_t handle,
437 AutoEGLImageAndGLTexture *out) {
438 EGLImageKHR image = eglCreateImageKHR(
439 egl_display, EGL_NO_CONTEXT, EGL_NATIVE_HANDLE_ANDROID_NVX,
440 (EGLClientBuffer)handle, NULL /* no attribs */);
442 if (image == EGL_NO_IMAGE_KHR) {
443 ALOGE("Failed to make image %s %p", GetEGLError(), handle);
448 glGenTextures(1, &texture);
449 glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
450 glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, (GLeglImageOES)image);
451 glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
452 glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
453 glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_REPEAT);
454 glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_REPEAT);
455 glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
457 out->image.reset(egl_display, image);
458 out->texture.reset(texture);
463 GLWorkerCompositor::GLWorkerCompositor()
464 : egl_display_(EGL_NO_DISPLAY), egl_ctx_(EGL_NO_CONTEXT) {
467 int GLWorkerCompositor::Init() {
469 const char *egl_extensions;
470 const char *gl_extensions;
472 EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE, EGL_NONE};
473 EGLConfig egl_config;
476 const GLfloat verts[] = {
477 0.0f, 0.0f, 0.0f, 0.0f,
478 0.0f, 2.0f, 0.0f, 2.0f,
479 2.0f, 0.0f, 2.0f, 0.0f
483 const EGLint config_attribs[] = {EGL_RENDERABLE_TYPE,
493 const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
495 egl_display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
496 if (egl_display_ == EGL_NO_DISPLAY) {
497 ALOGE("Failed to get egl display");
501 if (!eglInitialize(egl_display_, NULL, NULL)) {
502 ALOGE("Failed to initialize egl: %s", GetEGLError());
506 egl_extensions = eglQueryString(egl_display_, EGL_EXTENSIONS);
508 // These extensions are all technically required but not always reported due
509 // to meta EGL filtering them out.
510 if (!HasExtension("EGL_KHR_image_base", egl_extensions))
511 ALOGW("EGL_KHR_image_base extension not supported");
513 if (!HasExtension("EGL_ANDROID_image_native_buffer", egl_extensions))
514 ALOGW("EGL_ANDROID_image_native_buffer extension not supported");
516 if (!HasExtension("EGL_ANDROID_native_fence_sync", egl_extensions))
517 ALOGW("EGL_ANDROID_native_fence_sync extension not supported");
519 if (!eglChooseConfig(egl_display_, config_attribs, &egl_config, 1,
521 ALOGE("eglChooseConfig() failed with error: %s", GetEGLError());
526 eglCreateContext(egl_display_, egl_config,
527 EGL_NO_CONTEXT /* No shared context */, context_attribs);
529 if (egl_ctx_ == EGL_NO_CONTEXT) {
530 ALOGE("Failed to create OpenGL ES Context: %s", GetEGLError());
534 if (!eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_ctx_)) {
535 ALOGE("Failed to make the OpenGL ES Context current: %s", GetEGLError());
539 gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
541 if (!HasExtension("GL_OES_EGL_image", gl_extensions))
542 ALOGW("GL_OES_EGL_image extension not supported");
544 if (!HasExtension("GL_OES_EGL_image_external", gl_extensions))
545 ALOGW("GL_OES_EGL_image_external extension not supported");
547 GLuint vertex_buffer;
548 glGenBuffers(1, &vertex_buffer);
549 glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
550 glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
551 glBindBuffer(GL_ARRAY_BUFFER, 0);
552 vertex_buffer_.reset(vertex_buffer);
554 if (GenerateShaders(&blend_programs_)) {
561 GLWorkerCompositor::~GLWorkerCompositor() {
562 if (egl_display_ != EGL_NO_DISPLAY && egl_ctx_ != EGL_NO_CONTEXT)
563 if (eglDestroyContext(egl_display_, egl_ctx_) == EGL_FALSE)
564 ALOGE("Failed to destroy OpenGL ES Context: %s", GetEGLError());
567 int GLWorkerCompositor::Composite(DrmHwcLayer *layers,
568 DrmCompositionRegion *regions,
570 const sp<GraphicBuffer> &framebuffer) {
573 std::vector<AutoEGLImageAndGLTexture> layer_textures;
574 std::vector<RenderingCommand> commands;
576 if (num_regions == 0) {
580 GLint frame_width = framebuffer->getWidth();
581 GLint frame_height = framebuffer->getHeight();
582 CachedFramebuffer *cached_framebuffer =
583 PrepareAndCacheFramebuffer(framebuffer);
584 if (cached_framebuffer == NULL) {
585 ALOGE("Composite failed because of failed framebuffer");
589 std::unordered_set<size_t> layers_used_indices;
590 for (size_t region_index = 0; region_index < num_regions; region_index++) {
591 DrmCompositionRegion ®ion = regions[region_index];
592 layers_used_indices.insert(region.source_layers.begin(),
593 region.source_layers.end());
594 commands.emplace_back();
595 ConstructCommand(layers, region, commands.back());
598 for (size_t layer_index = 0; layer_index < MAX_OVERLAPPING_LAYERS;
600 DrmHwcLayer *layer = &layers[layer_index];
602 layer_textures.emplace_back();
604 if (layers_used_indices.count(layer_index) == 0)
607 ret = CreateTextureFromHandle(egl_display_, layer->get_usable_handle(),
608 &layer_textures.back());
611 ret = EGLFenceWait(egl_display_, layer->acquire_fence.Release());
614 layer_textures.pop_back();
622 glViewport(0, 0, frame_width, frame_height);
624 glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
625 glClear(GL_COLOR_BUFFER_BIT);
627 glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_.get());
628 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, NULL);
629 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4,
630 (void *)(sizeof(float) * 2));
631 glEnableVertexAttribArray(0);
632 glEnableVertexAttribArray(1);
633 glEnable(GL_SCISSOR_TEST);
635 for (const RenderingCommand &cmd : commands) {
636 if (cmd.texture_count <= 0) {
640 // TODO(zachr): handle the case of too many overlapping textures for one
641 // area by falling back to rendering as many layers as possible using
642 // multiple blending passes.
643 if (cmd.texture_count > blend_programs_.size()) {
644 ALOGE("Too many layers to render in one area");
648 GLint program = blend_programs_[cmd.texture_count - 1].get();
649 glUseProgram(program);
650 GLint gl_viewport_loc = glGetUniformLocation(program, "uViewport");
651 GLint gl_crop_loc = glGetUniformLocation(program, "uLayerCrop");
652 GLint gl_alpha_loc = glGetUniformLocation(program, "uLayerAlpha");
653 GLint gl_premult_loc = glGetUniformLocation(program, "uLayerPremult");
654 GLint gl_tex_matrix_loc = glGetUniformLocation(program, "uTexMatrix");
655 glUniform4f(gl_viewport_loc, cmd.bounds[0] / (float)frame_width,
656 cmd.bounds[1] / (float)frame_height,
657 (cmd.bounds[2] - cmd.bounds[0]) / (float)frame_width,
658 (cmd.bounds[3] - cmd.bounds[1]) / (float)frame_height);
660 for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
661 std::ostringstream texture_name_formatter;
662 texture_name_formatter << "uLayerTexture" << src_index;
664 glGetUniformLocation(program, texture_name_formatter.str().c_str());
666 const RenderingCommand::TextureSource &src = cmd.textures[src_index];
667 glUniform1f(gl_alpha_loc + src_index, src.alpha);
668 glUniform1f(gl_premult_loc + src_index, src.premult);
669 glUniform4f(gl_crop_loc + src_index, src.crop_bounds[0],
670 src.crop_bounds[1], src.crop_bounds[2] - src.crop_bounds[0],
671 src.crop_bounds[3] - src.crop_bounds[1]);
672 glUniform1i(gl_tex_loc, src_index);
673 glUniformMatrix2fv(gl_tex_matrix_loc + src_index, 1, GL_FALSE,
675 glActiveTexture(GL_TEXTURE0 + src_index);
676 glBindTexture(GL_TEXTURE_EXTERNAL_OES,
677 layer_textures[src.texture_index].texture.get());
680 glScissor(cmd.bounds[0], cmd.bounds[1], cmd.bounds[2] - cmd.bounds[0],
681 cmd.bounds[3] - cmd.bounds[1]);
682 glDrawArrays(GL_TRIANGLES, 0, 3);
684 for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
685 glActiveTexture(GL_TEXTURE0 + src_index);
686 glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
690 glDisable(GL_SCISSOR_TEST);
691 glActiveTexture(GL_TEXTURE0);
692 glDisableVertexAttribArray(0);
693 glDisableVertexAttribArray(1);
694 glBindBuffer(GL_ARRAY_BUFFER, 0);
697 glBindFramebuffer(GL_FRAMEBUFFER, 0);
702 void GLWorkerCompositor::Finish() {
706 char use_framebuffer_cache_opt[PROPERTY_VALUE_MAX];
707 property_get("hwc.drm.use_framebuffer_cache", use_framebuffer_cache_opt, "1");
708 bool use_framebuffer_cache = atoi(use_framebuffer_cache_opt);
710 if (use_framebuffer_cache) {
711 for (auto &fb : cached_framebuffers_)
712 fb.strong_framebuffer.clear();
714 cached_framebuffers_.clear();
718 GLWorkerCompositor::CachedFramebuffer::CachedFramebuffer(
719 const sp<GraphicBuffer> &gb, AutoEGLDisplayImage &&image,
720 AutoGLTexture &&tex, AutoGLFramebuffer &&fb)
721 : strong_framebuffer(gb),
722 weak_framebuffer(gb),
723 egl_fb_image(std::move(image)),
724 gl_fb_tex(std::move(tex)),
725 gl_fb(std::move(fb)) {
728 bool GLWorkerCompositor::CachedFramebuffer::Promote() {
729 if (strong_framebuffer.get() != NULL)
731 strong_framebuffer = weak_framebuffer.promote();
732 return strong_framebuffer.get() != NULL;
735 GLWorkerCompositor::CachedFramebuffer *
736 GLWorkerCompositor::FindCachedFramebuffer(
737 const sp<GraphicBuffer> &framebuffer) {
738 for (auto &fb : cached_framebuffers_)
739 if (fb.weak_framebuffer == framebuffer)
744 GLWorkerCompositor::CachedFramebuffer *
745 GLWorkerCompositor::PrepareAndCacheFramebuffer(
746 const sp<GraphicBuffer> &framebuffer) {
747 CachedFramebuffer *cached_framebuffer = FindCachedFramebuffer(framebuffer);
748 if (cached_framebuffer != NULL) {
749 if (cached_framebuffer->Promote()) {
750 glBindFramebuffer(GL_FRAMEBUFFER, cached_framebuffer->gl_fb.get());
751 return cached_framebuffer;
754 for (auto it = cached_framebuffers_.begin();
755 it != cached_framebuffers_.end(); ++it) {
756 if (it->weak_framebuffer == framebuffer) {
757 cached_framebuffers_.erase(it);
763 AutoEGLDisplayImage egl_fb_image(
765 eglCreateImageKHR(egl_display_, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
766 (EGLClientBuffer)framebuffer->getNativeBuffer(),
767 NULL /* no attribs */));
769 if (egl_fb_image.image() == EGL_NO_IMAGE_KHR) {
770 ALOGE("Failed to make image from target buffer: %s", GetEGLError());
775 glGenTextures(1, &gl_fb_tex);
776 AutoGLTexture gl_fb_tex_auto(gl_fb_tex);
777 glBindTexture(GL_TEXTURE_2D, gl_fb_tex);
778 glEGLImageTargetTexture2DOES(GL_TEXTURE_2D,
779 (GLeglImageOES)egl_fb_image.image());
780 glBindTexture(GL_TEXTURE_2D, 0);
783 glGenFramebuffers(1, &gl_fb);
784 AutoGLFramebuffer gl_fb_auto(gl_fb);
785 glBindFramebuffer(GL_FRAMEBUFFER, gl_fb);
786 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
789 if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
790 ALOGE("Failed framebuffer check for created target buffer: %s",
791 GetGLFramebufferError());
795 cached_framebuffers_.emplace_back(framebuffer, std::move(egl_fb_image),
796 std::move(gl_fb_tex_auto),
797 std::move(gl_fb_auto));
798 return &cached_framebuffers_.back();
801 } // namespace android