#include <SkScalerContext.h>

Inheritance diagram for SkScalerContext:

Classes
struct	GlyphMetrics

Public Types
enum	Flags { kFrameAndFill_Flag = 0x0001 , kUnused = 0x0002 , kEmbeddedBitmapText_Flag = 0x0004 , kEmbolden_Flag = 0x0008 , kSubpixelPositioning_Flag = 0x0010 , kForceAutohinting_Flag = 0x0020 , kHinting_Shift = 7 , kHintingBit1_Flag = 0x0080 , kHintingBit2_Flag = 0x0100 , kLCD_Vertical_Flag = 0x0200 , kLCD_BGROrder_Flag = 0x0400 , kGenA8FromLCD_Flag = 0x0800 , kLinearMetrics_Flag = 0x1000 , kBaselineSnap_Flag = 0x2000 , kNeedsForegroundColor_Flag = 0x4000 }

enum	{ kHinting_Mask = kHintingBit1_Flag \| kHintingBit2_Flag }

Public Member Functions
	SkScalerContext (sk_sp< SkTypeface >, const SkScalerContextEffects &, const SkDescriptor *)

virtual	~SkScalerContext ()

SkTypeface *	getTypeface () const

SkMask::Format	getMaskFormat () const

bool	isSubpixel () const

bool	isLinearMetrics () const

bool	isVertical () const

SkGlyph	makeGlyph (SkPackedGlyphID, SkArenaAlloc *)

void	getImage (const SkGlyph &)

void	getPath (SkGlyph &, SkArenaAlloc *)

sk_sp< SkDrawable >	getDrawable (SkGlyph &)

void	getFontMetrics (SkFontMetrics *)

const SkScalerContextRec &	getRec () const

SkScalerContextEffects	getEffects () const

SkAxisAlignment	computeAxisAlignmentForHText () const

Static Public Member Functions
static size_t	GetGammaLUTSize (SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma, int width, int height)

static bool	GetGammaLUTData (SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma, uint8_t *data)

static void	MakeRecAndEffects (const SkFont &font, const SkPaint &paint, const SkSurfaceProps &surfaceProps, SkScalerContextFlags scalerContextFlags, const SkMatrix &deviceMatrix, SkScalerContextRec rec, SkScalerContextEffects effects)

static void	MakeRecAndEffectsFromFont (const SkFont &font, SkScalerContextRec rec, SkScalerContextEffects effects)

static std::unique_ptr< SkScalerContext >	MakeEmpty (sk_sp< SkTypeface > typeface, const SkScalerContextEffects &effects, const SkDescriptor *desc)

static SkDescriptor *	AutoDescriptorGivenRecAndEffects (const SkScalerContextRec &rec, const SkScalerContextEffects &effects, SkAutoDescriptor *ad)

static std::unique_ptr< SkDescriptor >	DescriptorGivenRecAndEffects (const SkScalerContextRec &rec, const SkScalerContextEffects &effects)

static void	DescriptorBufferGiveRec (const SkScalerContextRec &rec, void *buffer)

static bool	CheckBufferSizeForRec (const SkScalerContextRec &rec, const SkScalerContextEffects &effects, size_t size)

static SkMaskGamma::PreBlend	GetMaskPreBlend (const SkScalerContextRec &rec)

static SkDescriptor *	CreateDescriptorAndEffectsUsingPaint (const SkFont &, const SkPaint &, const SkSurfaceProps &, SkScalerContextFlags scalerContextFlags, const SkMatrix &deviceMatrix, SkAutoDescriptor ad, SkScalerContextEffects effects)

Protected Member Functions
virtual GlyphMetrics	generateMetrics (const SkGlyph &, SkArenaAlloc *)=0

virtual void	generateImage (const SkGlyph &glyph, void *imageBuffer)=0

virtual bool	generatePath (const SkGlyph &, SkPath *)=0

virtual sk_sp< SkDrawable >	generateDrawable (const SkGlyph &)

virtual void	generateFontMetrics (SkFontMetrics *)=0

void	forceGenerateImageFromPath ()

void	forceOffGenerateImageFromPath ()

Static Protected Member Functions
static void	GenerateMetricsFromPath (SkGlyph *glyph, const SkPath &path, SkMask::Format format, bool verticalLCD, bool a8FromLCD, bool hairline)

static void	SaturateGlyphBounds (SkGlyph *glyph, SkRect &&)

static void	SaturateGlyphBounds (SkGlyph *glyph, SkIRect const &)

static void	GenerateImageFromPath (SkMaskBuilder &dst, const SkPath &path, const SkMaskGamma::PreBlend &maskPreBlend, bool doBGR, bool verticalLCD, bool a8FromLCD, bool hairline)

Protected Attributes
SkScalerContextRec	fRec

const SkMaskGamma::PreBlend	fPreBlend

Friends
class	PathText

class	PathTextBench

class	RandomScalerContext

Detailed Description

Definition at line 249 of file SkScalerContext.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
kHinting_Mask

Definition at line 280 of file SkScalerContext.h.

         {
        kHinting_Mask   = kHintingBit1_Flag | kHintingBit2_Flag,
    };

◆ Flags

enum SkScalerContext::Flags

Enumerator
kFrameAndFill_Flag
kUnused
kEmbeddedBitmapText_Flag
kEmbolden_Flag
kSubpixelPositioning_Flag
kForceAutohinting_Flag
kHinting_Shift
kHintingBit1_Flag
kHintingBit2_Flag
kLCD_Vertical_Flag
kLCD_BGROrder_Flag
kGenA8FromLCD_Flag
kLinearMetrics_Flag
kBaselineSnap_Flag
kNeedsForegroundColor_Flag

