SkScalerContextFTUtils Struct Reference

#include <SkFontHost_FreeType_common.h>

Public Types
using	LoadGlyphFlags = uint32_t

Public Member Functions
void	init (SkColor fgColor, SkScalerContext::Flags)
bool	isSubpixel () const
bool	isLinearMetrics () const
bool	drawCOLRv0Glyph (FT_Face, const SkGlyph &, LoadGlyphFlags, SkSpan< SkColor > palette, SkCanvas *) const
bool	drawCOLRv1Glyph (FT_Face, const SkGlyph &, LoadGlyphFlags, SkSpan< SkColor > palette, SkCanvas *) const
bool	drawSVGGlyph (FT_Face, const SkGlyph &, LoadGlyphFlags, SkSpan< SkColor > palette, SkCanvas *) const
void	generateGlyphImage (FT_Face, const SkGlyph &, void *, const SkMatrix &bitmapTransform, const SkMaskGamma::PreBlend &) const
bool	generateGlyphPath (FT_Face, SkPath *) const

Static Public Member Functions
static bool	computeColrV1GlyphBoundingBox (FT_Face, SkGlyphID, SkRect *bounds)

Public Attributes
SkColor	fForegroundColor
SkScalerContext::Flags	fFlags

Detailed Description

Definition at line 34 of file SkFontHost_FreeType_common.h.

Member Typedef Documentation

LoadGlyphFlags

using SkScalerContextFTUtils::LoadGlyphFlags = uint32_t

Definition at line 38 of file SkFontHost_FreeType_common.h.

Member Function Documentation

computeColrV1GlyphBoundingBox()

static bool SkScalerContextFTUtils::computeColrV1GlyphBoundingBox ( FT_Face  , SkGlyphID  , SkRect *  bounds  )

static

Computes a bounding box for a COLRv1 glyph.

This method may change the configured size and transforms on FT_Face. Make sure to configure size, matrix and load glyphs as needed after using this function to restore the state of FT_Face.

drawCOLRv0Glyph()

bool SkScalerContextFTUtils::drawCOLRv0Glyph	(	FT_Face	,
		const SkGlyph &	,
		LoadGlyphFlags	,
		SkSpan< SkColor >	palette,
		SkCanvas *
	)		const

drawCOLRv1Glyph()

bool SkScalerContextFTUtils::drawCOLRv1Glyph	(	FT_Face	,
		const SkGlyph &	,
		LoadGlyphFlags	,
		SkSpan< SkColor >	palette,
		SkCanvas *
	)		const

drawSVGGlyph()

bool SkScalerContextFTUtils::drawSVGGlyph	(	FT_Face	,
		const SkGlyph &	,
		LoadGlyphFlags	,
		SkSpan< SkColor >	palette,
		SkCanvas *
	)		const

generateGlyphImage()

void SkScalerContextFTUtils::generateGlyphImage	(	FT_Face	face,
		const SkGlyph &	glyph,
		void *	imageBuffer,
		const SkMatrix &	bitmapTransform,
		const SkMaskGamma::PreBlend &	preBlend
	)		const

