SkScalerContext.cpp File Reference

#include "src/core/SkScalerContext.h"
#include "include/core/SkColorType.h"
#include "include/core/SkDrawable.h"
#include "include/core/SkFont.h"
#include "include/core/SkFontMetrics.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkStrokeRec.h"
#include "include/private/SkColorData.h"
#include "include/private/base/SkAlign.h"
#include "include/private/base/SkCPUTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkFixed.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkMutex.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkArenaAlloc.h"
#include "src/base/SkAutoMalloc.h"
#include "src/core/SkAutoPixmapStorage.h"
#include "src/core/SkBlitter_A8.h"
#include "src/core/SkDescriptor.h"
#include "src/core/SkDrawBase.h"
#include "src/core/SkFontPriv.h"
#include "src/core/SkGlyph.h"
#include "src/core/SkMaskFilterBase.h"
#include "src/core/SkPaintPriv.h"
#include "src/core/SkRasterClip.h"
#include "src/core/SkTextFormatParams.h"
#include "src/core/SkWriteBuffer.h"
#include "src/utils/SkMatrix22.h"
#include <algorithm>
#include <cstring>
#include <limits>
#include <new>

Go to the source code of this file.

Macros
#define	SAMPLES_PER_PIXEL   4
#define	LCD_PER_PIXEL   3
#define	SK_MAX_SIZE_FOR_LCDTEXT   48

Functions
static SkMutex &	mask_gamma_cache_mutex ()
static const SkMaskGamma &	cached_mask_gamma (SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma)
template<typename D , typename S >
static constexpr D	sk_saturate_cast (S s)
static void	applyLUTToA8Mask (SkMaskBuilder &mask, const uint8_t *lut)
static void	pack4xHToMask (const SkPixmap &src, SkMaskBuilder &dst, const SkMaskGamma::PreBlend &maskPreBlend, const bool doBGR, const bool doVert)
static int	convert_8_to_1 (unsigned byte)
static uint8_t	pack_8_to_1 (const uint8_t alpha[8])
static void	packA8ToA1 (SkMaskBuilder &dstMask, const uint8_t *src, size_t srcRB)
static SkScalar	sk_relax (SkScalar x)
static SkMask::Format	compute_mask_format (const SkFont &font)
static bool	too_big_for_lcd (const SkScalerContextRec &rec, bool checkPost2x2)
static size_t	calculate_size_and_flatten (const SkScalerContextRec &rec, const SkScalerContextEffects &effects, SkBinaryWriteBuffer *effectBuffer)
static void	generate_descriptor (const SkScalerContextRec &rec, const SkBinaryWriteBuffer &effectBuffer, SkDescriptor *desc)

Variables
static SkMaskGamma *	gLinearMaskGamma = nullptr
static SkMaskGamma *	gMaskGamma = nullptr
static SkScalar	gContrast = SK_ScalarMin
static SkScalar	gPaintGamma = SK_ScalarMin
static SkScalar	gDeviceGamma = SK_ScalarMin
const SkScalar	gMaxSize2ForLCDText = SK_MAX_SIZE_FOR_LCDTEXT * SK_MAX_SIZE_FOR_LCDTEXT

Macro Definition Documentation

LCD_PER_PIXEL

#define LCD_PER_PIXEL   3

SAMPLES_PER_PIXEL

#define SAMPLES_PER_PIXEL   4

SK_MAX_SIZE_FOR_LCDTEXT

#define SK_MAX_SIZE_FOR_LCDTEXT   48

Definition at line 1027 of file SkScalerContext.cpp.

Function Documentation

applyLUTToA8Mask()

static void applyLUTToA8Mask ( SkMaskBuilder &  mask, const uint8_t *  lut  )

static

Definition at line 312 of file SkScalerContext.cpp.

                                                                      {
    uint8_t* SK_RESTRICT dst = mask.image();
    unsigned rowBytes = mask.fRowBytes;
 
    for (int y = mask.fBounds.height() - 1; y >= 0; --y) {
        for (int x = mask.fBounds.width() - 1; x >= 0; --x) {
            dst[x] = lut[dst[x]];
        }
        dst += rowBytes;
    }
}

cached_mask_gamma()

static const SkMaskGamma & cached_mask_gamma ( SkScalar  contrast, SkScalar  paintGamma, SkScalar  deviceGamma  )

static

The caller must hold the mask_gamma_cache_mutex() and continue to hold it until the returned SkMaskGamma pointer is refed or forgotten.