Definition at line 251 of file SkScalerContext.h.

               {
        kFrameAndFill_Flag        = 0x0001,
        kUnused                   = 0x0002,
        kEmbeddedBitmapText_Flag  = 0x0004,
        kEmbolden_Flag            = 0x0008,
        kSubpixelPositioning_Flag = 0x0010,
        kForceAutohinting_Flag    = 0x0020,  // Use auto instead of bytcode hinting if hinting.
 
        // together, these two flags resulting in a two bit value which matches
        // up with the SkPaint::Hinting enum.
        kHinting_Shift            = 7, // to shift into the other flags above
        kHintingBit1_Flag         = 0x0080,
        kHintingBit2_Flag         = 0x0100,
 
        // Pixel geometry information.
        // only meaningful if fMaskFormat is kLCD16
        kLCD_Vertical_Flag        = 0x0200,    // else Horizontal
        kLCD_BGROrder_Flag        = 0x0400,    // else RGB order
 
        // Generate A8 from LCD source (for GDI and CoreGraphics).
        // only meaningful if fMaskFormat is kA8
        kGenA8FromLCD_Flag        = 0x0800, // could be 0x200 (bit meaning dependent on fMaskFormat)
        kLinearMetrics_Flag       = 0x1000,
        kBaselineSnap_Flag        = 0x2000,
 
        kNeedsForegroundColor_Flag = 0x4000,
    };

Constructor & Destructor Documentation

◆ SkScalerContext()

SkScalerContext::SkScalerContext	(	sk_sp< SkTypeface >	typeface,
		const SkScalerContextEffects &	effects,
		const SkDescriptor *	desc
	)

Definition at line 88 of file SkScalerContext.cpp.

    : fRec(PreprocessRec(*typeface, effects, *desc))
    , fTypeface(std::move(typeface))
    , fPathEffect(sk_ref_sp(effects.fPathEffect))
    , fMaskFilter(sk_ref_sp(effects.fMaskFilter))
      // Initialize based on our settings. Subclasses can also force this.
    , fGenerateImageFromPath(fRec.fFrameWidth >= 0 || fPathEffect != nullptr)
 
    , fPreBlend(fMaskFilter ? SkMaskGamma::PreBlend() : SkScalerContext::GetMaskPreBlend(fRec))
{
    if constexpr (kSkScalerContextDumpRec) {
        SkDebugf("SkScalerContext checksum %x count %u length %u\n",
                 desc->getChecksum(), desc->getCount(), desc->getLength());
        SkDebugf("%s", fRec.dump().c_str());
        SkDebugf("  effects %p\n", desc->findEntry(kEffects_SkDescriptorTag, nullptr));
    }
}

◆ ~SkScalerContext()

SkScalerContext::~SkScalerContext ( )

virtual

Definition at line 107 of file SkScalerContext.cpp.

107{}

Member Function Documentation

◆ AutoDescriptorGivenRecAndEffects()

SkDescriptor * SkScalerContext::AutoDescriptorGivenRecAndEffects	(	const SkScalerContextRec &	rec,
		const SkScalerContextEffects &	effects,
		SkAutoDescriptor *	ad
	)

static

Definition at line 1236 of file SkScalerContext.cpp.

{
    SkBinaryWriteBuffer buf({});
 
    ad->reset(calculate_size_and_flatten(rec, effects, &buf));
    generate_descriptor(rec, buf, ad->getDesc());
 
    return ad->getDesc();
}

◆ CheckBufferSizeForRec()

bool SkScalerContext::CheckBufferSizeForRec	(	const SkScalerContextRec &	rec,
		const SkScalerContextEffects &	effects,
		size_t	size
	)

static

Definition at line 1265 of file SkScalerContext.cpp.

                                                         {
    SkBinaryWriteBuffer buf({});
    return size >= calculate_size_and_flatten(rec, effects, &buf);
}

◆ computeAxisAlignmentForHText()

SkAxisAlignment SkScalerContext::computeAxisAlignmentForHText ( ) const

Return the axis (if any) that the baseline for horizontal text should land on. As an example, the identity matrix will return SkAxisAlignment::kX.

Definition at line 969 of file SkScalerContext.cpp.

                                                                    {
    return fRec.computeAxisAlignmentForHText();
}

◆ CreateDescriptorAndEffectsUsingPaint()

SkDescriptor * SkScalerContext::CreateDescriptorAndEffectsUsingPaint	(	const SkFont &	font,
		const SkPaint &	paint,
		const SkSurfaceProps &	surfaceProps,
		SkScalerContextFlags	scalerContextFlags,
		const SkMatrix &	deviceMatrix,
		SkAutoDescriptor *	ad,
		SkScalerContextEffects *	effects
	)

static

Definition at line 1195 of file SkScalerContext.cpp.

{
    SkScalerContextRec rec;
    MakeRecAndEffects(font, paint, surfaceProps, scalerContextFlags, deviceMatrix, &rec, effects);
    return AutoDescriptorGivenRecAndEffects(rec, *effects, ad);
}

◆ DescriptorBufferGiveRec()

void SkScalerContext::DescriptorBufferGiveRec	(	const SkScalerContextRec &	rec,
		void *	buffer
	)

static

Definition at line 1261 of file SkScalerContext.cpp.

                                                                                         {
    generate_descriptor(rec, SkBinaryWriteBuffer({}), (SkDescriptor*)buffer);
}

◆ DescriptorGivenRecAndEffects()

std::unique_ptr< SkDescriptor > SkScalerContext::DescriptorGivenRecAndEffects	(	const SkScalerContextRec &	rec,
		const SkScalerContextEffects &	effects
	)

static

Definition at line 1249 of file SkScalerContext.cpp.

