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