1 /* 2 * Copyright 2013 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 19 #include "ProgramCache.h" 20 21 #include <GLES2/gl2.h> 22 #include <GLES2/gl2ext.h> 23 #include <log/log.h> 24 #include <renderengine/private/Description.h> 25 #include <utils/String8.h> 26 #include <utils/Trace.h> 27 #include "Program.h" 28 29 ANDROID_SINGLETON_STATIC_INSTANCE(android::renderengine::gl::ProgramCache) 30 31 namespace android { 32 namespace renderengine { 33 namespace gl { 34 35 /* 36 * A simple formatter class to automatically add the endl and 37 * manage the indentation. 38 */ 39 40 class Formatter; 41 static Formatter& indent(Formatter& f); 42 static Formatter& dedent(Formatter& f); 43 44 class Formatter { 45 String8 mString; 46 int mIndent; 47 typedef Formatter& (*FormaterManipFunc)(Formatter&); 48 friend Formatter& indent(Formatter& f); 49 friend Formatter& dedent(Formatter& f); 50 51 public: 52 Formatter() : mIndent(0) {} 53 54 String8 getString() const { return mString; } 55 56 friend Formatter& operator<<(Formatter& out, const char* in) { 57 for (int i = 0; i < out.mIndent; i++) { 58 out.mString.append(" "); 59 } 60 out.mString.append(in); 61 out.mString.append("\n"); 62 return out; 63 } 64 friend inline Formatter& operator<<(Formatter& out, const String8& in) { 65 return operator<<(out, in.string()); 66 } 67 friend inline Formatter& operator<<(Formatter& to, FormaterManipFunc func) { 68 return (*func)(to); 69 } 70 }; 71 Formatter& indent(Formatter& f) { 72 f.mIndent++; 73 return f; 74 } 75 Formatter& dedent(Formatter& f) { 76 f.mIndent--; 77 return f; 78 } 79 80 void ProgramCache::primeCache(EGLContext context, bool useColorManagement) { 81 auto& cache = mCaches[context]; 82 uint32_t shaderCount = 0; 83 uint32_t keyMask = Key::BLEND_MASK | Key::OPACITY_MASK | Key::ALPHA_MASK | Key::TEXTURE_MASK 84 | Key::ROUNDED_CORNERS_MASK; 85 // Prime the cache for all combinations of the above masks, 86 // leaving off the experimental color matrix mask options. 87 88 nsecs_t timeBefore = systemTime(); 89 for (uint32_t keyVal = 0; keyVal <= keyMask; keyVal++) { 90 Key shaderKey; 91 shaderKey.set(keyMask, keyVal); 92 uint32_t tex = shaderKey.getTextureTarget(); 93 if (tex != Key::TEXTURE_OFF && tex != Key::TEXTURE_EXT && tex != Key::TEXTURE_2D) { 94 continue; 95 } 96 if (cache.count(shaderKey) == 0) { 97 cache.emplace(shaderKey, generateProgram(shaderKey)); 98 shaderCount++; 99 } 100 } 101 102 // Prime for sRGB->P3 conversion 103 if (useColorManagement) { 104 Key shaderKey; 105 shaderKey.set(Key::BLEND_MASK | Key::OUTPUT_TRANSFORM_MATRIX_MASK | Key::INPUT_TF_MASK | 106 Key::OUTPUT_TF_MASK, 107 Key::BLEND_PREMULT | Key::OUTPUT_TRANSFORM_MATRIX_ON | Key::INPUT_TF_SRGB | 108 Key::OUTPUT_TF_SRGB); 109 for (int i = 0; i < 16; i++) { 110 shaderKey.set(Key::OPACITY_MASK, 111 (i & 1) ? Key::OPACITY_OPAQUE : Key::OPACITY_TRANSLUCENT); 112 shaderKey.set(Key::ALPHA_MASK, (i & 2) ? Key::ALPHA_LT_ONE : Key::ALPHA_EQ_ONE); 113 114 // Cache rounded corners 115 shaderKey.set(Key::ROUNDED_CORNERS_MASK, 116 (i & 4) ? Key::ROUNDED_CORNERS_ON : Key::ROUNDED_CORNERS_OFF); 117 118 // Cache texture off option for window transition 119 shaderKey.set(Key::TEXTURE_MASK, (i & 8) ? Key::TEXTURE_EXT : Key::TEXTURE_OFF); 120 if (cache.count(shaderKey) == 0) { 121 cache.emplace(shaderKey, generateProgram(shaderKey)); 122 shaderCount++; 123 } 124 } 125 } 126 127 nsecs_t timeAfter = systemTime(); 128 float compileTimeMs = static_cast<float>(timeAfter - timeBefore) / 1.0E6; 129 ALOGD("shader cache generated - %u shaders in %f ms\n", shaderCount, compileTimeMs); 130 } 131 132 ProgramCache::Key ProgramCache::computeKey(const Description& description) { 133 Key needs; 134 needs.set(Key::TEXTURE_MASK, 135 !description.textureEnabled 136 ? Key::TEXTURE_OFF 137 : description.texture.getTextureTarget() == GL_TEXTURE_EXTERNAL_OES 138 ? Key::TEXTURE_EXT 139 : description.texture.getTextureTarget() == GL_TEXTURE_2D 140 ? Key::TEXTURE_2D 141 : Key::TEXTURE_OFF) 142 .set(Key::ALPHA_MASK, (description.color.a < 1) ? Key::ALPHA_LT_ONE : Key::ALPHA_EQ_ONE) 143 .set(Key::BLEND_MASK, 144 description.isPremultipliedAlpha ? Key::BLEND_PREMULT : Key::BLEND_NORMAL) 145 .set(Key::OPACITY_MASK, 146 description.isOpaque ? Key::OPACITY_OPAQUE : Key::OPACITY_TRANSLUCENT) 147 .set(Key::Key::INPUT_TRANSFORM_MATRIX_MASK, 148 description.hasInputTransformMatrix() 149 ? Key::INPUT_TRANSFORM_MATRIX_ON : Key::INPUT_TRANSFORM_MATRIX_OFF) 150 .set(Key::Key::OUTPUT_TRANSFORM_MATRIX_MASK, 151 description.hasOutputTransformMatrix() || description.hasColorMatrix() 152 ? Key::OUTPUT_TRANSFORM_MATRIX_ON 153 : Key::OUTPUT_TRANSFORM_MATRIX_OFF) 154 .set(Key::ROUNDED_CORNERS_MASK, 155 description.cornerRadius > 0 156 ? Key::ROUNDED_CORNERS_ON : Key::ROUNDED_CORNERS_OFF); 157 158 needs.set(Key::Y410_BT2020_MASK, 159 description.isY410BT2020 ? Key::Y410_BT2020_ON : Key::Y410_BT2020_OFF); 160 161 if (needs.hasTransformMatrix() || 162 (description.inputTransferFunction != description.outputTransferFunction)) { 163 switch (description.inputTransferFunction) { 164 case Description::TransferFunction::LINEAR: 165 default: 166 needs.set(Key::INPUT_TF_MASK, Key::INPUT_TF_LINEAR); 167 break; 168 case Description::TransferFunction::SRGB: 169 needs.set(Key::INPUT_TF_MASK, Key::INPUT_TF_SRGB); 170 break; 171 case Description::TransferFunction::ST2084: 172 needs.set(Key::INPUT_TF_MASK, Key::INPUT_TF_ST2084); 173 break; 174 case Description::TransferFunction::HLG: 175 needs.set(Key::INPUT_TF_MASK, Key::INPUT_TF_HLG); 176 break; 177 } 178 179 switch (description.outputTransferFunction) { 180 case Description::TransferFunction::LINEAR: 181 default: 182 needs.set(Key::OUTPUT_TF_MASK, Key::OUTPUT_TF_LINEAR); 183 break; 184 case Description::TransferFunction::SRGB: 185 needs.set(Key::OUTPUT_TF_MASK, Key::OUTPUT_TF_SRGB); 186 break; 187 case Description::TransferFunction::ST2084: 188 needs.set(Key::OUTPUT_TF_MASK, Key::OUTPUT_TF_ST2084); 189 break; 190 case Description::TransferFunction::HLG: 191 needs.set(Key::OUTPUT_TF_MASK, Key::OUTPUT_TF_HLG); 192 break; 193 } 194 } 195 196 return needs; 197 } 198 199 // Generate EOTF that converts signal values to relative display light, 200 // both normalized to [0, 1]. 201 void ProgramCache::generateEOTF(Formatter& fs, const Key& needs) { 202 switch (needs.getInputTF()) { 203 case Key::INPUT_TF_SRGB: 204 fs << R"__SHADER__( 205 float EOTF_sRGB(float srgb) { 206 return srgb <= 0.04045 ? srgb / 12.92 : pow((srgb + 0.055) / 1.055, 2.4); 207 } 208 209 vec3 EOTF_sRGB(const vec3 srgb) { 210 return vec3(EOTF_sRGB(srgb.r), EOTF_sRGB(srgb.g), EOTF_sRGB(srgb.b)); 211 } 212 213 vec3 EOTF(const vec3 srgb) { 214 return sign(srgb.rgb) * EOTF_sRGB(abs(srgb.rgb)); 215 } 216 )__SHADER__"; 217 break; 218 case Key::INPUT_TF_ST2084: 219 fs << R"__SHADER__( 220 vec3 EOTF(const highp vec3 color) { 221 const highp float m1 = (2610.0 / 4096.0) / 4.0; 222 const highp float m2 = (2523.0 / 4096.0) * 128.0; 223 const highp float c1 = (3424.0 / 4096.0); 224 const highp float c2 = (2413.0 / 4096.0) * 32.0; 225 const highp float c3 = (2392.0 / 4096.0) * 32.0; 226 227 highp vec3 tmp = pow(clamp(color, 0.0, 1.0), 1.0 / vec3(m2)); 228 tmp = max(tmp - c1, 0.0) / (c2 - c3 * tmp); 229 return pow(tmp, 1.0 / vec3(m1)); 230 } 231 )__SHADER__"; 232 break; 233 case Key::INPUT_TF_HLG: 234 fs << R"__SHADER__( 235 highp float EOTF_channel(const highp float channel) { 236 const highp float a = 0.17883277; 237 const highp float b = 0.28466892; 238 const highp float c = 0.55991073; 239 return channel <= 0.5 ? channel * channel / 3.0 : 240 (exp((channel - c) / a) + b) / 12.0; 241 } 242 243 vec3 EOTF(const highp vec3 color) { 244 return vec3(EOTF_channel(color.r), EOTF_channel(color.g), 245 EOTF_channel(color.b)); 246 } 247 )__SHADER__"; 248 break; 249 default: 250 fs << R"__SHADER__( 251 vec3 EOTF(const vec3 linear) { 252 return linear; 253 } 254 )__SHADER__"; 255 break; 256 } 257 } 258 259 void ProgramCache::generateToneMappingProcess(Formatter& fs, const Key& needs) { 260 // Convert relative light to absolute light. 261 switch (needs.getInputTF()) { 262 case Key::INPUT_TF_ST2084: 263 fs << R"__SHADER__( 264 highp vec3 ScaleLuminance(highp vec3 color) { 265 return color * 10000.0; 266 } 267 )__SHADER__"; 268 break; 269 case Key::INPUT_TF_HLG: 270 fs << R"__SHADER__( 271 highp vec3 ScaleLuminance(highp vec3 color) { 272 // The formula is: 273 // alpha * pow(Y, gamma - 1.0) * color + beta; 274 // where alpha is 1000.0, gamma is 1.2, beta is 0.0. 275 return color * 1000.0 * pow(color.y, 0.2); 276 } 277 )__SHADER__"; 278 break; 279 default: 280 fs << R"__SHADER__( 281 highp vec3 ScaleLuminance(highp vec3 color) { 282 return color * displayMaxLuminance; 283 } 284 )__SHADER__"; 285 break; 286 } 287 288 // Tone map absolute light to display luminance range. 289 switch (needs.getInputTF()) { 290 case Key::INPUT_TF_ST2084: 291 case Key::INPUT_TF_HLG: 292 switch (needs.getOutputTF()) { 293 case Key::OUTPUT_TF_HLG: 294 // Right now when mixed PQ and HLG contents are presented, 295 // HLG content will always be converted to PQ. However, for 296 // completeness, we simply clamp the value to [0.0, 1000.0]. 297 fs << R"__SHADER__( 298 highp vec3 ToneMap(highp vec3 color) { 299 return clamp(color, 0.0, 1000.0); 300 } 301 )__SHADER__"; 302 break; 303 case Key::OUTPUT_TF_ST2084: 304 fs << R"__SHADER__( 305 highp vec3 ToneMap(highp vec3 color) { 306 return color; 307 } 308 )__SHADER__"; 309 break; 310 default: 311 fs << R"__SHADER__( 312 highp vec3 ToneMap(highp vec3 color) { 313 const float maxMasteringLumi = 1000.0; 314 const float maxContentLumi = 1000.0; 315 const float maxInLumi = min(maxMasteringLumi, maxContentLumi); 316 float maxOutLumi = displayMaxLuminance; 317 318 float nits = color.y; 319 320 // clamp to max input luminance 321 nits = clamp(nits, 0.0, maxInLumi); 322 323 // scale [0.0, maxInLumi] to [0.0, maxOutLumi] 324 if (maxInLumi <= maxOutLumi) { 325 return color * (maxOutLumi / maxInLumi); 326 } else { 327 // three control points 328 const float x0 = 10.0; 329 const float y0 = 17.0; 330 float x1 = maxOutLumi * 0.75; 331 float y1 = x1; 332 float x2 = x1 + (maxInLumi - x1) / 2.0; 333 float y2 = y1 + (maxOutLumi - y1) * 0.75; 334 335 // horizontal distances between the last three control points 336 float h12 = x2 - x1; 337 float h23 = maxInLumi - x2; 338 // tangents at the last three control points 339 float m1 = (y2 - y1) / h12; 340 float m3 = (maxOutLumi - y2) / h23; 341 float m2 = (m1 + m3) / 2.0; 342 343 if (nits < x0) { 344 // scale [0.0, x0] to [0.0, y0] linearly 345 float slope = y0 / x0; 346 return color * slope; 347 } else if (nits < x1) { 348 // scale [x0, x1] to [y0, y1] linearly 349 float slope = (y1 - y0) / (x1 - x0); 350 nits = y0 + (nits - x0) * slope; 351 } else if (nits < x2) { 352 // scale [x1, x2] to [y1, y2] using Hermite interp 353 float t = (nits - x1) / h12; 354 nits = (y1 * (1.0 + 2.0 * t) + h12 * m1 * t) * (1.0 - t) * (1.0 - t) + 355 (y2 * (3.0 - 2.0 * t) + h12 * m2 * (t - 1.0)) * t * t; 356 } else { 357 // scale [x2, maxInLumi] to [y2, maxOutLumi] using Hermite interp 358 float t = (nits - x2) / h23; 359 nits = (y2 * (1.0 + 2.0 * t) + h23 * m2 * t) * (1.0 - t) * (1.0 - t) + 360 (maxOutLumi * (3.0 - 2.0 * t) + h23 * m3 * (t - 1.0)) * t * t; 361 } 362 } 363 364 // color.y is greater than x0 and is thus non-zero 365 return color * (nits / color.y); 366 } 367 )__SHADER__"; 368 break; 369 } 370 break; 371 default: 372 // inverse tone map; the output luminance can be up to maxOutLumi. 373 fs << R"__SHADER__( 374 highp vec3 ToneMap(highp vec3 color) { 375 const float maxOutLumi = 3000.0; 376 377 const float x0 = 5.0; 378 const float y0 = 2.5; 379 float x1 = displayMaxLuminance * 0.7; 380 float y1 = maxOutLumi * 0.15; 381 float x2 = displayMaxLuminance * 0.9; 382 float y2 = maxOutLumi * 0.45; 383 float x3 = displayMaxLuminance; 384 float y3 = maxOutLumi; 385 386 float c1 = y1 / 3.0; 387 float c2 = y2 / 2.0; 388 float c3 = y3 / 1.5; 389 390 float nits = color.y; 391 392 float scale; 393 if (nits <= x0) { 394 // scale [0.0, x0] to [0.0, y0] linearly 395 const float slope = y0 / x0; 396 return color * slope; 397 } else if (nits <= x1) { 398 // scale [x0, x1] to [y0, y1] using a curve 399 float t = (nits - x0) / (x1 - x0); 400 nits = (1.0 - t) * (1.0 - t) * y0 + 2.0 * (1.0 - t) * t * c1 + t * t * y1; 401 } else if (nits <= x2) { 402 // scale [x1, x2] to [y1, y2] using a curve 403 float t = (nits - x1) / (x2 - x1); 404 nits = (1.0 - t) * (1.0 - t) * y1 + 2.0 * (1.0 - t) * t * c2 + t * t * y2; 405 } else { 406 // scale [x2, x3] to [y2, y3] using a curve 407 float t = (nits - x2) / (x3 - x2); 408 nits = (1.0 - t) * (1.0 - t) * y2 + 2.0 * (1.0 - t) * t * c3 + t * t * y3; 409 } 410 411 // color.y is greater than x0 and is thus non-zero 412 return color * (nits / color.y); 413 } 414 )__SHADER__"; 415 break; 416 } 417 418 // convert absolute light to relative light. 419 switch (needs.getOutputTF()) { 420 case Key::OUTPUT_TF_ST2084: 421 fs << R"__SHADER__( 422 highp vec3 NormalizeLuminance(highp vec3 color) { 423 return color / 10000.0; 424 } 425 )__SHADER__"; 426 break; 427 case Key::OUTPUT_TF_HLG: 428 fs << R"__SHADER__( 429 highp vec3 NormalizeLuminance(highp vec3 color) { 430 return color / 1000.0 * pow(color.y / 1000.0, -0.2 / 1.2); 431 } 432 )__SHADER__"; 433 break; 434 default: 435 fs << R"__SHADER__( 436 highp vec3 NormalizeLuminance(highp vec3 color) { 437 return color / displayMaxLuminance; 438 } 439 )__SHADER__"; 440 break; 441 } 442 } 443 444 // Generate OOTF that modifies the relative scence light to relative display light. 445 void ProgramCache::generateOOTF(Formatter& fs, const ProgramCache::Key& needs) { 446 if (!needs.needsToneMapping()) { 447 fs << R"__SHADER__( 448 highp vec3 OOTF(const highp vec3 color) { 449 return color; 450 } 451 )__SHADER__"; 452 } else { 453 generateToneMappingProcess(fs, needs); 454 fs << R"__SHADER__( 455 highp vec3 OOTF(const highp vec3 color) { 456 return NormalizeLuminance(ToneMap(ScaleLuminance(color))); 457 } 458 )__SHADER__"; 459 } 460 } 461 462 // Generate OETF that converts relative display light to signal values, 463 // both normalized to [0, 1] 464 void ProgramCache::generateOETF(Formatter& fs, const Key& needs) { 465 switch (needs.getOutputTF()) { 466 case Key::OUTPUT_TF_SRGB: 467 fs << R"__SHADER__( 468 float OETF_sRGB(const float linear) { 469 return linear <= 0.0031308 ? 470 linear * 12.92 : (pow(linear, 1.0 / 2.4) * 1.055) - 0.055; 471 } 472 473 vec3 OETF_sRGB(const vec3 linear) { 474 return vec3(OETF_sRGB(linear.r), OETF_sRGB(linear.g), OETF_sRGB(linear.b)); 475 } 476 477 vec3 OETF(const vec3 linear) { 478 return sign(linear.rgb) * OETF_sRGB(abs(linear.rgb)); 479 } 480 )__SHADER__"; 481 break; 482 case Key::OUTPUT_TF_ST2084: 483 fs << R"__SHADER__( 484 vec3 OETF(const vec3 linear) { 485 const highp float m1 = (2610.0 / 4096.0) / 4.0; 486 const highp float m2 = (2523.0 / 4096.0) * 128.0; 487 const highp float c1 = (3424.0 / 4096.0); 488 const highp float c2 = (2413.0 / 4096.0) * 32.0; 489 const highp float c3 = (2392.0 / 4096.0) * 32.0; 490 491 highp vec3 tmp = pow(linear, vec3(m1)); 492 tmp = (c1 + c2 * tmp) / (1.0 + c3 * tmp); 493 return pow(tmp, vec3(m2)); 494 } 495 )__SHADER__"; 496 break; 497 case Key::OUTPUT_TF_HLG: 498 fs << R"__SHADER__( 499 highp float OETF_channel(const highp float channel) { 500 const highp float a = 0.17883277; 501 const highp float b = 0.28466892; 502 const highp float c = 0.55991073; 503 return channel <= 1.0 / 12.0 ? sqrt(3.0 * channel) : 504 a * log(12.0 * channel - b) + c; 505 } 506 507 vec3 OETF(const highp vec3 color) { 508 return vec3(OETF_channel(color.r), OETF_channel(color.g), 509 OETF_channel(color.b)); 510 } 511 )__SHADER__"; 512 break; 513 default: 514 fs << R"__SHADER__( 515 vec3 OETF(const vec3 linear) { 516 return linear; 517 } 518 )__SHADER__"; 519 break; 520 } 521 } 522 523 String8 ProgramCache::generateVertexShader(const Key& needs) { 524 Formatter vs; 525 if (needs.isTexturing()) { 526 vs << "attribute vec4 texCoords;" 527 << "varying vec2 outTexCoords;"; 528 } 529 if (needs.hasRoundedCorners()) { 530 vs << "attribute lowp vec4 cropCoords;"; 531 vs << "varying lowp vec2 outCropCoords;"; 532 } 533 vs << "attribute vec4 position;" 534 << "uniform mat4 projection;" 535 << "uniform mat4 texture;" 536 << "void main(void) {" << indent << "gl_Position = projection * position;"; 537 if (needs.isTexturing()) { 538 vs << "outTexCoords = (texture * texCoords).st;"; 539 } 540 if (needs.hasRoundedCorners()) { 541 vs << "outCropCoords = cropCoords.st;"; 542 } 543 vs << dedent << "}"; 544 return vs.getString(); 545 } 546 547 String8 ProgramCache::generateFragmentShader(const Key& needs) { 548 Formatter fs; 549 if (needs.getTextureTarget() == Key::TEXTURE_EXT) { 550 fs << "#extension GL_OES_EGL_image_external : require"; 551 } 552 553 // default precision is required-ish in fragment shaders 554 fs << "precision mediump float;"; 555 556 if (needs.getTextureTarget() == Key::TEXTURE_EXT) { 557 fs << "uniform samplerExternalOES sampler;" 558 << "varying vec2 outTexCoords;"; 559 } else if (needs.getTextureTarget() == Key::TEXTURE_2D) { 560 fs << "uniform sampler2D sampler;" 561 << "varying vec2 outTexCoords;"; 562 } 563 564 if (needs.hasRoundedCorners()) { 565 // Rounded corners implementation using a signed distance function. 566 fs << R"__SHADER__( 567 uniform float cornerRadius; 568 uniform vec2 cropCenter; 569 varying vec2 outCropCoords; 570 571 /** 572 * This function takes the current crop coordinates and calculates an alpha value based 573 * on the corner radius and distance from the crop center. 574 */ 575 float applyCornerRadius(vec2 cropCoords) 576 { 577 vec2 position = cropCoords - cropCenter; 578 // Scale down the dist vector here, as otherwise large corner 579 // radii can cause floating point issues when computing the norm 580 vec2 dist = (abs(position) - cropCenter + vec2(cornerRadius)) / 16.0; 581 // Once we've found the norm, then scale back up. 582 float plane = length(max(dist, vec2(0.0))) * 16.0; 583 return 1.0 - clamp(plane - cornerRadius, 0.0, 1.0); 584 } 585 )__SHADER__"; 586 } 587 588 if (needs.getTextureTarget() == Key::TEXTURE_OFF || needs.hasAlpha()) { 589 fs << "uniform vec4 color;"; 590 } 591 592 if (needs.isY410BT2020()) { 593 fs << R"__SHADER__( 594 vec3 convertY410BT2020(const vec3 color) { 595 const vec3 offset = vec3(0.0625, 0.5, 0.5); 596 const mat3 transform = mat3( 597 vec3(1.1678, 1.1678, 1.1678), 598 vec3( 0.0, -0.1878, 2.1481), 599 vec3(1.6836, -0.6523, 0.0)); 600 // Y is in G, U is in R, and V is in B 601 return clamp(transform * (color.grb - offset), 0.0, 1.0); 602 } 603 )__SHADER__"; 604 } 605 606 if (needs.hasTransformMatrix() || (needs.getInputTF() != needs.getOutputTF())) { 607 // Currently, display maximum luminance is needed when doing tone mapping. 608 if (needs.needsToneMapping()) { 609 fs << "uniform float displayMaxLuminance;"; 610 } 611 612 if (needs.hasInputTransformMatrix()) { 613 fs << "uniform mat4 inputTransformMatrix;"; 614 fs << R"__SHADER__( 615 highp vec3 InputTransform(const highp vec3 color) { 616 return clamp(vec3(inputTransformMatrix * vec4(color, 1.0)), 0.0, 1.0); 617 } 618 )__SHADER__"; 619 } else { 620 fs << R"__SHADER__( 621 highp vec3 InputTransform(const highp vec3 color) { 622 return color; 623 } 624 )__SHADER__"; 625 } 626 627 // the transformation from a wider colorspace to a narrower one can 628 // result in >1.0 or <0.0 pixel values 629 if (needs.hasOutputTransformMatrix()) { 630 fs << "uniform mat4 outputTransformMatrix;"; 631 fs << R"__SHADER__( 632 highp vec3 OutputTransform(const highp vec3 color) { 633 return clamp(vec3(outputTransformMatrix * vec4(color, 1.0)), 0.0, 1.0); 634 } 635 )__SHADER__"; 636 } else { 637 fs << R"__SHADER__( 638 highp vec3 OutputTransform(const highp vec3 color) { 639 return clamp(color, 0.0, 1.0); 640 } 641 )__SHADER__"; 642 } 643 644 generateEOTF(fs, needs); 645 generateOOTF(fs, needs); 646 generateOETF(fs, needs); 647 } 648 649 fs << "void main(void) {" << indent; 650 if (needs.isTexturing()) { 651 fs << "gl_FragColor = texture2D(sampler, outTexCoords);"; 652 if (needs.isY410BT2020()) { 653 fs << "gl_FragColor.rgb = convertY410BT2020(gl_FragColor.rgb);"; 654 } 655 } else { 656 fs << "gl_FragColor.rgb = color.rgb;"; 657 fs << "gl_FragColor.a = 1.0;"; 658 } 659 if (needs.isOpaque()) { 660 fs << "gl_FragColor.a = 1.0;"; 661 } 662 if (needs.hasAlpha()) { 663 // modulate the current alpha value with alpha set 664 if (needs.isPremultiplied()) { 665 // ... and the color too if we're premultiplied 666 fs << "gl_FragColor *= color.a;"; 667 } else { 668 fs << "gl_FragColor.a *= color.a;"; 669 } 670 } 671 672 if (needs.hasTransformMatrix() || (needs.getInputTF() != needs.getOutputTF())) { 673 if (!needs.isOpaque() && needs.isPremultiplied()) { 674 // un-premultiply if needed before linearization 675 // avoid divide by 0 by adding 0.5/256 to the alpha channel 676 fs << "gl_FragColor.rgb = gl_FragColor.rgb / (gl_FragColor.a + 0.0019);"; 677 } 678 fs << "gl_FragColor.rgb = " 679 "OETF(OutputTransform(OOTF(InputTransform(EOTF(gl_FragColor.rgb)))));"; 680 if (!needs.isOpaque() && needs.isPremultiplied()) { 681 // and re-premultiply if needed after gamma correction 682 fs << "gl_FragColor.rgb = gl_FragColor.rgb * (gl_FragColor.a + 0.0019);"; 683 } 684 } 685 686 if (needs.hasRoundedCorners()) { 687 if (needs.isPremultiplied()) { 688 fs << "gl_FragColor *= vec4(applyCornerRadius(outCropCoords));"; 689 } else { 690 fs << "gl_FragColor.a *= applyCornerRadius(outCropCoords);"; 691 } 692 } 693 694 fs << dedent << "}"; 695 return fs.getString(); 696 } 697 698 std::unique_ptr<Program> ProgramCache::generateProgram(const Key& needs) { 699 ATRACE_CALL(); 700 701 // vertex shader 702 String8 vs = generateVertexShader(needs); 703 704 // fragment shader 705 String8 fs = generateFragmentShader(needs); 706 707 return std::make_unique<Program>(needs, vs.string(), fs.string()); 708 } 709 710 void ProgramCache::useProgram(EGLContext context, const Description& description) { 711 // generate the key for the shader based on the description 712 Key needs(computeKey(description)); 713 714 // look-up the program in the cache 715 auto& cache = mCaches[context]; 716 auto it = cache.find(needs); 717 if (it == cache.end()) { 718 // we didn't find our program, so generate one... 719 nsecs_t time = systemTime(); 720 it = cache.emplace(needs, generateProgram(needs)).first; 721 time = systemTime() - time; 722 723 ALOGV(">>> generated new program for context %p: needs=%08X, time=%u ms (%zu programs)", 724 context, needs.mKey, uint32_t(ns2ms(time)), cache.size()); 725 } 726 727 // here we have a suitable program for this description 728 std::unique_ptr<Program>& program = it->second; 729 if (program->isValid()) { 730 program->use(); 731 program->setUniforms(description); 732 } 733 } 734 735 } // namespace gl 736 } // namespace renderengine 737 } // namespace android 738