{
    SkBinaryWriteBuffer buf({});
 
    auto desc = SkDescriptor::Alloc(calculate_size_and_flatten(rec, effects, &buf));
    generate_descriptor(rec, buf, desc.get());
 
    return desc;
}

◆ forceGenerateImageFromPath()

void SkScalerContext::forceGenerateImageFromPath ( )

inlineprotected

Definition at line 441 of file SkScalerContext.h.

441{ fGenerateImageFromPath = true; }

◆ forceOffGenerateImageFromPath()

void SkScalerContext::forceOffGenerateImageFromPath ( )

inlineprotected

Definition at line 442 of file SkScalerContext.h.

442{ fGenerateImageFromPath = false; }

◆ generateDrawable()

sk_sp< SkDrawable > SkScalerContext::generateDrawable ( const SkGlyph & )

protectedvirtual

Returns the drawable for the glyph (if any).

The generated drawable will be lifetime scoped to the lifetime of this scaler context. This means the drawable may refer to the scaler context and associated font data.

The drawable does not need to be flattenable (e.g. implement getFactory and getTypeName). Any necessary serialization will be done with makePictureSnapshot.

Reimplemented in SkScalerContextProxy, SkScalerContext_FreeType, SkScalerContext_DW, RandomScalerContext, SkFontationsScalerContext, and SkUserScalerContext.

Definition at line 744 of file SkScalerContext.cpp.

                                                                  {
    return nullptr;
}

◆ generateFontMetrics()

virtual void SkScalerContext::generateFontMetrics ( SkFontMetrics * )

protectedpure virtual

Retrieves font metrics.

Implemented in SkScalerContext_FreeType, SkScalerContext_DW, RandomScalerContext, SkScalerContextProxy, SkUserScalerContext, SkTestScalerContext, and SkFontationsScalerContext.

◆ generateImage()

virtual void SkScalerContext::generateImage	(	const SkGlyph &	glyph,
		void *	imageBuffer
	)

protectedpure virtual

Generates the contents of glyph.fImage. When called, glyph.fImage will be pointing to a pre-allocated, uninitialized region of memory of size glyph.imageSize(). This method may not change glyph.fMaskFormat.

Because glyph.imageSize() will determine the size of fImage, generateMetrics will be called before generateImage.

Implemented in SkScalerContextProxy, SkScalerContext_FreeType, RandomScalerContext, SkTestScalerContext, SkScalerContext_DW, SkFontationsScalerContext, and SkUserScalerContext.

◆ GenerateImageFromPath()

void SkScalerContext::GenerateImageFromPath	(	SkMaskBuilder &	dst,
		const SkPath &	path,
		const SkMaskGamma::PreBlend &	maskPreBlend,
		bool	doBGR,
		bool	verticalLCD,
		bool	a8FromLCD,
		bool	hairline
	)

staticprotected

Definition at line 490 of file SkScalerContext.cpp.

{
    SkASSERT(dstMask.fFormat == SkMask::kBW_Format ||
             dstMask.fFormat == SkMask::kA8_Format ||
             dstMask.fFormat == SkMask::kLCD16_Format);
 
    SkPaint paint;
    SkPath strokePath;
    const SkPath* pathToUse = &path;
 
    int srcW = dstMask.fBounds.width();
    int srcH = dstMask.fBounds.height();
    int dstW = srcW;
    int dstH = srcH;
 
    SkMatrix matrix;
    matrix.setTranslate(-SkIntToScalar(dstMask.fBounds.fLeft),
                        -SkIntToScalar(dstMask.fBounds.fTop));
 
    paint.setStroke(hairline);
    paint.setAntiAlias(SkMask::kBW_Format != dstMask.fFormat);
 
    const bool fromLCD = (dstMask.fFormat == SkMask::kLCD16_Format) ||
                         (dstMask.fFormat == SkMask::kA8_Format && a8FromLCD);
    const bool intermediateDst = fromLCD || dstMask.fFormat == SkMask::kBW_Format;
    if (fromLCD) {
        if (verticalLCD) {
            dstW = 4*dstH - 8;
            dstH = srcW;
            matrix.setAll(0, 4, -SkIntToScalar(dstMask.fBounds.fTop + 1) * 4,
                          1, 0, -SkIntToScalar(dstMask.fBounds.fLeft),
                          0, 0, 1);
        } else {
            dstW = 4*dstW - 8;
            matrix.setAll(4, 0, -SkIntToScalar(dstMask.fBounds.fLeft + 1) * 4,
                          0, 1, -SkIntToScalar(dstMask.fBounds.fTop),
                          0, 0, 1);
        }
 
        // LCD hairline doesn't line up with the pixels, so do it the expensive way.
        SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
        if (hairline) {
            rec.setStrokeStyle(1.0f, false);
            rec.setStrokeParams(SkPaint::kButt_Cap, SkPaint::kRound_Join, 0.0f);
        }
        if (rec.needToApply() && rec.applyToPath(&strokePath, path)) {
            pathToUse = &strokePath;
            paint.setStyle(SkPaint::kFill_Style);
        }
    }
 
    SkRasterClip clip;
    clip.setRect(SkIRect::MakeWH(dstW, dstH));
 
    const SkImageInfo info = SkImageInfo::MakeA8(dstW, dstH);
    SkAutoPixmapStorage dst;
 
    if (intermediateDst) {
        if (!dst.tryAlloc(info)) {
            // can't allocate offscreen, so empty the mask and return
            sk_bzero(dstMask.image(), dstMask.computeImageSize());
            return;
        }
    } else {
        dst.reset(info, dstMask.image(), dstMask.fRowBytes);
    }
    sk_bzero(dst.writable_addr(), dst.computeByteSize());
 
    SkDrawBase  draw;
    draw.fBlitterChooser = SkA8Blitter_Choose;
    draw.fDst            = dst;
    draw.fRC             = &clip;
    draw.fCTM            = &matrix;
    draw.drawPath(*pathToUse, paint);
 
    switch (dstMask.fFormat) {
        case SkMask::kBW_Format:
            packA8ToA1(dstMask, dst.addr8(0, 0), dst.rowBytes());
            break;
        case SkMask::kA8_Format:
            if (fromLCD) {
                pack4xHToMask(dst, dstMask, maskPreBlend, doBGR, verticalLCD);
            } else if (maskPreBlend.isApplicable()) {
                applyLUTToA8Mask(dstMask, maskPreBlend.fG);
            }
            break;
        case SkMask::kLCD16_Format:
            pack4xHToMask(dst, dstMask, maskPreBlend, doBGR, verticalLCD);
            break;
        default:
            break;
    }
}

