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