SkMaskGamma.h File Reference

#include "include/core/SkColor.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "include/private/SkColorData.h"
#include "include/private/base/SkCPUTypes.h"
#include "include/private/base/SkNoncopyable.h"
#include "include/private/base/SkTo.h"
#include <cstdint>

Go to the source code of this file.

Classes
class	SkColorSpaceLuminance
class	SkTMaskGamma< R_LUM_BITS, G_LUM_BITS, B_LUM_BITS >
class	SkTMaskPreBlend< R_LUM_BITS, G_LUM_BITS, B_LUM_BITS >

Functions
void	SkTMaskGamma_build_correcting_lut (uint8_t table[256], U8CPU srcI, SkScalar contrast, const SkColorSpaceLuminance &dstConvert, SkScalar dstGamma)
template<U8CPU N>
static U8CPU	sk_t_scale255 (U8CPU base)
template<>
U8CPU	sk_t_scale255< 1 > (U8CPU base)
template<>
U8CPU	sk_t_scale255< 2 > (U8CPU base)
template<>
U8CPU	sk_t_scale255< 4 > (U8CPU base)
template<>
U8CPU	sk_t_scale255< 8 > (U8CPU base)
template<bool APPLY_LUT>
static U8CPU	sk_apply_lut_if (U8CPU component, const uint8_t *)
template<>
U8CPU	sk_apply_lut_if< true > (U8CPU component, const uint8_t *lut)

Function Documentation

sk_apply_lut_if()

template<bool APPLY_LUT>

static U8CPU sk_apply_lut_if ( U8CPU  component, const uint8_t *    )

inlinestatic

If APPLY_LUT is false, returns component unchanged. If APPLY_LUT is true, returns lut[component].

Parameters

APPLY_LUT

whether or not the look-up table should be applied to component. @component the initial component. @lut a look-up table which transforms the component.

Definition at line 225 of file SkMaskGamma.h.

                                                                                              {
    return component;
}

sk_apply_lut_if< true >()

template<>

U8CPU sk_apply_lut_if< true > ( U8CPU  component, const uint8_t *  lut  )

inline

Definition at line 228 of file SkMaskGamma.h.

                                                                                     {
    return lut[component];
}

sk_t_scale255()

template<U8CPU N>

static U8CPU sk_t_scale255 ( U8CPU  base )

inlinestatic

Scales base <= 2^N-1 to 2^8-1

Parameters

N	[1, 8] the number of bits used by base.
base	the number to be scaled to [0, 255].

Definition at line 61 of file SkMaskGamma.h.

                                                                {
    base <<= (8 - N);
    U8CPU lum = base;
    for (unsigned int i = N; i < 8; i += N) {
        lum |= base >> i;
    }
    return lum;
}

sk_t_scale255< 1 >()

template<>

U8CPU sk_t_scale255< 1 > ( U8CPU  base )

inline

Definition at line 69 of file SkMaskGamma.h.

                                                       {
    return base * 0xFF;
}

sk_t_scale255< 2 >()

template<>

U8CPU sk_t_scale255< 2 > ( U8CPU  base )

inline

Definition at line 72 of file SkMaskGamma.h.

                                                       {
    return base * 0x55;
}

sk_t_scale255< 4 >()

template<>

U8CPU sk_t_scale255< 4 > ( U8CPU  base )

inline

Definition at line 75 of file SkMaskGamma.h.

                                                       {
    return base * 0x11;
}

sk_t_scale255< 8 >()

template<>

U8CPU sk_t_scale255< 8 > ( U8CPU  base )

inline

Definition at line 78 of file SkMaskGamma.h.

                                                       {
    return base;
}

SkTMaskGamma_build_correcting_lut()

void SkTMaskGamma_build_correcting_lut	(	uint8_t	table[256],
		U8CPU	srcI,
		SkScalar	contrast,
		const SkColorSpaceLuminance &	dstConvert,
		SkScalar	dstGamma
	)

Definition at line 78 of file SkMaskGamma.cpp.

                                                                                                   {
    const SkColorSpaceLuminance& srcConvert = dstConvert;
    const SkScalar srcGamma = dstGamma;
    const float src = (float)srcI / 255.0f;
    const float linSrc = srcConvert.toLuma(srcGamma, src);
    //Guess at the dst. The perceptual inverse provides smaller visual
    //discontinuities when slight changes to desaturated colors cause a channel
    //to map to a different correcting lut with neighboring srcI.
    //See https://code.google.com/p/chromium/issues/detail?id=141425#c59 .
    const float dst = 1.0f - src;
    const float linDst = dstConvert.toLuma(dstGamma, dst);
 
    //Contrast value tapers off to 0 as the src luminance becomes white
    const float adjustedContrast = contrast * linDst;
 
    //Remove discontinuity and instability when src is close to dst.
    //The value 1/256 is arbitrary and appears to contain the instability.
    if (fabs(src - dst) < (1.0f / 256.0f)) {
        float ii = 0.0f;
        for (int i = 0; i < 256; ++i, ii += 1.0f) {
            float rawSrca = ii / 255.0f;
            float srca = apply_contrast(rawSrca, adjustedContrast);
            table[i] = SkToU8(sk_float_round2int(255.0f * srca));
        }
    } else {
        // Avoid slow int to float conversion.
        float ii = 0.0f;
        for (int i = 0; i < 256; ++i, ii += 1.0f) {
            // 'rawSrca += 1.0f / 255.0f' and even
            // 'rawSrca = i * (1.0f / 255.0f)' can add up to more than 1.0f.
            // When this happens the table[255] == 0x0 instead of 0xff.
            // See http://code.google.com/p/chromium/issues/detail?id=146466
            float rawSrca = ii / 255.0f;
            float srca = apply_contrast(rawSrca, adjustedContrast);
            SkASSERT(srca <= 1.0f);
            float dsta = 1.0f - srca;
 
            //Calculate the output we want.
            float linOut = (linSrc * srca + dsta * linDst);
            SkASSERT(linOut <= 1.0f);
            float out = dstConvert.fromLuma(dstGamma, linOut);
 
            //Undo what the blit blend will do.
            float result = (out - dst) / (src - dst);
            SkASSERT(sk_float_round2int(255.0f * result) <= 255);
 
            table[i] = SkToU8(sk_float_round2int(255.0f * result));
        }
    }
}