◆ generateMetrics()

virtual GlyphMetrics SkScalerContext::generateMetrics	(	const SkGlyph &	,
		SkArenaAlloc *
	)

protectedpure virtual

Implemented in SkScalerContextProxy, SkScalerContext_FreeType, SkScalerContext_DW, RandomScalerContext, SkFontationsScalerContext, SkUserScalerContext, and SkTestScalerContext.

◆ GenerateMetricsFromPath()

void SkScalerContext::GenerateMetricsFromPath	(	SkGlyph *	glyph,
		const SkPath &	path,
		SkMask::Format	format,
		bool	verticalLCD,
		bool	a8FromLCD,
		bool	hairline
	)

staticprotected

Definition at line 218 of file SkScalerContext.cpp.

{
    // Only BW, A8, and LCD16 can be produced from paths.
    if (glyph->fMaskFormat != SkMask::kBW_Format &&
        glyph->fMaskFormat != SkMask::kA8_Format &&
        glyph->fMaskFormat != SkMask::kLCD16_Format)
    {
        glyph->fMaskFormat = SkMask::kA8_Format;
    }
 
    SkRect bounds = devPath.getBounds();
    if (!bounds.isEmpty()) {
        const bool fromLCD = (glyph->fMaskFormat == SkMask::kLCD16_Format) ||
                             (glyph->fMaskFormat == SkMask::kA8_Format && a8FromLCD);
 
        const bool needExtraWidth  = (fromLCD && !verticalLCD) || hairline;
        const bool needExtraHeight = (fromLCD &&  verticalLCD) || hairline;
        if (needExtraWidth) {
            bounds.roundOut(&bounds);
            bounds.outset(1, 0);
        }
        if (needExtraHeight) {
            bounds.roundOut(&bounds);
            bounds.outset(0, 1);
        }
    }
    SaturateGlyphBounds(glyph, std::move(bounds));
}

◆ generatePath()

virtual bool SkScalerContext::generatePath	(	const SkGlyph &	,
		SkPath *
	)

protectedpure virtual

Sets the passed path to the glyph outline. If this cannot be done the path is set to empty; Does not apply subpixel positioning to the path.

Returns: false if this glyph does not have any path.

Implemented in SkScalerContext_DW, RandomScalerContext, SkScalerContextProxy, SkScalerContext_FreeType, SkFontationsScalerContext, SkUserScalerContext, and SkTestScalerContext.

◆ getDrawable()

sk_sp< SkDrawable > SkScalerContext::getDrawable ( SkGlyph & glyph )

Definition at line 740 of file SkScalerContext.cpp.

                                                             {
    return this->generateDrawable(glyph);
}

◆ getEffects()

SkScalerContextEffects SkScalerContext::getEffects ( ) const

inline

Definition at line 362 of file SkScalerContext.h.

                                              {
        return { fPathEffect.get(), fMaskFilter.get() };
    }

◆ getFontMetrics()

void SkScalerContext::getFontMetrics ( SkFontMetrics * fm )

Definition at line 748 of file SkScalerContext.cpp.

                                                      {
    SkASSERT(fm);
    this->generateFontMetrics(fm);
}

◆ GetGammaLUTData()

bool SkScalerContext::GetGammaLUTData	(	SkScalar	contrast,
		SkScalar	paintGamma,
		SkScalar	deviceGamma,
		uint8_t *	data
	)

static

Get the associated gamma lookup table. The 'data' pointer must point to pre-allocated memory, with size in bytes greater than or equal to the return value of getGammaLUTSize().

If the lookup table hasn't been initialized (e.g., it's linear), this will return false.

Definition at line 175 of file SkScalerContext.cpp.

                                                     {
    SkAutoMutexExclusive ama(mask_gamma_cache_mutex());
    const SkMaskGamma& maskGamma = cached_mask_gamma(contrast,
                                                     paintGamma,
                                                     deviceGamma);
    const uint8_t* gammaTables = maskGamma.getGammaTables();
    if (!gammaTables) {
        return false;
    }
 
    int width, height;
    maskGamma.getGammaTableDimensions(&width, &height);
    size_t size = width*height * sizeof(uint8_t);
    memcpy(data, gammaTables, size);
    return true;
}

◆ GetGammaLUTSize()

size_t SkScalerContext::GetGammaLUTSize	(	SkScalar	contrast,
		SkScalar	paintGamma,
		SkScalar	deviceGamma,
		int *	width,
		int *	height
	)

static

Return the size in bytes of the associated gamma lookup table

Definition at line 162 of file SkScalerContext.cpp.

                                                                                       {
    SkAutoMutexExclusive ama(mask_gamma_cache_mutex());
    const SkMaskGamma& maskGamma = cached_mask_gamma(contrast,
                                                     paintGamma,
                                                     deviceGamma);
 
    maskGamma.getGammaTableDimensions(width, height);
    size_t size = (*width)*(*height)*sizeof(uint8_t);
 
    return size;
}

