SkMaskGamma.cpp File Reference

#include "src/core/SkMaskGamma.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkTo.h"
#include <cmath>

Go to the source code of this file.

Classes
class	SkLinearColorSpaceLuminance
class	SkGammaColorSpaceLuminance
class	SkSRGBColorSpaceLuminance

Functions
static float	apply_contrast (float srca, float contrast)
void	SkTMaskGamma_build_correcting_lut (uint8_t table[256], U8CPU srcI, SkScalar contrast, const SkColorSpaceLuminance &srcConvert, SkScalar srcGamma, const SkColorSpaceLuminance &dstConvert, SkScalar dstGamma)

Function Documentation

apply_contrast()

static float apply_contrast ( float  srca, float  contrast  )

static

Definition at line 74 of file SkMaskGamma.cpp.

                                                        {
    return srca + ((1.0f - srca) * contrast * srca);
}

SkTMaskGamma_build_correcting_lut()

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

Definition at line 78 of file SkMaskGamma.cpp.

                                                                                                   {
    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));
        }
    }
}