Definition at line 129 of file SkScalerContext.cpp.

                                                                  {
    mask_gamma_cache_mutex().assertHeld();
    if (0 == contrast && SK_Scalar1 == paintGamma && SK_Scalar1 == deviceGamma) {
        if (nullptr == gLinearMaskGamma) {
            gLinearMaskGamma = new SkMaskGamma;
        }
        return *gLinearMaskGamma;
    }
    if (gContrast != contrast || gPaintGamma != paintGamma || gDeviceGamma != deviceGamma) {
        SkSafeUnref(gMaskGamma);
        gMaskGamma = new SkMaskGamma(contrast, paintGamma, deviceGamma);
        gContrast = contrast;
        gPaintGamma = paintGamma;
        gDeviceGamma = deviceGamma;
    }
    return *gMaskGamma;
}

calculate_size_and_flatten()

static size_t calculate_size_and_flatten ( const SkScalerContextRec &  rec, const SkScalerContextEffects &  effects, SkBinaryWriteBuffer *  effectBuffer  )

static

Definition at line 1205 of file SkScalerContext.cpp.

                                                                            {
    size_t descSize = sizeof(rec);
    int entryCount = 1;
 
    if (effects.fPathEffect || effects.fMaskFilter) {
        if (effects.fPathEffect) { effectBuffer->writeFlattenable(effects.fPathEffect); }
        if (effects.fMaskFilter) { effectBuffer->writeFlattenable(effects.fMaskFilter); }
        entryCount += 1;
        descSize += effectBuffer->bytesWritten();
    }
 
    descSize += SkDescriptor::ComputeOverhead(entryCount);
    return descSize;
}

compute_mask_format()

static SkMask::Format compute_mask_format ( const SkFont &  font )

static

Definition at line 1011 of file SkScalerContext.cpp.

                                                            {
    switch (font.getEdging()) {
        case SkFont::Edging::kAlias:
            return SkMask::kBW_Format;
        case SkFont::Edging::kAntiAlias:
            return SkMask::kA8_Format;
        case SkFont::Edging::kSubpixelAntiAlias:
            return SkMask::kLCD16_Format;
    }
    SkASSERT(false);
    return SkMask::kA8_Format;
}

convert_8_to_1()

static int convert_8_to_1 ( unsigned  byte )

inlinestatic

Definition at line 444 of file SkScalerContext.cpp.

                                                {
    SkASSERT(byte <= 0xFF);
    return byte >> 7;
}

generate_descriptor()

static void generate_descriptor ( const SkScalerContextRec &  rec, const SkBinaryWriteBuffer &  effectBuffer, SkDescriptor *  desc  )

static

Definition at line 1222 of file SkScalerContext.cpp.

                                                    {
    desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
 
    if (effectBuffer.bytesWritten() > 0) {
        effectBuffer.writeToMemory(desc->addEntry(kEffects_SkDescriptorTag,
                                                  effectBuffer.bytesWritten(),
                                                  nullptr));
    }
 
    desc->computeChecksum();
}

mask_gamma_cache_mutex()

static SkMutex & mask_gamma_cache_mutex ( )

static

In order to call cachedDeviceLuminance, cachedPaintLuminance, or cachedMaskGamma the caller must hold the mask_gamma_cache_mutex and continue to hold it until the returned pointer is refed or forgotten.

Definition at line 114 of file SkScalerContext.cpp.

                                         {
    static SkMutex& mutex = *(new SkMutex);
    return mutex;
}

pack4xHToMask()

static void pack4xHToMask ( const SkPixmap &  src, SkMaskBuilder &  dst, const SkMaskGamma::PreBlend &  maskPreBlend, const bool  doBGR, const bool  doVert  )

static