◆ getImage()

void SkScalerContext::getImage ( const SkGlyph & origGlyph )

Definition at line 586 of file SkScalerContext.cpp.

                                                       {
    SkASSERT(origGlyph.fAdvancesBoundsFormatAndInitialPathDone);
 
    const SkGlyph* unfilteredGlyph = &origGlyph;
    // in case we need to call generateImage on a mask-format that is different
    // (i.e. larger) than what our caller allocated by looking at origGlyph.
    SkAutoMalloc tmpGlyphImageStorage;
    SkGlyph tmpGlyph;
    SkSTArenaAlloc<sizeof(SkGlyph::PathData)> tmpGlyphPathDataStorage;
    if (fMaskFilter) {
        // need the original bounds, sans our maskfilter
        sk_sp<SkMaskFilter> mf = std::move(fMaskFilter);
        tmpGlyph = this->makeGlyph(origGlyph.getPackedID(), &tmpGlyphPathDataStorage);
        fMaskFilter = std::move(mf);
 
        // Use the origGlyph storage for the temporary unfiltered mask if it will fit.
        if (tmpGlyph.fMaskFormat == origGlyph.fMaskFormat &&
            tmpGlyph.imageSize() <= origGlyph.imageSize())
        {
            tmpGlyph.fImage = origGlyph.fImage;
        } else {
            tmpGlyphImageStorage.reset(tmpGlyph.imageSize());
            tmpGlyph.fImage = tmpGlyphImageStorage.get();
        }
        unfilteredGlyph = &tmpGlyph;
    }
 
    if (!fGenerateImageFromPath) {
        generateImage(*unfilteredGlyph, unfilteredGlyph->fImage);
    } else {
        SkASSERT(origGlyph.setPathHasBeenCalled());
        const SkPath* devPath = origGlyph.path();
 
        if (!devPath) {
            generateImage(*unfilteredGlyph, unfilteredGlyph->fImage);
        } else {
            SkMaskBuilder mask(static_cast<uint8_t*>(unfilteredGlyph->fImage),
                               unfilteredGlyph->iRect(), unfilteredGlyph->rowBytes(),
                               unfilteredGlyph->maskFormat());
            SkASSERT(SkMask::kARGB32_Format != origGlyph.fMaskFormat);
            SkASSERT(SkMask::kARGB32_Format != mask.fFormat);
            const bool doBGR = SkToBool(fRec.fFlags & SkScalerContext::kLCD_BGROrder_Flag);
            const bool doVert = SkToBool(fRec.fFlags & SkScalerContext::kLCD_Vertical_Flag);
            const bool a8LCD = SkToBool(fRec.fFlags & SkScalerContext::kGenA8FromLCD_Flag);
            const bool hairline = origGlyph.pathIsHairline();
            GenerateImageFromPath(mask, *devPath, fPreBlend, doBGR, doVert, a8LCD, hairline);
        }
    }
 
    if (fMaskFilter) {
        // k3D_Format should not be mask filtered.
        SkASSERT(SkMask::k3D_Format != unfilteredGlyph->fMaskFormat);
 
        SkMaskBuilder srcMask;
        SkAutoMaskFreeImage srcMaskOwnedImage(nullptr);
        SkMatrix m;
        fRec.getMatrixFrom2x2(&m);
 
        if (as_MFB(fMaskFilter)->filterMask(&srcMask, unfilteredGlyph->mask(), m, nullptr)) {
            // Filter succeeded; srcMask.fImage was allocated.
            srcMaskOwnedImage.reset(srcMask.image());
        } else if (unfilteredGlyph->fImage == tmpGlyphImageStorage.get()) {
            // Filter did nothing; unfiltered mask is independent of origGlyph.fImage.
            srcMask = SkMaskBuilder(static_cast<uint8_t*>(unfilteredGlyph->fImage),
                                    unfilteredGlyph->iRect(), unfilteredGlyph->rowBytes(),
                                    unfilteredGlyph->maskFormat());
        } else if (origGlyph.iRect() == unfilteredGlyph->iRect()) {
            // Filter did nothing; the unfiltered mask is in origGlyph.fImage and matches.
            return;
        } else {
            // Filter did nothing; the unfiltered mask is in origGlyph.fImage and conflicts.
            srcMask = SkMaskBuilder(static_cast<uint8_t*>(unfilteredGlyph->fImage),
                                    unfilteredGlyph->iRect(), unfilteredGlyph->rowBytes(),
                                    unfilteredGlyph->maskFormat());
            size_t imageSize = unfilteredGlyph->imageSize();
            tmpGlyphImageStorage.reset(imageSize);
            srcMask.image() = static_cast<uint8_t*>(tmpGlyphImageStorage.get());
            memcpy(srcMask.image(), unfilteredGlyph->fImage, imageSize);
        }
 
        SkASSERT_RELEASE(srcMask.fFormat == origGlyph.fMaskFormat);
        SkMaskBuilder dstMask = SkMaskBuilder(static_cast<uint8_t*>(origGlyph.fImage),
                                              origGlyph.iRect(), origGlyph.rowBytes(),
                                              origGlyph.maskFormat());
        SkIRect origBounds = dstMask.fBounds;
 
        // Find the intersection of src and dst while updating the fImages.
        if (srcMask.fBounds.fTop < dstMask.fBounds.fTop) {
            int32_t topDiff = dstMask.fBounds.fTop - srcMask.fBounds.fTop;
            srcMask.image() += srcMask.fRowBytes * topDiff;
            srcMask.bounds().fTop = dstMask.fBounds.fTop;
        }
        if (dstMask.fBounds.fTop < srcMask.fBounds.fTop) {
            int32_t topDiff = srcMask.fBounds.fTop - dstMask.fBounds.fTop;
            dstMask.image() += dstMask.fRowBytes * topDiff;
            dstMask.bounds().fTop = srcMask.fBounds.fTop;
        }
 
        if (srcMask.fBounds.fLeft < dstMask.fBounds.fLeft) {
            int32_t leftDiff = dstMask.fBounds.fLeft - srcMask.fBounds.fLeft;
            srcMask.image() += leftDiff;
            srcMask.bounds().fLeft = dstMask.fBounds.fLeft;
        }
        if (dstMask.fBounds.fLeft < srcMask.fBounds.fLeft) {
            int32_t leftDiff = srcMask.fBounds.fLeft - dstMask.fBounds.fLeft;
            dstMask.image() += leftDiff;
            dstMask.bounds().fLeft = srcMask.fBounds.fLeft;
        }
 
        if (srcMask.fBounds.fBottom < dstMask.fBounds.fBottom) {
            dstMask.bounds().fBottom = srcMask.fBounds.fBottom;
        }
        if (dstMask.fBounds.fBottom < srcMask.fBounds.fBottom) {
            srcMask.bounds().fBottom = dstMask.fBounds.fBottom;
        }
 
        if (srcMask.fBounds.fRight < dstMask.fBounds.fRight) {
            dstMask.bounds().fRight = srcMask.fBounds.fRight;
        }
        if (dstMask.fBounds.fRight < srcMask.fBounds.fRight) {
            srcMask.bounds().fRight = dstMask.fBounds.fRight;
        }
 
        SkASSERT(srcMask.fBounds == dstMask.fBounds);
        int width = srcMask.fBounds.width();
        int height = srcMask.fBounds.height();
        int dstRB = dstMask.fRowBytes;
        int srcRB = srcMask.fRowBytes;
 
        const uint8_t* src = srcMask.fImage;
        uint8_t* dst = dstMask.image();
 
        if (SkMask::k3D_Format == srcMask.fFormat) {
            // we have to copy 3 times as much
            height *= 3;
        }
 
        // If not filling the full original glyph, clear it out first.
        if (dstMask.fBounds != origBounds) {
            sk_bzero(origGlyph.fImage, origGlyph.fHeight * origGlyph.rowBytes());
        }
 
        while (--height >= 0) {
            memcpy(dst, src, width);
            src += srcRB;
            dst += dstRB;
        }
    }
}