Definition at line 1647 of file SkFontHost_FreeType_common.cpp.

                                                                                           {
    switch ( face->glyph->format ) {
        case FT_GLYPH_FORMAT_OUTLINE: {
            FT_Outline* outline = &face->glyph->outline;
 
            int dx = 0, dy = 0;
            if (this->isSubpixel()) {
                dx = SkFixedToFDot6(glyph.getSubXFixed());
                dy = SkFixedToFDot6(glyph.getSubYFixed());
                // negate dy since freetype-y-goes-up and skia-y-goes-down
                dy = -dy;
            }
 
            memset(imageBuffer, 0, glyph.rowBytes() * glyph.height());
 
            if (SkMask::kLCD16_Format == glyph.maskFormat()) {
                const bool doBGR = SkToBool(fFlags & SkScalerContext::kLCD_BGROrder_Flag);
                const bool doVert = SkToBool(fFlags & SkScalerContext::kLCD_Vertical_Flag);
 
                FT_Outline_Translate(outline, dx, dy);
                FT_Error err = FT_Render_Glyph(face->glyph, doVert ? FT_RENDER_MODE_LCD_V :
                                                                     FT_RENDER_MODE_LCD);
                if (err) {
                    SK_TRACEFTR(err, "Could not render glyph %p.", face->glyph);
                    return;
                }
 
                SkMaskBuilder mask(static_cast<uint8_t*>(imageBuffer),
                                   glyph.iRect(), glyph.rowBytes(), glyph.maskFormat());
 
                if constexpr (kSkShowTextBlitCoverage) {
                    memset(mask.image(), 0x80, mask.fBounds.height() * mask.fRowBytes);
                }
                FT_GlyphSlotRec& ftGlyph = *face->glyph;
 
                if (!SkIRect::Intersects(mask.fBounds,
                                         SkIRect::MakeXYWH( ftGlyph.bitmap_left,
                                                           -ftGlyph.bitmap_top,
                                                            ftGlyph.bitmap.width,
                                                            ftGlyph.bitmap.rows)))
                {
                    return;
                }
 
                // If the FT_Bitmap extent is larger, discard bits of the bitmap outside the mask.
                // If the SkMask extent is larger, shrink mask to fit bitmap (clearing discarded).
                unsigned char* origBuffer = ftGlyph.bitmap.buffer;
                // First align the top left (origin).
                if (-ftGlyph.bitmap_top < mask.fBounds.fTop) {
                    int32_t topDiff = mask.fBounds.fTop - (-ftGlyph.bitmap_top);
                    ftGlyph.bitmap.buffer += ftGlyph.bitmap.pitch * topDiff;
                    ftGlyph.bitmap.rows -= topDiff;
                    ftGlyph.bitmap_top = -mask.fBounds.fTop;
                }
                if (ftGlyph.bitmap_left < mask.fBounds.fLeft) {
                    int32_t leftDiff = mask.fBounds.fLeft - ftGlyph.bitmap_left;
                    ftGlyph.bitmap.buffer += leftDiff;
                    ftGlyph.bitmap.width -= leftDiff;
                    ftGlyph.bitmap_left = mask.fBounds.fLeft;
                }
                if (mask.fBounds.fTop < -ftGlyph.bitmap_top) {
                    mask.image() += mask.fRowBytes * (-ftGlyph.bitmap_top - mask.fBounds.fTop);
                    mask.bounds().fTop = -ftGlyph.bitmap_top;
                }
                if (mask.fBounds.fLeft < ftGlyph.bitmap_left) {
                    mask.image() += sizeof(uint16_t) * (ftGlyph.bitmap_left - mask.fBounds.fLeft);
                    mask.bounds().fLeft = ftGlyph.bitmap_left;
                }
                // Origins aligned, clean up the width and height.
                int ftVertScale = (doVert ? 3 : 1);
                int ftHoriScale = (doVert ? 1 : 3);
                if (mask.fBounds.height() * ftVertScale < SkToInt(ftGlyph.bitmap.rows)) {
                    ftGlyph.bitmap.rows = mask.fBounds.height() * ftVertScale;
                }
                if (mask.fBounds.width() * ftHoriScale < SkToInt(ftGlyph.bitmap.width)) {
                    ftGlyph.bitmap.width = mask.fBounds.width() * ftHoriScale;
                }
                if (SkToInt(ftGlyph.bitmap.rows) < mask.fBounds.height() * ftVertScale) {
                    mask.bounds().fBottom = mask.fBounds.fTop + ftGlyph.bitmap.rows / ftVertScale;
                }
                if (SkToInt(ftGlyph.bitmap.width) < mask.fBounds.width() * ftHoriScale) {
                    mask.bounds().fRight = mask.fBounds.fLeft + ftGlyph.bitmap.width / ftHoriScale;
                }
                if (preBlend.isApplicable()) {
                    copyFT2LCD16<true>(ftGlyph.bitmap, &mask, doBGR,
                                       preBlend.fR, preBlend.fG, preBlend.fB);
                } else {
                    copyFT2LCD16<false>(ftGlyph.bitmap, &mask, doBGR,
                                        preBlend.fR, preBlend.fG, preBlend.fB);
                }
                // Restore the buffer pointer so FreeType can properly free it.
                ftGlyph.bitmap.buffer = origBuffer;
            } else {
                FT_BBox     bbox;
                FT_Bitmap   target;
                FT_Outline_Get_CBox(outline, &bbox);
                /*
                    what we really want to do for subpixel is
                        offset(dx, dy)
                        compute_bounds
                        offset(bbox & !63)
                    but that is two calls to offset, so we do the following, which
                    achieves the same thing with only one offset call.
                */
                FT_Outline_Translate(outline, dx - ((bbox.xMin + dx) & ~63),
                                              dy - ((bbox.yMin + dy) & ~63));
 
                target.width = glyph.width();
                target.rows = glyph.height();
                target.pitch = glyph.rowBytes();
                target.buffer = static_cast<uint8_t*>(imageBuffer);
                target.pixel_mode = compute_pixel_mode(glyph.maskFormat());
                target.num_grays = 256;
 
                FT_Outline_Get_Bitmap(face->glyph->library, outline, &target);
                if constexpr (kSkShowTextBlitCoverage) {
                    if (glyph.maskFormat() == SkMask::kBW_Format) {
                        for (unsigned y = 0; y < target.rows; y += 2) {
                            for (unsigned x = (y & 0x2); x < target.width; x+=4) {
                                uint8_t& b = target.buffer[(target.pitch * y) + (x >> 3)];
                                b = b ^ (1 << (0x7 - (x & 0x7)));
                            }
                        }
                    } else {
                        for (unsigned y = 0; y < target.rows; ++y) {
                            for (unsigned x = 0; x < target.width; ++x) {
                                uint8_t& a = target.buffer[(target.pitch * y) + x];
                                a = std::max<uint8_t>(a, 0x20);
                            }
                        }
                    }
                }
            }
        } break;
 
        case FT_GLYPH_FORMAT_BITMAP: {
            FT_Pixel_Mode pixel_mode = static_cast<FT_Pixel_Mode>(face->glyph->bitmap.pixel_mode);
            SkMask::Format maskFormat = glyph.maskFormat();
 
            // Assume that the other formats do not exist.
            SkASSERT(FT_PIXEL_MODE_MONO == pixel_mode ||
                     FT_PIXEL_MODE_GRAY == pixel_mode ||
                     FT_PIXEL_MODE_BGRA == pixel_mode);
 
            // These are the only formats this ScalerContext should request.
            SkASSERT(SkMask::kBW_Format == maskFormat ||
                     SkMask::kA8_Format == maskFormat ||
                     SkMask::kARGB32_Format == maskFormat ||
                     SkMask::kLCD16_Format == maskFormat);
 
            // If no scaling needed, directly copy glyph bitmap.
            if (bitmapTransform.isIdentity()) {
                SkMaskBuilder dstMask = SkMaskBuilder(static_cast<uint8_t*>(imageBuffer),
                                                      glyph.iRect(), glyph.rowBytes(),
                                                      glyph.maskFormat());
                copyFTBitmap(face->glyph->bitmap, &dstMask);
                break;
            }
 
            // Otherwise, scale the bitmap.
 
            // Copy the FT_Bitmap into an SkBitmap (either A8 or ARGB)
            SkBitmap unscaledBitmap;
            // TODO: mark this as sRGB when the blits will be sRGB.
            unscaledBitmap.setInfo(SkImageInfo::Make(face->glyph->bitmap.width,
                                                     face->glyph->bitmap.rows,
                                                     SkColorType_for_FTPixelMode(pixel_mode),
                                                     kPremul_SkAlphaType));
            if (!unscaledBitmap.tryAllocPixels()) {
                // TODO: set the imageBuffer to indicate "missing"
                memset(imageBuffer, 0, glyph.rowBytes() * glyph.height());
                return;
            }
 
            SkMaskBuilder unscaledBitmapAlias(
                reinterpret_cast<uint8_t*>(unscaledBitmap.getPixels()),
                SkIRect::MakeWH(unscaledBitmap.width(), unscaledBitmap.height()),
                unscaledBitmap.rowBytes(),
                SkMaskFormat_for_SkColorType(unscaledBitmap.colorType()));
            copyFTBitmap(face->glyph->bitmap, &unscaledBitmapAlias);
 
            // Wrap the glyph's mask in a bitmap, unless the glyph's mask is BW or LCD.
            // BW requires an A8 target for resizing, which can then be down sampled.
            // LCD should use a 4x A8 target, which will then be down sampled.
            // For simplicity, LCD uses A8 and is replicated.
            int bitmapRowBytes = 0;
            if (SkMask::kBW_Format != maskFormat && SkMask::kLCD16_Format != maskFormat) {
                bitmapRowBytes = glyph.rowBytes();
            }
            SkBitmap dstBitmap;
            // TODO: mark this as sRGB when the blits will be sRGB.
            dstBitmap.setInfo(SkImageInfo::Make(glyph.width(), glyph.height(),
                                                SkColorType_for_SkMaskFormat(maskFormat),
                                                kPremul_SkAlphaType),
                              bitmapRowBytes);
            if (SkMask::kBW_Format == maskFormat || SkMask::kLCD16_Format == maskFormat) {
                if (!dstBitmap.tryAllocPixels()) {
                    // TODO: set the fImage to indicate "missing"
                    memset(imageBuffer, 0, glyph.rowBytes() * glyph.height());
                    return;
                }
            } else {
                dstBitmap.setPixels(imageBuffer);
            }
 
            // Scale unscaledBitmap into dstBitmap.
            SkCanvas canvas(dstBitmap);
            if constexpr (kSkShowTextBlitCoverage) {
                canvas.clear(0x33FF0000);
            } else {
                canvas.clear(SK_ColorTRANSPARENT);
            }
            canvas.translate(-glyph.left(), -glyph.top());
            canvas.concat(bitmapTransform);
            canvas.translate(face->glyph->bitmap_left, -face->glyph->bitmap_top);
 
            SkSamplingOptions sampling(SkFilterMode::kLinear, SkMipmapMode::kNearest);
            canvas.drawImage(unscaledBitmap.asImage().get(), 0, 0, sampling, nullptr);
 
            // If the destination is BW or LCD, convert from A8.
            if (SkMask::kBW_Format == maskFormat) {
                // Copy the A8 dstBitmap into the A1 imageBuffer.
                SkMaskBuilder dstMask(static_cast<uint8_t*>(imageBuffer),
                                      glyph.iRect(), glyph.rowBytes(), glyph.maskFormat());
                packA8ToA1(&dstMask, dstBitmap.getAddr8(0, 0), dstBitmap.rowBytes());
            } else if (SkMask::kLCD16_Format == maskFormat) {
                // Copy the A8 dstBitmap into the LCD16 imageBuffer.
                uint8_t* src = dstBitmap.getAddr8(0, 0);
                uint16_t* dst = reinterpret_cast<uint16_t*>(imageBuffer);
                for (int y = dstBitmap.height(); y --> 0;) {
                    for (int x = 0; x < dstBitmap.width(); ++x) {
                        dst[x] = grayToRGB16(src[x]);
                    }
                    dst = (uint16_t*)((char*)dst + glyph.rowBytes());
                    src += dstBitmap.rowBytes();
                }
            }
        } break;
 
        default:
            SkDEBUGFAIL("unknown glyph format");
            memset(imageBuffer, 0, glyph.rowBytes() * glyph.height());
            return;
    }
 
// We used to always do this pre-USE_COLOR_LUMINANCE, but with colorlum,
// it is optional
#if defined(SK_GAMMA_APPLY_TO_A8)
    if (SkMask::kA8_Format == glyph.maskFormat() && preBlend.isApplicable()) {
        uint8_t* SK_RESTRICT dst = (uint8_t*)imageBuffer;
        unsigned rowBytes = glyph.rowBytes();
 
        for (int y = glyph.height() - 1; y >= 0; --y) {
            for (int x = glyph.width() - 1; x >= 0; --x) {
                dst[x] = preBlend.fG[dst[x]];
            }
            dst += rowBytes;
        }
    }
#endif
}