Definition at line 324 of file SkScalerContext.cpp.

                                                               {
#define SAMPLES_PER_PIXEL 4
#define LCD_PER_PIXEL 3
    SkASSERT(kAlpha_8_SkColorType == src.colorType());
 
    const bool toA8 = SkMask::kA8_Format == dst.fFormat;
    SkASSERT(SkMask::kLCD16_Format == dst.fFormat || toA8);
 
    // doVert in this function means swap x and y when writing to dst.
    if (doVert) {
        SkASSERT(src.width() == (dst.fBounds.height() - 2) * 4);
        SkASSERT(src.height() == dst.fBounds.width());
    } else {
        SkASSERT(src.width() == (dst.fBounds.width() - 2) * 4);
        SkASSERT(src.height() == dst.fBounds.height());
    }
 
    const int sample_width = src.width();
    const int height = src.height();
 
    uint8_t* dstImage = dst.image();
    size_t dstRB = dst.fRowBytes;
    // An N tap FIR is defined by
    // out[n] = coeff[0]*x[n] + coeff[1]*x[n-1] + ... + coeff[N]*x[n-N]
    // or
    // out[n] = sum(i, 0, N, coeff[i]*x[n-i])
 
    // The strategy is to use one FIR (different coefficients) for each of r, g, and b.
    // This means using every 4th FIR output value of each FIR and discarding the rest.
    // The FIRs are aligned, and the coefficients reach 5 samples to each side of their 'center'.
    // (For r and b this is technically incorrect, but the coeffs outside round to zero anyway.)
 
    // These are in some fixed point repesentation.
    // Adding up to more than one simulates ink spread.
    // For implementation reasons, these should never add up to more than two.
 
    // Coefficients determined by a gausian where 5 samples = 3 std deviations (0x110 'contrast').
    // Calculated using tools/generate_fir_coeff.py
    // With this one almost no fringing is ever seen, but it is imperceptibly blurry.
    // The lcd smoothed text is almost imperceptibly different from gray,
    // but is still sharper on small stems and small rounded corners than gray.
    // This also seems to be about as wide as one can get and only have a three pixel kernel.
    // TODO: calculate these at runtime so parameters can be adjusted (esp contrast).
    static const unsigned int coefficients[LCD_PER_PIXEL][SAMPLES_PER_PIXEL*3] = {
        //The red subpixel is centered inside the first sample (at 1/6 pixel), and is shifted.
        { 0x03, 0x0b, 0x1c, 0x33,  0x40, 0x39, 0x24, 0x10,  0x05, 0x01, 0x00, 0x00, },
        //The green subpixel is centered between two samples (at 1/2 pixel), so is symetric
        { 0x00, 0x02, 0x08, 0x16,  0x2b, 0x3d, 0x3d, 0x2b,  0x16, 0x08, 0x02, 0x00, },
        //The blue subpixel is centered inside the last sample (at 5/6 pixel), and is shifted.
        { 0x00, 0x00, 0x01, 0x05,  0x10, 0x24, 0x39, 0x40,  0x33, 0x1c, 0x0b, 0x03, },
    };
 
    size_t dstPB = toA8 ? sizeof(uint8_t) : sizeof(uint16_t);
    for (int y = 0; y < height; ++y) {
        uint8_t* dstP;
        size_t dstPDelta;
        if (doVert) {
            dstP = SkTAddOffset<uint8_t>(dstImage, y * dstPB);
            dstPDelta = dstRB;
        } else {
            dstP = SkTAddOffset<uint8_t>(dstImage, y * dstRB);
            dstPDelta = dstPB;
        }
 
        const uint8_t* srcP = src.addr8(0, y);
 
        // TODO: this fir filter implementation is straight forward, but slow.
        // It should be possible to make it much faster.
        for (int sample_x = -4; sample_x < sample_width + 4; sample_x += 4) {
            int fir[LCD_PER_PIXEL] = { 0 };
            for (int sample_index = std::max(0, sample_x - 4), coeff_index = sample_index - (sample_x - 4)
                ; sample_index < std::min(sample_x + 8, sample_width)
                ; ++sample_index, ++coeff_index)
            {
                int sample_value = srcP[sample_index];
                for (int subpxl_index = 0; subpxl_index < LCD_PER_PIXEL; ++subpxl_index) {
                    fir[subpxl_index] += coefficients[subpxl_index][coeff_index] * sample_value;
                }
            }
            for (int subpxl_index = 0; subpxl_index < LCD_PER_PIXEL; ++subpxl_index) {
                fir[subpxl_index] /= 0x100;
                fir[subpxl_index] = std::min(fir[subpxl_index], 255);
            }
 
            U8CPU r, g, b;
            if (doBGR) {
                r = fir[2];
                g = fir[1];
                b = fir[0];
            } else {
                r = fir[0];
                g = fir[1];
                b = fir[2];
            }
            if constexpr (kSkShowTextBlitCoverage) {
                r = std::max(r, 10u);
                g = std::max(g, 10u);
                b = std::max(b, 10u);
            }
            if (toA8) {
                U8CPU a = (r + g + b) / 3;
                if (maskPreBlend.isApplicable()) {
                    a = maskPreBlend.fG[a];
                }
                *dstP = a;
            } else {
                if (maskPreBlend.isApplicable()) {
                    r = maskPreBlend.fR[r];
                    g = maskPreBlend.fG[g];
                    b = maskPreBlend.fB[b];
                }
                *(uint16_t*)dstP = SkPack888ToRGB16(r, g, b);
            }
            dstP = SkTAddOffset<uint8_t>(dstP, dstPDelta);
        }
    }
}