◆ getMaskFormat()

SkMask::Format SkScalerContext::getMaskFormat ( ) const

inline

Definition at line 289 of file SkScalerContext.h.

                                       {
        return fRec.fMaskFormat;
    }

◆ GetMaskPreBlend()

SkMaskGamma::PreBlend SkScalerContext::GetMaskPreBlend ( const SkScalerContextRec & rec )

static

Expands fDeviceGamma, fPaintGamma, fContrast, and fLumBits into a mask pre-blend.

Definition at line 151 of file SkScalerContext.cpp.

                                                                                  {
    SkAutoMutexExclusive ama(mask_gamma_cache_mutex());
 
    const SkMaskGamma& maskGamma = cached_mask_gamma(rec.getContrast(),
                                                     rec.getPaintGamma(),
                                                     rec.getDeviceGamma());
 
    // TODO: remove CanonicalColor when we to fix up Chrome layout tests.
    return maskGamma.preBlend(rec.getLuminanceColor());
}

◆ getPath()

void SkScalerContext::getPath	(	SkGlyph &	glyph,
		SkArenaAlloc *	alloc
	)

Definition at line 736 of file SkScalerContext.cpp.

                                                                 {
    this->internalGetPath(glyph, alloc);
}

◆ getRec()

const SkScalerContextRec & SkScalerContext::getRec ( ) const

inline

Definition at line 360 of file SkScalerContext.h.

360{ return fRec; }

◆ getTypeface()

SkTypeface * SkScalerContext::getTypeface ( ) const

inline

Definition at line 287 of file SkScalerContext.h.

287{ return fTypeface.get(); }

◆ isLinearMetrics()

bool SkScalerContext::isLinearMetrics ( ) const

inline

Definition at line 297 of file SkScalerContext.h.

                                 {
        return SkToBool(fRec.fFlags & kLinearMetrics_Flag);
    }

◆ isSubpixel()

bool SkScalerContext::isSubpixel ( ) const

inline

Definition at line 293 of file SkScalerContext.h.

                            {
        return SkToBool(fRec.fFlags & kSubpixelPositioning_Flag);
    }

◆ isVertical()

bool SkScalerContext::isVertical ( ) const

inline

Definition at line 302 of file SkScalerContext.h.

302{ return false; }

◆ MakeEmpty()

std::unique_ptr< SkScalerContext > SkScalerContext::MakeEmpty	(	sk_sp< SkTypeface >	typeface,
		const SkScalerContextEffects &	effects,
		const SkDescriptor *	desc
	)

static

Definition at line 1272 of file SkScalerContext.cpp.

                                  {
    class SkScalerContext_Empty : public SkScalerContext {
    public:
        SkScalerContext_Empty(sk_sp<SkTypeface> typeface, const SkScalerContextEffects& effects,
                              const SkDescriptor* desc)
                : SkScalerContext(std::move(typeface), effects, desc) {}
 
    protected:
        GlyphMetrics generateMetrics(const SkGlyph& glyph, SkArenaAlloc*) override {
            return {glyph.maskFormat()};
        }
        void generateImage(const SkGlyph&, void*) override {}
        bool generatePath(const SkGlyph& glyph, SkPath* path) override {
            path->reset();
            return false;
        }
        void generateFontMetrics(SkFontMetrics* metrics) override {
            if (metrics) {
                sk_bzero(metrics, sizeof(*metrics));
            }
        }
    };
 
    return std::make_unique<SkScalerContext_Empty>(std::move(typeface), effects, desc);
}