generateGlyphPath()

bool SkScalerContextFTUtils::generateGlyphPath	(	FT_Face	face,
		SkPath *	path
	)		const

Definition at line 2076 of file SkFontHost_FreeType_common.cpp.

                                                                               {
    if (!generateGlyphPathStatic(face, path)) {
        return false;
    }
    if (face->glyph->outline.flags & FT_OUTLINE_OVERLAP) {
        Simplify(*path, path);
        // Simplify will return an even-odd path.
        // A stroke+fill (for fake bold) may be incorrect for even-odd.
        // https://github.com/flutter/flutter/issues/112546
        AsWinding(*path, path);
    }
    return true;
}

init()

void SkScalerContextFTUtils::init	(	SkColor	fgColor,
		SkScalerContext::Flags	flags
	)

Definition at line 1560 of file SkFontHost_FreeType_common.cpp.

                                                                             {
    fForegroundColor = fgColor;
    fFlags = flags;
}

isLinearMetrics()

bool SkScalerContextFTUtils::isLinearMetrics ( ) const

inline

Definition at line 46 of file SkFontHost_FreeType_common.h.

                                 {
        return SkToBool(fFlags & SkScalerContext::kLinearMetrics_Flag);
    }

isSubpixel()

bool SkScalerContextFTUtils::isSubpixel ( ) const

inline

Definition at line 42 of file SkFontHost_FreeType_common.h.

                            {
        return SkToBool(fFlags & SkScalerContext::kSubpixelPositioning_Flag);
    }

Member Data Documentation

fFlags

SkScalerContext::Flags SkScalerContextFTUtils::fFlags

Definition at line 36 of file SkFontHost_FreeType_common.h.

fForegroundColor

SkColor SkScalerContextFTUtils::fForegroundColor

Definition at line 35 of file SkFontHost_FreeType_common.h.

---

The documentation for this struct was generated from the following files:

• third_party/skia/src/ports/SkFontHost_FreeType_common.h
• third_party/skia/src/ports/SkFontHost_FreeType_common.cpp