Home | History | Annotate | Download | only in core 
      1 /*
      2  * Copyright 2012 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #include "SkTypes.h"
      9 
     10 #include "SkColor.h"
     11 #include "SkFloatingPoint.h"
     12 #include "SkMaskGamma.h"
     13 
     14 class SkLinearColorSpaceLuminance : public SkColorSpaceLuminance {
     15     SkScalar toLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luminance) const override {
     16         SkASSERT(SK_Scalar1 == gamma);
     17         return luminance;
     18     }
     19     SkScalar fromLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luma) const override {
     20         SkASSERT(SK_Scalar1 == gamma);
     21         return luma;
     22     }
     23 };
     24 
     25 class SkGammaColorSpaceLuminance : public SkColorSpaceLuminance {
     26     SkScalar toLuma(SkScalar gamma, SkScalar luminance) const override {
     27         return SkScalarPow(luminance, gamma);
     28     }
     29     SkScalar fromLuma(SkScalar gamma, SkScalar luma) const override {
     30         return SkScalarPow(luma, SkScalarInvert(gamma));
     31     }
     32 };
     33 
     34 class SkSRGBColorSpaceLuminance : public SkColorSpaceLuminance {
     35     SkScalar toLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luminance) const override {
     36         SkASSERT(0 == gamma);
     37         //The magic numbers are derived from the sRGB specification.
     38         //See http://www.color.org/chardata/rgb/srgb.xalter .
     39         if (luminance <= 0.04045f) {
     40             return luminance / 12.92f;
     41         }
     42         return SkScalarPow((luminance + 0.055f) / 1.055f,
     43                         2.4f);
     44     }
     45     SkScalar fromLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luma) const override {
     46         SkASSERT(0 == gamma);
     47         //The magic numbers are derived from the sRGB specification.
     48         //See http://www.color.org/chardata/rgb/srgb.xalter .
     49         if (luma <= 0.0031308f) {
     50             return luma * 12.92f;
     51         }
     52         return 1.055f * SkScalarPow(luma, SkScalarInvert(2.4f))
     53                - 0.055f;
     54     }
     55 };
     56 
     57 /*static*/ const SkColorSpaceLuminance& SkColorSpaceLuminance::Fetch(SkScalar gamma) {
     58     static SkLinearColorSpaceLuminance gSkLinearColorSpaceLuminance;
     59     static SkGammaColorSpaceLuminance gSkGammaColorSpaceLuminance;
     60     static SkSRGBColorSpaceLuminance gSkSRGBColorSpaceLuminance;
     61 
     62     if (0 == gamma) {
     63         return gSkSRGBColorSpaceLuminance;
     64     } else if (SK_Scalar1 == gamma) {
     65         return gSkLinearColorSpaceLuminance;
     66     } else {
     67         return gSkGammaColorSpaceLuminance;
     68     }
     69 }
     70 
     71 static float apply_contrast(float srca, float contrast) {
     72     return srca + ((1.0f - srca) * contrast * srca);
     73 }
     74 
     75 void SkTMaskGamma_build_correcting_lut(uint8_t table[256], U8CPU srcI, SkScalar contrast,
     76                                        const SkColorSpaceLuminance& srcConvert, SkScalar srcGamma,
     77                                        const SkColorSpaceLuminance& dstConvert, SkScalar dstGamma) {
     78     const float src = (float)srcI / 255.0f;
     79     const float linSrc = srcConvert.toLuma(srcGamma, src);
     80     //Guess at the dst. The perceptual inverse provides smaller visual
     81     //discontinuities when slight changes to desaturated colors cause a channel
     82     //to map to a different correcting lut with neighboring srcI.
     83     //See https://code.google.com/p/chromium/issues/detail?id=141425#c59 .
     84     const float dst = 1.0f - src;
     85     const float linDst = dstConvert.toLuma(dstGamma, dst);
     86 
     87     //Contrast value tapers off to 0 as the src luminance becomes white
     88     const float adjustedContrast = SkScalarToFloat(contrast) * linDst;
     89 
     90     //Remove discontinuity and instability when src is close to dst.
     91     //The value 1/256 is arbitrary and appears to contain the instability.
     92     if (fabs(src - dst) < (1.0f / 256.0f)) {
     93         float ii = 0.0f;
     94         for (int i = 0; i < 256; ++i, ii += 1.0f) {
     95             float rawSrca = ii / 255.0f;
     96             float srca = apply_contrast(rawSrca, adjustedContrast);
     97             table[i] = SkToU8(sk_float_round2int(255.0f * srca));
     98         }
     99     } else {
    100         // Avoid slow int to float conversion.
    101         float ii = 0.0f;
    102         for (int i = 0; i < 256; ++i, ii += 1.0f) {
    103             // 'rawSrca += 1.0f / 255.0f' and even
    104             // 'rawSrca = i * (1.0f / 255.0f)' can add up to more than 1.0f.
    105             // When this happens the table[255] == 0x0 instead of 0xff.
    106             // See http://code.google.com/p/chromium/issues/detail?id=146466
    107             float rawSrca = ii / 255.0f;
    108             float srca = apply_contrast(rawSrca, adjustedContrast);
    109             SkASSERT(srca <= 1.0f);
    110             float dsta = 1.0f - srca;
    111 
    112             //Calculate the output we want.
    113             float linOut = (linSrc * srca + dsta * linDst);
    114             SkASSERT(linOut <= 1.0f);
    115             float out = dstConvert.fromLuma(dstGamma, linOut);
    116 
    117             //Undo what the blit blend will do.
    118             float result = (out - dst) / (src - dst);
    119             SkASSERT(sk_float_round2int(255.0f * result) <= 255);
    120 
    121             table[i] = SkToU8(sk_float_round2int(255.0f * result));
    122         }
    123     }
    124 }
    125