◆ makeGlyph()

SkGlyph SkScalerContext::makeGlyph	(	SkPackedGlyphID	packedID,
		SkArenaAlloc *	alloc
	)

Definition at line 193 of file SkScalerContext.cpp.

                                                                                {
    return internalMakeGlyph(packedID, fRec.fMaskFormat, alloc);
}

◆ MakeRecAndEffects()

void SkScalerContext::MakeRecAndEffects	(	const SkFont &	font,
		const SkPaint &	paint,
		const SkSurfaceProps &	surfaceProps,
		SkScalerContextFlags	scalerContextFlags,
		const SkMatrix &	deviceMatrix,
		SkScalerContextRec *	rec,
		SkScalerContextEffects *	effects
	)

static

Definition at line 1045 of file SkScalerContext.cpp.

                                                                         {
    SkASSERT(!deviceMatrix.hasPerspective());
 
    sk_bzero(rec, sizeof(SkScalerContextRec));
 
    SkTypeface* typeface = font.getTypeface();
 
    rec->fTypefaceID = typeface->uniqueID();
    rec->fTextSize = font.getSize();
    rec->fPreScaleX = font.getScaleX();
    rec->fPreSkewX  = font.getSkewX();
 
    bool checkPost2x2 = false;
 
    const SkMatrix::TypeMask mask = deviceMatrix.getType();
    if (mask & SkMatrix::kScale_Mask) {
        rec->fPost2x2[0][0] = sk_relax(deviceMatrix.getScaleX());
        rec->fPost2x2[1][1] = sk_relax(deviceMatrix.getScaleY());
        checkPost2x2 = true;
    } else {
        rec->fPost2x2[0][0] = rec->fPost2x2[1][1] = SK_Scalar1;
    }
    if (mask & SkMatrix::kAffine_Mask) {
        rec->fPost2x2[0][1] = sk_relax(deviceMatrix.getSkewX());
        rec->fPost2x2[1][0] = sk_relax(deviceMatrix.getSkewY());
        checkPost2x2 = true;
    } else {
        rec->fPost2x2[0][1] = rec->fPost2x2[1][0] = 0;
    }
 
    SkPaint::Style  style = paint.getStyle();
    SkScalar        strokeWidth = paint.getStrokeWidth();
 
    unsigned flags = 0;
 
    if (font.isEmbolden()) {
#ifdef SK_USE_FREETYPE_EMBOLDEN
        flags |= SkScalerContext::kEmbolden_Flag;
#else
        SkScalar fakeBoldScale = SkScalarInterpFunc(font.getSize(),
                                                    kStdFakeBoldInterpKeys,
                                                    kStdFakeBoldInterpValues,
                                                    kStdFakeBoldInterpLength);
        SkScalar extra = font.getSize() * fakeBoldScale;
 
        if (style == SkPaint::kFill_Style) {
            style = SkPaint::kStrokeAndFill_Style;
            strokeWidth = extra;    // ignore paint's strokeWidth if it was "fill"
        } else {
            strokeWidth += extra;
        }
#endif
    }
 
    if (style != SkPaint::kFill_Style && strokeWidth >= 0) {
        rec->fFrameWidth = strokeWidth;
        rec->fMiterLimit = paint.getStrokeMiter();
        rec->fStrokeJoin = SkToU8(paint.getStrokeJoin());
        rec->fStrokeCap = SkToU8(paint.getStrokeCap());
 
        if (style == SkPaint::kStrokeAndFill_Style) {
            flags |= SkScalerContext::kFrameAndFill_Flag;
        }
    } else {
        rec->fFrameWidth = -1;
        rec->fMiterLimit = 0;
        rec->fStrokeJoin = 0;
        rec->fStrokeCap = 0;
    }
 
    rec->fMaskFormat = compute_mask_format(font);
 
    if (SkMask::kLCD16_Format == rec->fMaskFormat) {
        if (too_big_for_lcd(*rec, checkPost2x2)) {
            rec->fMaskFormat = SkMask::kA8_Format;
            flags |= SkScalerContext::kGenA8FromLCD_Flag;
        } else {
            SkPixelGeometry geometry = surfaceProps.pixelGeometry();
 
            switch (geometry) {
                case kUnknown_SkPixelGeometry:
                    // eeek, can't support LCD
                    rec->fMaskFormat = SkMask::kA8_Format;
                    flags |= SkScalerContext::kGenA8FromLCD_Flag;
                    break;
                case kRGB_H_SkPixelGeometry:
                    // our default, do nothing.
                    break;
                case kBGR_H_SkPixelGeometry:
                    flags |= SkScalerContext::kLCD_BGROrder_Flag;
                    break;
                case kRGB_V_SkPixelGeometry:
                    flags |= SkScalerContext::kLCD_Vertical_Flag;
                    break;
                case kBGR_V_SkPixelGeometry:
                    flags |= SkScalerContext::kLCD_Vertical_Flag;
                    flags |= SkScalerContext::kLCD_BGROrder_Flag;
                    break;
            }
        }
    }
 
    if (font.isEmbeddedBitmaps()) {
        flags |= SkScalerContext::kEmbeddedBitmapText_Flag;
    }
    if (font.isSubpixel()) {
        flags |= SkScalerContext::kSubpixelPositioning_Flag;
    }
    if (font.isForceAutoHinting()) {
        flags |= SkScalerContext::kForceAutohinting_Flag;
    }
    if (font.isLinearMetrics()) {
        flags |= SkScalerContext::kLinearMetrics_Flag;
    }
    if (font.isBaselineSnap()) {
        flags |= SkScalerContext::kBaselineSnap_Flag;
    }
    if (typeface->glyphMaskNeedsCurrentColor()) {
        flags |= SkScalerContext::kNeedsForegroundColor_Flag;
        rec->fForegroundColor = paint.getColor();
    }
    rec->fFlags = SkToU16(flags);
 
    // these modify fFlags, so do them after assigning fFlags
    rec->setHinting(font.getHinting());
    rec->setLuminanceColor(SkPaintPriv::ComputeLuminanceColor(paint));
 
    // For now always set the paint gamma equal to the device gamma.
    // The math in SkMaskGamma can handle them being different,
    // but it requires superluminous masks when
    // Ex : deviceGamma(x) < paintGamma(x) and x is sufficiently large.
    rec->setDeviceGamma(surfaceProps.textGamma());
    rec->setPaintGamma(surfaceProps.textGamma());
    rec->setContrast(surfaceProps.textContrast());
 
    if (!SkToBool(scalerContextFlags & SkScalerContextFlags::kFakeGamma)) {
        rec->ignoreGamma();
    }
    if (!SkToBool(scalerContextFlags & SkScalerContextFlags::kBoostContrast)) {
        rec->setContrast(0);
    }
 
    new (effects) SkScalerContextEffects{paint};
}

