123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232 |
- /*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
- #ifndef SkMaskGamma_DEFINED
- #define SkMaskGamma_DEFINED
- #include "include/core/SkColor.h"
- #include "include/core/SkRefCnt.h"
- #include "include/core/SkTypes.h"
- #include "include/private/SkColorData.h"
- #include "include/private/SkNoncopyable.h"
- /**
- * SkColorSpaceLuminance is used to convert luminances to and from linear and
- * perceptual color spaces.
- *
- * Luma is used to specify a linear luminance value [0.0, 1.0].
- * Luminance is used to specify a luminance value in an arbitrary color space [0.0, 1.0].
- */
- class SkColorSpaceLuminance : SkNoncopyable {
- public:
- virtual ~SkColorSpaceLuminance() { }
- /** Converts a color component luminance in the color space to a linear luma. */
- virtual SkScalar toLuma(SkScalar gamma, SkScalar luminance) const = 0;
- /** Converts a linear luma to a color component luminance in the color space. */
- virtual SkScalar fromLuma(SkScalar gamma, SkScalar luma) const = 0;
- /** Converts a color to a luminance value. */
- static U8CPU computeLuminance(SkScalar gamma, SkColor c) {
- const SkColorSpaceLuminance& luminance = Fetch(gamma);
- SkScalar r = luminance.toLuma(gamma, SkIntToScalar(SkColorGetR(c)) / 255);
- SkScalar g = luminance.toLuma(gamma, SkIntToScalar(SkColorGetG(c)) / 255);
- SkScalar b = luminance.toLuma(gamma, SkIntToScalar(SkColorGetB(c)) / 255);
- SkScalar luma = r * SK_LUM_COEFF_R +
- g * SK_LUM_COEFF_G +
- b * SK_LUM_COEFF_B;
- SkASSERT(luma <= SK_Scalar1);
- return SkScalarRoundToInt(luminance.fromLuma(gamma, luma) * 255);
- }
- /** Retrieves the SkColorSpaceLuminance for the given gamma. */
- static const SkColorSpaceLuminance& Fetch(SkScalar gamma);
- };
- ///@{
- /**
- * Scales base <= 2^N-1 to 2^8-1
- * @param N [1, 8] the number of bits used by base.
- * @param base the number to be scaled to [0, 255].
- */
- template<U8CPU N> static inline U8CPU sk_t_scale255(U8CPU base) {
- base <<= (8 - N);
- U8CPU lum = base;
- for (unsigned int i = N; i < 8; i += N) {
- lum |= base >> i;
- }
- return lum;
- }
- template<> /*static*/ inline U8CPU sk_t_scale255<1>(U8CPU base) {
- return base * 0xFF;
- }
- template<> /*static*/ inline U8CPU sk_t_scale255<2>(U8CPU base) {
- return base * 0x55;
- }
- template<> /*static*/ inline U8CPU sk_t_scale255<4>(U8CPU base) {
- return base * 0x11;
- }
- template<> /*static*/ inline U8CPU sk_t_scale255<8>(U8CPU base) {
- return base;
- }
- ///@}
- template <int R_LUM_BITS, int G_LUM_BITS, int B_LUM_BITS> class SkTMaskPreBlend;
- void SkTMaskGamma_build_correcting_lut(uint8_t table[256], U8CPU srcI, SkScalar contrast,
- const SkColorSpaceLuminance& srcConvert, SkScalar srcGamma,
- const SkColorSpaceLuminance& dstConvert, SkScalar dstGamma);
- /**
- * A regular mask contains linear alpha values. A gamma correcting mask
- * contains non-linear alpha values in an attempt to create gamma correct blits
- * in the presence of a gamma incorrect (linear) blend in the blitter.
- *
- * SkMaskGamma creates and maintains tables which convert linear alpha values
- * to gamma correcting alpha values.
- * @param R The number of luminance bits to use [1, 8] from the red channel.
- * @param G The number of luminance bits to use [1, 8] from the green channel.
- * @param B The number of luminance bits to use [1, 8] from the blue channel.
- */
- template <int R_LUM_BITS, int G_LUM_BITS, int B_LUM_BITS> class SkTMaskGamma : public SkRefCnt {
- public:
- /** Creates a linear SkTMaskGamma. */
- SkTMaskGamma() : fIsLinear(true) { }
- /**
- * Creates tables to convert linear alpha values to gamma correcting alpha
- * values.
- *
- * @param contrast A value in the range [0.0, 1.0] which indicates the
- * amount of artificial contrast to add.
- * @param paint The color space in which the paint color was chosen.
- * @param device The color space of the target device.
- */
- SkTMaskGamma(SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma) : fIsLinear(false) {
- const SkColorSpaceLuminance& paintConvert = SkColorSpaceLuminance::Fetch(paintGamma);
- const SkColorSpaceLuminance& deviceConvert = SkColorSpaceLuminance::Fetch(deviceGamma);
- for (U8CPU i = 0; i < (1 << MAX_LUM_BITS); ++i) {
- U8CPU lum = sk_t_scale255<MAX_LUM_BITS>(i);
- SkTMaskGamma_build_correcting_lut(fGammaTables[i], lum, contrast,
- paintConvert, paintGamma,
- deviceConvert, deviceGamma);
- }
- }
- /** Given a color, returns the closest canonical color. */
- static SkColor CanonicalColor(SkColor color) {
- return SkColorSetRGB(
- sk_t_scale255<R_LUM_BITS>(SkColorGetR(color) >> (8 - R_LUM_BITS)),
- sk_t_scale255<G_LUM_BITS>(SkColorGetG(color) >> (8 - G_LUM_BITS)),
- sk_t_scale255<B_LUM_BITS>(SkColorGetB(color) >> (8 - B_LUM_BITS)));
- }
- /** The type of the mask pre-blend which will be returned from preBlend(SkColor). */
- typedef SkTMaskPreBlend<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS> PreBlend;
- /**
- * Provides access to the tables appropriate for converting linear alpha
- * values into gamma correcting alpha values when drawing the given color
- * through the mask. The destination color will be approximated.
- */
- PreBlend preBlend(SkColor color) const;
- /**
- * Get dimensions for the full table set, so it can be allocated as a block.
- */
- void getGammaTableDimensions(int* tableWidth, int* numTables) const {
- *tableWidth = 256;
- *numTables = (1 << MAX_LUM_BITS);
- }
- /**
- * Provides direct access to the full table set, so it can be uploaded
- * into a texture or analyzed in other ways.
- * Returns nullptr if fGammaTables hasn't been initialized.
- */
- const uint8_t* getGammaTables() const {
- return fIsLinear ? nullptr : (const uint8_t*) fGammaTables;
- }
- private:
- static const int MAX_LUM_BITS =
- B_LUM_BITS > (R_LUM_BITS > G_LUM_BITS ? R_LUM_BITS : G_LUM_BITS)
- ? B_LUM_BITS : (R_LUM_BITS > G_LUM_BITS ? R_LUM_BITS : G_LUM_BITS);
- uint8_t fGammaTables[1 << MAX_LUM_BITS][256];
- bool fIsLinear;
- typedef SkRefCnt INHERITED;
- };
- /**
- * SkTMaskPreBlend is a tear-off of SkTMaskGamma. It provides the tables to
- * convert a linear alpha value for a given channel to a gamma correcting alpha
- * value for that channel. This class is immutable.
- *
- * If fR, fG, or fB is nullptr, all of them will be. This indicates that no mask
- * pre blend should be applied. SkTMaskPreBlend::isApplicable() is provided as
- * a convenience function to test for the absence of this case.
- */
- template <int R_LUM_BITS, int G_LUM_BITS, int B_LUM_BITS> class SkTMaskPreBlend {
- private:
- SkTMaskPreBlend(sk_sp<const SkTMaskGamma<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>> parent,
- const uint8_t* r, const uint8_t* g, const uint8_t* b)
- : fParent(std::move(parent)), fR(r), fG(g), fB(b) { }
- sk_sp<const SkTMaskGamma<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>> fParent;
- friend class SkTMaskGamma<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>;
- public:
- /** Creates a non applicable SkTMaskPreBlend. */
- SkTMaskPreBlend() : fParent(), fR(nullptr), fG(nullptr), fB(nullptr) { }
- /**
- * This copy contructor exists for correctness, but should never be called
- * when return value optimization is enabled.
- */
- SkTMaskPreBlend(const SkTMaskPreBlend<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>& that)
- : fParent(that.fParent), fR(that.fR), fG(that.fG), fB(that.fB) { }
- ~SkTMaskPreBlend() { }
- /** True if this PreBlend should be applied. When false, fR, fG, and fB are nullptr. */
- bool isApplicable() const { return SkToBool(this->fG); }
- const uint8_t* fR;
- const uint8_t* fG;
- const uint8_t* fB;
- };
- template <int R_LUM_BITS, int G_LUM_BITS, int B_LUM_BITS>
- SkTMaskPreBlend<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>
- SkTMaskGamma<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>::preBlend(SkColor color) const {
- return fIsLinear ? SkTMaskPreBlend<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>()
- : SkTMaskPreBlend<R_LUM_BITS, G_LUM_BITS, B_LUM_BITS>(sk_ref_sp(this),
- fGammaTables[SkColorGetR(color) >> (8 - MAX_LUM_BITS)],
- fGammaTables[SkColorGetG(color) >> (8 - MAX_LUM_BITS)],
- fGammaTables[SkColorGetB(color) >> (8 - MAX_LUM_BITS)]);
- }
- ///@{
- /**
- * If APPLY_LUT is false, returns component unchanged.
- * If APPLY_LUT is true, returns lut[component].
- * @param 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.
- */
- template<bool APPLY_LUT> static inline U8CPU sk_apply_lut_if(U8CPU component, const uint8_t*) {
- return component;
- }
- template<> /*static*/ inline U8CPU sk_apply_lut_if<true>(U8CPU component, const uint8_t* lut) {
- return lut[component];
- }
- ///@}
- #endif
|