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 #ifndef SkMaskGamma_DEFINED
      9 #define SkMaskGamma_DEFINED
     10 
     11 #include "SkTypes.h"
     12 #include "SkColor.h"
     13 #include "SkColorPriv.h"
     14 #include "SkRefCnt.h"
     15 
     16 /**
     17  * SkColorSpaceLuminance is used to convert luminances to and from linear and
     18  * perceptual color spaces.
     19  *
     20  * Luma is used to specify a linear luminance value [0.0, 1.0].
     21  * Luminance is used to specify a luminance value in an arbitrary color space [0.0, 1.0].
     22  */
     23 class SkColorSpaceLuminance : SkNoncopyable {
     24 public:
     25     virtual ~SkColorSpaceLuminance() { }
     26 
     27     /** Converts a color component luminance in the color space to a linear luma. */
     28     virtual SkScalar toLuma(SkScalar gamma, SkScalar luminance) const = 0;
     29     /** Converts a linear luma to a color component luminance in the color space. */
     30     virtual SkScalar fromLuma(SkScalar gamma, SkScalar luma) const = 0;
     31 
     32     /** Converts a color to a luminance value. */
     33     static U8CPU computeLuminance(SkScalar gamma, SkColor c) {
     34         const SkColorSpaceLuminance& luminance = Fetch(gamma);
     35         SkScalar r = luminance.toLuma(gamma, SkIntToScalar(SkColorGetR(c)) / 255);
     36         SkScalar g = luminance.toLuma(gamma, SkIntToScalar(SkColorGetG(c)) / 255);
     37         SkScalar b = luminance.toLuma(gamma, SkIntToScalar(SkColorGetB(c)) / 255);
     38         SkScalar luma = r * SK_LUM_COEFF_R +
     39                         g * SK_LUM_COEFF_G +
     40                         b * SK_LUM_COEFF_B;
     41         SkASSERT(luma <= SK_Scalar1);
     42         return SkScalarRoundToInt(luminance.fromLuma(gamma, luma) * 255);
     43     }
     44 
     45     /** Retrieves the SkColorSpaceLuminance for the given gamma. */
     46     static const SkColorSpaceLuminance& Fetch(SkScalar gamma);
     47 };
     48 
     49 ///@{
     50 /**
     51  * Scales base <= 2^N-1 to 2^8-1
     52  * @param N [1, 8] the number of bits used by base.
     53  * @param base the number to be scaled to [0, 255].
     54  */
     55 template<U8CPU N> static inline U8CPU sk_t_scale255(U8CPU base) {
     56     base <<= (8 - N);
     57     U8CPU lum = base;
     58     for (unsigned int i = N; i < 8; i += N) {
     59         lum |= base >> i;
     60     }
     61     return lum;
     62 }
     63 template<> /*static*/ inline U8CPU sk_t_scale255<1>(U8CPU base) {
     64     return base * 0xFF;
     65 }
     66 template<> /*static*/ inline U8CPU sk_t_scale255<2>(U8CPU base) {
     67     return base * 0x55;
     68 }
     69 template<> /*static*/ inline U8CPU sk_t_scale255<4>(U8CPU base) {
     70     return base * 0x11;
     71 }
     72 template<> /*static*/ inline U8CPU sk_t_scale255<8>(U8CPU base) {
     73     return base;
     74 }
     75 ///@}
     76 
     77 template <int R_LUM_BITS, int G_LUM_BITS, int B_LUM_BITS> class SkTMaskPreBlend;
     78 
     79 void SkTMaskGamma_build_correcting_lut(uint8_t table[256], U8CPU srcI, SkScalar contrast,
     80                                        const SkColorSpaceLuminance& srcConvert, SkScalar srcGamma,
     81                                        const SkColorSpaceLuminance& dstConvert, SkScalar dstGamma);
     82 
     83 /**
     84  * A regular mask contains linear alpha values. A gamma correcting mask
     85  * contains non-linear alpha values in an attempt to create gamma correct blits
     86  * in the presence of a gamma incorrect (linear) blend in the blitter.
     87  *
     88  * SkMaskGamma creates and maintains tables which convert linear alpha values
     89  * to gamma correcting alpha values.
     90  * @param R The number of luminance bits to use [1, 8] from the red channel.
     91  * @param G The number of luminance bits to use [1, 8] from the green channel.
     92  * @param B The number of luminance bits to use [1, 8] from the blue channel.
     93  */
     94 template <int R_LUM_BITS, int G_LUM_BITS, int B_LUM_BITS> class SkTMaskGamma : public SkRefCnt {
     95 
     96 public:
     97 
     98     /** Creates a linear SkTMaskGamma. */
     99     SkTMaskGamma() : fIsLinear(true) { }
    100 
    101     /**
    102      * Creates tables to convert linear alpha values to gamma correcting alpha
    103      * values.
    104      *
    105      * @param contrast A value in the range [0.0, 1.0] which indicates the
    106      *                 amount of artificial contrast to add.
    107      * @param paint The color space in which the paint color was chosen.
    108      * @param device The color space of the target device.
    109      */
    110     SkTMaskGamma(SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma) : fIsLinear(false) {
    111         const SkColorSpaceLuminance& paintConvert = SkColorSpaceLuminance::Fetch(paintGamma);
    112         const SkColorSpaceLuminance& deviceConvert = SkColorSpaceLuminance::Fetch(deviceGamma);
    113         for (U8CPU i = 0; i < (1 << MAX_LUM_BITS); ++i) {
    114             U8CPU lum = sk_t_scale255<MAX_LUM_BITS>(i);
    115             SkTMaskGamma_build_correcting_lut(fGammaTables[i], lum, contrast,
    116                                               paintConvert, paintGamma,
    117                                               deviceConvert, deviceGamma);
    118         }
    119     }
    120 
    121     /** Given a color, returns the closest canonical color. */
    122     static SkColor CanonicalColor(SkColor color) {
    123         return SkColorSetRGB(
    124                    sk_t_scale255<R_LUM_BITS>(SkColorGetR(color) >> (8 - R_LUM_BITS)),
    125                    sk_t_scale255<G_LUM_BITS>(SkColorGetG(color) >> (8 - G_LUM_BITS)),
    126                    sk_t_scale255<B_LUM_BITS>(SkColorGetB(color) >> (8 - B_LUM_BITS)));
    127     }
    128 
    129     /** The type of the mask pre-blend which will be returned from preBlend(SkColor). */
    130     typedef SkTMaskPreBlend<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS> PreBlend;
    131 
    132     /**
    133      * Provides access to the tables appropriate for converting linear alpha
    134      * values into gamma correcting alpha values when drawing the given color
    135      * through the mask. The destination color will be approximated.
    136      */
    137     PreBlend preBlend(SkColor color) const;
    138 
    139     /**
    140      * Get dimensions for the full table set, so it can be allocated as a block.
    141      */
    142     void getGammaTableDimensions(int* tableWidth, int* numTables) const {
    143         *tableWidth = 256;
    144         *numTables = (1 << MAX_LUM_BITS);
    145     }
    146 
    147     /**
    148      * Provides direct access to the full table set, so it can be uploaded
    149      * into a texture.
    150      */
    151     const uint8_t* getGammaTables() const {
    152         return (const uint8_t*) fGammaTables;
    153     }
    154 
    155 private:
    156     static const int MAX_LUM_BITS =
    157           B_LUM_BITS > (R_LUM_BITS > G_LUM_BITS ? R_LUM_BITS : G_LUM_BITS)
    158         ? B_LUM_BITS : (R_LUM_BITS > G_LUM_BITS ? R_LUM_BITS : G_LUM_BITS);
    159     uint8_t fGammaTables[1 << MAX_LUM_BITS][256];
    160     bool fIsLinear;
    161 
    162     typedef SkRefCnt INHERITED;
    163 };
    164 
    165 
    166 /**
    167  * SkTMaskPreBlend is a tear-off of SkTMaskGamma. It provides the tables to
    168  * convert a linear alpha value for a given channel to a gamma correcting alpha
    169  * value for that channel. This class is immutable.
    170  *
    171  * If fR, fG, or fB is nullptr, all of them will be. This indicates that no mask
    172  * pre blend should be applied. SkTMaskPreBlend::isApplicable() is provided as
    173  * a convenience function to test for the absence of this case.
    174  */
    175 template <int R_LUM_BITS, int G_LUM_BITS, int B_LUM_BITS> class SkTMaskPreBlend {
    176 private:
    177     SkTMaskPreBlend(const SkTMaskGamma<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>* parent,
    178                     const uint8_t* r, const uint8_t* g, const uint8_t* b)
    179     : fParent(SkSafeRef(parent)), fR(r), fG(g), fB(b) { }
    180 
    181     SkAutoTUnref<const SkTMaskGamma<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS> > fParent;
    182     friend class SkTMaskGamma<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>;
    183 public:
    184     /** Creates a non applicable SkTMaskPreBlend. */
    185     SkTMaskPreBlend() : fParent(), fR(nullptr), fG(nullptr), fB(nullptr) { }
    186 
    187     /**
    188      * This copy contructor exists for correctness, but should never be called
    189      * when return value optimization is enabled.
    190      */
    191     SkTMaskPreBlend(const SkTMaskPreBlend<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>& that)
    192     : fParent(SkSafeRef(that.fParent.get())), fR(that.fR), fG(that.fG), fB(that.fB) { }
    193 
    194     ~SkTMaskPreBlend() { }
    195 
    196     /** True if this PreBlend should be applied. When false, fR, fG, and fB are nullptr. */
    197     bool isApplicable() const { return SkToBool(this->fG); }
    198 
    199     const uint8_t* fR;
    200     const uint8_t* fG;
    201     const uint8_t* fB;
    202 };
    203 
    204 template <int R_LUM_BITS, int G_LUM_BITS, int B_LUM_BITS>
    205 SkTMaskPreBlend<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>
    206 SkTMaskGamma<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>::preBlend(SkColor color) const {
    207     return fIsLinear ? SkTMaskPreBlend<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>()
    208                      : SkTMaskPreBlend<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>(this,
    209                          fGammaTables[SkColorGetR(color) >> (8 - MAX_LUM_BITS)],
    210                          fGammaTables[SkColorGetG(color) >> (8 - MAX_LUM_BITS)],
    211                          fGammaTables[SkColorGetB(color) >> (8 - MAX_LUM_BITS)]);
    212 }
    213 
    214 ///@{
    215 /**
    216  *  If APPLY_LUT is false, returns component unchanged.
    217  *  If APPLY_LUT is true, returns lut[component].
    218  *  @param APPLY_LUT whether or not the look-up table should be applied to component.
    219  *  @component the initial component.
    220  *  @lut a look-up table which transforms the component.
    221  */
    222 template<bool APPLY_LUT> static inline U8CPU sk_apply_lut_if(U8CPU component, const uint8_t*) {
    223     return component;
    224 }
    225 template<> /*static*/ inline U8CPU sk_apply_lut_if<true>(U8CPU component, const uint8_t* lut) {
    226     return lut[component];
    227 }
    228 ///@}
    229 
    230 #endif
    231