◆ MakeRecAndEffectsFromFont()

static void SkScalerContext::MakeRecAndEffectsFromFont	(	const SkFont &	font,
		SkScalerContextRec *	rec,
		SkScalerContextEffects *	effects
	)

inlinestatic

Definition at line 331 of file SkScalerContext.h.

                                                                           {
        SkPaint paint;
        return MakeRecAndEffects(
                font, paint, SkSurfaceProps(),
                SkScalerContextFlags::kNone, SkMatrix::I(), rec, effects);
    }

◆ SaturateGlyphBounds() [1/2]

void SkScalerContext::SaturateGlyphBounds	(	SkGlyph *	glyph,
		SkIRect const &	r
	)

staticprotected

Definition at line 211 of file SkScalerContext.cpp.

                                                                           {
    glyph->fLeft    = sk_saturate_cast<int16_t>(r.fLeft);
    glyph->fTop     = sk_saturate_cast<int16_t>(r.fTop);
    glyph->fWidth   = sk_saturate_cast<uint16_t>(r.width64());
    glyph->fHeight  = sk_saturate_cast<uint16_t>(r.height64());
}

◆ SaturateGlyphBounds() [2/2]

void SkScalerContext::SaturateGlyphBounds	(	SkGlyph *	glyph,
		SkRect &&	r
	)

staticprotected

Definition at line 204 of file SkScalerContext.cpp.

                                                                    {
    r.roundOut(&r);
    glyph->fLeft    = sk_saturate_cast<int16_t>(r.fLeft);
    glyph->fTop     = sk_saturate_cast<int16_t>(r.fTop);
    glyph->fWidth   = sk_saturate_cast<uint16_t>(r.width());
    glyph->fHeight  = sk_saturate_cast<uint16_t>(r.height());
}

Friends And Related Symbol Documentation

◆ PathText

friend class PathText

friend

Definition at line 445 of file SkScalerContext.h.

◆ PathTextBench

friend class PathTextBench

friend

Definition at line 446 of file SkScalerContext.h.

◆ RandomScalerContext

friend class RandomScalerContext

friend

Definition at line 447 of file SkScalerContext.h.

Member Data Documentation

◆ fPreBlend

const SkMaskGamma::PreBlend SkScalerContext::fPreBlend

protected

Definition at line 470 of file SkScalerContext.h.

◆ fRec

SkScalerContextRec SkScalerContext::fRec

protected

Definition at line 379 of file SkScalerContext.h.

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

third_party/skia/src/core/SkScalerContext.h
third_party/skia/src/core/SkScalerContext.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

◆ Flags

Constructor & Destructor Documentation

◆ SkScalerContext()

◆ ~SkScalerContext()

Member Function Documentation

◆ AutoDescriptorGivenRecAndEffects()

◆ CheckBufferSizeForRec()

◆ computeAxisAlignmentForHText()

◆ CreateDescriptorAndEffectsUsingPaint()

◆ DescriptorBufferGiveRec()

◆ DescriptorGivenRecAndEffects()

◆ forceGenerateImageFromPath()

◆ forceOffGenerateImageFromPath()

◆ generateDrawable()

◆ generateFontMetrics()

◆ generateImage()

◆ GenerateImageFromPath()

◆ generateMetrics()

◆ GenerateMetricsFromPath()

◆ generatePath()

◆ getDrawable()

◆ getEffects()

◆ getFontMetrics()

◆ GetGammaLUTData()

◆ GetGammaLUTSize()

◆ getImage()

◆ getMaskFormat()

◆ GetMaskPreBlend()

◆ getPath()

◆ getRec()

◆ getTypeface()

◆ isLinearMetrics()

◆ isSubpixel()

◆ isVertical()

◆ MakeEmpty()

◆ makeGlyph()

◆ MakeRecAndEffects()

◆ MakeRecAndEffectsFromFont()

◆ SaturateGlyphBounds() [1/2]

◆ SaturateGlyphBounds() [2/2]

Friends And Related Symbol Documentation

◆ PathText

◆ PathTextBench

◆ RandomScalerContext

Member Data Documentation

◆ fPreBlend

◆ fRec