pack_8_to_1()

static uint8_t pack_8_to_1 ( const uint8_t  alpha[8] )

static

Definition at line 449 of file SkScalerContext.cpp.

                                                   {
    unsigned bits = 0;
    for (int i = 0; i < 8; ++i) {
        bits <<= 1;
        bits |= convert_8_to_1(alpha[i]);
    }
    return SkToU8(bits);
}

packA8ToA1()

static void packA8ToA1 ( SkMaskBuilder &  dstMask, const uint8_t *  src, size_t  srcRB  )

static

Definition at line 458 of file SkScalerContext.cpp.

                                                                                 {
    const int height = dstMask.fBounds.height();
    const int width = dstMask.fBounds.width();
    const int octs = width >> 3;
    const int leftOverBits = width & 7;
 
    uint8_t* dst = dstMask.image();
    const int dstPad = dstMask.fRowBytes - SkAlign8(width)/8;
    SkASSERT(dstPad >= 0);
 
    SkASSERT(width >= 0);
    SkASSERT(srcRB >= (size_t)width);
    const size_t srcPad = srcRB - width;
 
    for (int y = 0; y < height; ++y) {
        for (int i = 0; i < octs; ++i) {
            *dst++ = pack_8_to_1(src);
            src += 8;
        }
        if (leftOverBits > 0) {
            unsigned bits = 0;
            int shift = 7;
            for (int i = 0; i < leftOverBits; ++i, --shift) {
                bits |= convert_8_to_1(*src++) << shift;
            }
            *dst++ = bits;
        }
        src += srcPad;
        dst += dstPad;
    }
}

sk_relax()

static SkScalar sk_relax ( SkScalar  x )

static

Definition at line 1006 of file SkScalerContext.cpp.

                                     {
    SkScalar n = SkScalarRoundToScalar(x * 1024);
    return n / 1024.0f;
}

sk_saturate_cast()

template<typename D , typename S >

static constexpr D sk_saturate_cast ( S  s )

staticconstexpr

Return the closest D for the given S. Returns std::numeric_limits<D>::max() for NaN.

Definition at line 198 of file SkScalerContext.cpp.

                                                                           {
    static_assert(std::is_integral_v<D>);
    s = s < std::numeric_limits<D>::max() ? s : std::numeric_limits<D>::max();
    s = s > std::numeric_limits<D>::min() ? s : std::numeric_limits<D>::min();
    return (D)s;
}

too_big_for_lcd()

static bool too_big_for_lcd ( const SkScalerContextRec &  rec, bool  checkPost2x2  )

static

Definition at line 1032 of file SkScalerContext.cpp.

                                                                              {
    if (checkPost2x2) {
        SkScalar area = rec.fPost2x2[0][0] * rec.fPost2x2[1][1] -
                        rec.fPost2x2[1][0] * rec.fPost2x2[0][1];
        area *= rec.fTextSize * rec.fTextSize;
        return area > gMaxSize2ForLCDText;
    } else {
        return rec.fTextSize > SK_MAX_SIZE_FOR_LCDTEXT;
    }
}

Variable Documentation

gContrast

SkScalar gContrast = SK_ScalarMin

static

Definition at line 121 of file SkScalerContext.cpp.

gDeviceGamma

SkScalar gDeviceGamma = SK_ScalarMin

static

Definition at line 123 of file SkScalerContext.cpp.

gLinearMaskGamma

SkMaskGamma* gLinearMaskGamma = nullptr

static

Definition at line 119 of file SkScalerContext.cpp.

gMaskGamma

SkMaskGamma* gMaskGamma = nullptr

static

Definition at line 120 of file SkScalerContext.cpp.

gMaxSize2ForLCDText

const SkScalar gMaxSize2ForLCDText = SK_MAX_SIZE_FOR_LCDTEXT * SK_MAX_SIZE_FOR_LCDTEXT

Definition at line 1030 of file SkScalerContext.cpp.

gPaintGamma

SkScalar gPaintGamma = SK_ScalarMin

static

Definition at line 122 of file SkScalerContext.cpp.