SkStrike Class Reference

#include <SkStrike.h>

Inheritance diagram for SkStrike:

Public Member Functions
	Monitor (SkStrike *strike) SK_ACQUIRE(strike -> fStrikeLock) :fStrike
	~Monitor () SK_RELEASE_CAPABILITY()
	SkStrike (SkStrikeCache *strikeCache, const SkStrikeSpec &strikeSpec, std::unique_ptr< SkScalerContext > scaler, const SkFontMetrics *metrics, std::unique_ptr< SkStrikePinner > pinner)
void	lock () override SK_ACQUIRE(fStrikeLock)
void	unlock () override SK_RELEASE_CAPABILITY(fStrikeLock)
SkGlyphDigest	digestFor (skglyph::ActionType, SkPackedGlyphID) override SK_REQUIRES(fStrikeLock)
bool	prepareForImage (SkGlyph *glyph) override SK_REQUIRES(fStrikeLock)
bool	prepareForPath (SkGlyph *) override SK_REQUIRES(fStrikeLock)
bool	prepareForDrawable (SkGlyph *) override SK_REQUIRES(fStrikeLock)
bool	mergeFromBuffer (SkReadBuffer &buffer) SK_EXCLUDES(fStrikeLock)
SkGlyph *	mergeGlyphAndImage (SkPackedGlyphID toID, const SkGlyph &fromGlyph) SK_EXCLUDES(fStrikeLock)
const SkPath *	mergePath (SkGlyph *glyph, const SkPath *path, bool hairline) SK_EXCLUDES(fStrikeLock)
const SkDrawable *	mergeDrawable (SkGlyph *glyph, sk_sp< SkDrawable > drawable) SK_EXCLUDES(fStrikeLock)
void	findIntercepts (const SkScalar bounds[2], SkScalar scale, SkScalar xPos, SkGlyph *, SkScalar *array, int *count) SK_EXCLUDES(fStrikeLock)
const SkFontMetrics &	getFontMetrics () const
SkSpan< const SkGlyph * >	metrics (SkSpan< const SkGlyphID > glyphIDs, const SkGlyph *results[]) SK_EXCLUDES(fStrikeLock)
SkSpan< const SkGlyph * >	preparePaths (SkSpan< const SkGlyphID > glyphIDs, const SkGlyph *results[]) SK_EXCLUDES(fStrikeLock)
SkSpan< const SkGlyph * >	prepareImages (SkSpan< const SkPackedGlyphID > glyphIDs, const SkGlyph *results[]) SK_EXCLUDES(fStrikeLock)
SkSpan< const SkGlyph * >	prepareDrawables (SkSpan< const SkGlyphID > glyphIDs, const SkGlyph *results[]) SK_EXCLUDES(fStrikeLock)
const SkDescriptor &	getDescriptor () const override
const SkGlyphPositionRoundingSpec &	roundingSpec () const override
sktext::SkStrikePromise	strikePromise () override
void	glyphIDsToPaths (SkSpan< sktext::IDOrPath > idsOrPaths) SK_EXCLUDES(fStrikeLock)
void	glyphIDsToDrawables (SkSpan< sktext::IDOrDrawable > idsOrDrawables) SK_EXCLUDES(fStrikeLock)
const SkStrikeSpec &	strikeSpec () const
void	verifyPinnedStrike () const
void	dump () const SK_EXCLUDES(fStrikeLock)
void	dumpMemoryStatistics (SkTraceMemoryDump *dump) const SK_EXCLUDES(fStrikeLock)
SkGlyph *	glyph (SkGlyphDigest) SK_REQUIRES(fStrikeLock)
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static void	FlattenGlyphsByType (SkWriteBuffer &buffer, SkSpan< SkGlyph > images, SkSpan< SkGlyph > paths, SkSpan< SkGlyph > drawables)

Friends
class	SkStrikeCache
class	SkStrikeTestingPeer

Detailed Description

Definition at line 60 of file SkStrike.cpp.

Constructor & Destructor Documentation

~Monitor()

SkStrike::~Monitor ( )

inline

Definition at line 67 of file SkStrike.cpp.

                                       {
        fStrike->unlock();
    }

SkStrike()

SkStrike::SkStrike	(	SkStrikeCache *	strikeCache,
		const SkStrikeSpec &	strikeSpec,
		std::unique_ptr< SkScalerContext >	scaler,
		const SkFontMetrics *	metrics,
		std::unique_ptr< SkStrikePinner >	pinner
	)

Definition at line 45 of file SkStrike.cpp.

        : fFontMetrics{use_or_generate_metrics(metrics, scaler.get())}
        , fRoundingSpec{scaler->isSubpixel(),
                        scaler->computeAxisAlignmentForHText()}
        , fStrikeSpec{strikeSpec}
        , fStrikeCache{strikeCache}
        , fScalerContext{std::move(scaler)}
        , fPinner{std::move(pinner)} {
    SkASSERT(fScalerContext != nullptr);
}

Member Function Documentation

digestFor()

SkGlyphDigest SkStrike::digestFor ( skglyph::ActionType  actionType, SkPackedGlyphID  packedGlyphID  )

overridevirtual

Implements sktext::StrikeForGPU.

Definition at line 331 of file SkStrike.cpp.

                                                                                      {
    SkGlyphDigest* digestPtr = fDigestForPackedGlyphID.find(packedGlyphID);
    if (digestPtr != nullptr && digestPtr->actionFor(actionType) != GlyphAction::kUnset) {
        return *digestPtr;
    }
 
    SkGlyph* glyph;
    if (digestPtr != nullptr) {
        glyph = fGlyphForIndex[digestPtr->index()];
    } else {
        glyph = fAlloc.make<SkGlyph>(fScalerContext->makeGlyph(packedGlyphID, &fAlloc));
        fMemoryIncrease += sizeof(SkGlyph);
        digestPtr = this->addGlyphAndDigest(glyph);
    }
 
    digestPtr->setActionFor(actionType, glyph, this);
 
    return *digestPtr;
}

dump()

void SkStrike::dump

(

)

const

Definition at line 277 of file SkStrike.cpp.

                          {
    SkAutoMutexExclusive lock{fStrikeLock};
    const SkTypeface* face = fScalerContext->getTypeface();
    const SkScalerContextRec& rec = fScalerContext->getRec();
    SkMatrix matrix;
    rec.getSingleMatrix(&matrix);
    matrix.preScale(SkScalarInvert(rec.fTextSize), SkScalarInvert(rec.fTextSize));
    SkString name;
    face->getFamilyName(&name);
 
    SkString msg;
    SkFontStyle style = face->fontStyle();
    msg.printf("cache typeface:%x %25s:(%d,%d,%d)\n %s glyphs:%3d",
               face->uniqueID(), name.c_str(), style.weight(), style.width(), style.slant(),
               rec.dump().c_str(), fDigestForPackedGlyphID.count());
    SkDebugf("%s\n", msg.c_str());
}

dumpMemoryStatistics()

void SkStrike::dumpMemoryStatistics

(

SkTraceMemoryDump *

dump

)

const

Definition at line 295 of file SkStrike.cpp.

                                                                 {
    SkAutoMutexExclusive lock{fStrikeLock};
    const SkTypeface* face = fScalerContext->getTypeface();
    const SkScalerContextRec& rec = fScalerContext->getRec();
 
    SkString fontName;
    face->getFamilyName(&fontName);
    // Replace all special characters with '_'.
    for (size_t index = 0; index < fontName.size(); ++index) {
        if (!std::isalnum(fontName[index])) {
            fontName[index] = '_';
        }
    }
 
    SkString dumpName = SkStringPrintf("%s/%s_%u/%p",
                                       SkStrikeCache::kGlyphCacheDumpName,
                                       fontName.c_str(),
                                       rec.fTypefaceID,
                                       this);
 
    dump->dumpNumericValue(dumpName.c_str(), "size", "bytes", fMemoryUsed);
    dump->dumpNumericValue(dumpName.c_str(),
                           "glyph_count", "objects",
                           fDigestForPackedGlyphID.count());
    dump->setMemoryBacking(dumpName.c_str(), "malloc", nullptr);
}

findIntercepts()

void SkStrike::findIntercepts	(	const SkScalar	bounds[2],
		SkScalar	scale,
		SkScalar	xPos,
		SkGlyph *	glyph,
		SkScalar *	array,
		int *	count
	)

Definition at line 212 of file SkStrike.cpp.

                                                                           {
    SkAutoMutexExclusive lock{fStrikeLock};
    glyph->ensureIntercepts(bounds, scale, xPos, array, count, &fAlloc);
}

FlattenGlyphsByType()

void SkStrike::FlattenGlyphsByType ( SkWriteBuffer &  buffer, SkSpan< SkGlyph >  images, SkSpan< SkGlyph >  paths, SkSpan< SkGlyph >  drawables  )

static

Definition at line 87 of file SkStrike.cpp.

                                                         {
    SkASSERT_RELEASE(SkTFitsIn<int>(images.size()) &&
                     SkTFitsIn<int>(paths.size()) &&
                     SkTFitsIn<int>(drawables.size()));
 
    buffer.writeInt(images.size());
    for (SkGlyph& glyph : images) {
        SkASSERT(SkMask::IsValidFormat(glyph.maskFormat()));
        glyph.flattenMetrics(buffer);
        glyph.flattenImage(buffer);
    }
 
    buffer.writeInt(paths.size());
    for (SkGlyph& glyph : paths) {
        SkASSERT(SkMask::IsValidFormat(glyph.maskFormat()));
        glyph.flattenMetrics(buffer);
        glyph.flattenPath(buffer);
    }
 
    buffer.writeInt(drawables.size());
    for (SkGlyph& glyph : drawables) {
        SkASSERT(SkMask::IsValidFormat(glyph.maskFormat()));
        glyph.flattenMetrics(buffer);
        glyph.flattenDrawable(buffer);
    }
}

getDescriptor()

const SkDescriptor & SkStrike::getDescriptor ( ) const

inlineoverridevirtual

Implements sktext::StrikeForGPU.

Definition at line 103 of file SkStrike.h.

                                                       {
        return fStrikeSpec.descriptor();
    }

getFontMetrics()

const SkFontMetrics & SkStrike::getFontMetrics ( ) const

inline

Definition at line 86 of file SkStrike.h.

                                                {
        return fFontMetrics;
    }

glyph()

SkGlyph * SkStrike::glyph

(

SkGlyphDigest

digest

)

Definition at line 322 of file SkStrike.cpp.

                                             {
    return fGlyphForIndex[digest.index()];
}

glyphIDsToDrawables()

void SkStrike::glyphIDsToDrawables

(

SkSpan< sktext::IDOrDrawable >

idsOrDrawables

)

Definition at line 267 of file SkStrike.cpp.

                                                                            {
    Monitor m{this};
    for (sktext::IDOrDrawable& idOrDrawable : idsOrDrawables) {
        SkGlyph* glyph = this->glyph(SkPackedGlyphID{idOrDrawable.fGlyphID});
        this->prepareForDrawable(glyph);
        SkASSERT(glyph->drawable() != nullptr);
        idOrDrawable.fDrawable = glyph->drawable();
    }
}

glyphIDsToPaths()

void SkStrike::glyphIDsToPaths

(

SkSpan< sktext::IDOrPath >

idsOrPaths

)

Definition at line 258 of file SkStrike.cpp.

                                                                {
    Monitor m{this};
    for (sktext::IDOrPath& idOrPath : idsOrPaths) {
        SkGlyph* glyph = this->glyph(SkPackedGlyphID{idOrPath.fGlyphID});
        this->prepareForPath(glyph);
        new (&idOrPath.fPath) SkPath{*glyph->path()};
    }
}

lock()

void SkStrike::lock ( )

overridevirtual

Implements sktext::StrikeForGPU.

Definition at line 75 of file SkStrike.cpp.

                    {
    fStrikeLock.acquire();
    fMemoryIncrease = 0;
}

mergeDrawable()

const SkDrawable * SkStrike::mergeDrawable	(	SkGlyph *	glyph,
		sk_sp< SkDrawable >	drawable
	)

Definition at line 199 of file SkStrike.cpp.

                                                                                    {
    Monitor m{this};
    if (glyph->setDrawableHasBeenCalled()) {
        SkDEBUGFAIL("Re-adding drawable to existing glyph. This should not happen.");
    }
    if (glyph->setDrawable(&fAlloc, std::move(drawable))) {
        fMemoryIncrease += glyph->drawable()->approximateBytesUsed();
        SkASSERT(fMemoryIncrease > 0);
    }
 
    return glyph->drawable();
}

mergeFromBuffer()

bool SkStrike::mergeFromBuffer

(

SkReadBuffer &

buffer

)

Definition at line 117 of file SkStrike.cpp.

                                                   {
    // Read glyphs with images for the current strike.
    const int imagesCount = buffer.readInt();
    if (imagesCount == 0 && !buffer.isValid()) {
        return false;
    }
 
    {
        Monitor m{this};
        for (int curImage = 0; curImage < imagesCount; ++curImage) {
            if (!this->mergeGlyphAndImageFromBuffer(buffer)) {
                return false;
            }
        }
    }
 
    // Read glyphs with paths for the current strike.
    const int pathsCount = buffer.readInt();
    if (pathsCount == 0 && !buffer.isValid()) {
        return false;
    }
    {
        Monitor m{this};
        for (int curPath = 0; curPath < pathsCount; ++curPath) {
            if (!this->mergeGlyphAndPathFromBuffer(buffer)) {
                return false;
            }
        }
    }
 
    // Read glyphs with drawables for the current strike.
    const int drawablesCount = buffer.readInt();
    if (drawablesCount == 0 && !buffer.isValid()) {
        return false;
    }
    {
        Monitor m{this};
        for (int curDrawable = 0; curDrawable < drawablesCount; ++curDrawable) {
            if (!this->mergeGlyphAndDrawableFromBuffer(buffer)) {
                return false;
            }
        }
    }
 
    return true;
}

mergeGlyphAndImage()

SkGlyph * SkStrike::mergeGlyphAndImage	(	SkPackedGlyphID	toID,
		const SkGlyph &	fromGlyph
	)

Definition at line 164 of file SkStrike.cpp.

                                                                                    {
    Monitor m{this};
    // TODO(herb): remove finding the glyph when setting the metrics and image are separated
    SkGlyphDigest* digest = fDigestForPackedGlyphID.find(toID);
    if (digest != nullptr) {
        SkGlyph* glyph = fGlyphForIndex[digest->index()];
        if (fromGlyph.setImageHasBeenCalled()) {
            if (glyph->setImageHasBeenCalled()) {
                // Should never set an image on a glyph which already has an image.
                SkDEBUGFAIL("Re-adding image to existing glyph. This should not happen.");
            }
            // TODO: assert that any metrics on fromGlyph are the same.
            fMemoryIncrease += glyph->setMetricsAndImage(&fAlloc, fromGlyph);
        }
        return glyph;
    } else {
        SkGlyph* glyph = fAlloc.make<SkGlyph>(toID);
        fMemoryIncrease += glyph->setMetricsAndImage(&fAlloc, fromGlyph) + sizeof(SkGlyph);
        (void)this->addGlyphAndDigest(glyph);
        return glyph;
    }
}

mergePath()

const SkPath * SkStrike::mergePath	(	SkGlyph *	glyph,
		const SkPath *	path,
		bool	hairline
	)

Definition at line 187 of file SkStrike.cpp.

                                                                                   {
    Monitor m{this};
    if (glyph->setPathHasBeenCalled()) {
        SkDEBUGFAIL("Re-adding path to existing glyph. This should not happen.");
    }
    if (glyph->setPath(&fAlloc, path, hairline)) {
        fMemoryIncrease += glyph->path()->approximateBytesUsed();
    }
 
    return glyph->path();
}

metrics()

SkSpan< const SkGlyph * > SkStrike::metrics	(	SkSpan< const SkGlyphID >	glyphIDs,
		const SkGlyph *	results[]
	)

Definition at line 218 of file SkStrike.cpp.

                                                                    {
    Monitor m{this};
    return this->internalPrepare(glyphIDs, kMetricsOnly, results);
}

Monitor()

SkStrike::Monitor ( SkStrike *  strike ) -> fStrikeLock) : fStrike

inline

Definition at line 62 of file SkStrike.cpp.

            : fStrike{strike} {

prepareDrawables()

SkSpan< const SkGlyph * > SkStrike::prepareDrawables	(	SkSpan< const SkGlyphID >	glyphIDs,
		const SkGlyph *	results[]
	)

Definition at line 243 of file SkStrike.cpp.

                                                                    {
    const SkGlyph** cursor = results;
    {
        Monitor m{this};
        for (auto glyphID : glyphIDs) {
            SkGlyph* glyph = this->glyph(SkPackedGlyphID{glyphID});
            this->prepareForDrawable(glyph);
            *cursor++ = glyph;
        }
    }
 
    return {results, glyphIDs.size()};
}

prepareForDrawable()

bool SkStrike::prepareForDrawable ( SkGlyph *  glyph )

overridevirtual

Implements sktext::StrikeForGPU.

Definition at line 373 of file SkStrike.cpp.

                                                {
    if (glyph->setDrawable(&fAlloc, fScalerContext.get())) {
        size_t increase = glyph->drawable()->approximateBytesUsed();
        SkASSERT(increase > 0);
        fMemoryIncrease += increase;
    }
    return glyph->drawable() != nullptr;
}

prepareForImage()

bool SkStrike::prepareForImage ( SkGlyph *  glyph )

overridevirtual

Implements sktext::StrikeForGPU.

Definition at line 359 of file SkStrike.cpp.

                                             {
    if (glyph->setImage(&fAlloc, fScalerContext.get())) {
        fMemoryIncrease += glyph->imageSize();
    }
    return glyph->image() != nullptr;
}

prepareForPath()

bool SkStrike::prepareForPath ( SkGlyph *  glyph )

overridevirtual

Implements sktext::StrikeForGPU.

Definition at line 366 of file SkStrike.cpp.

                                            {
    if (glyph->setPath(&fAlloc, fScalerContext.get())) {
        fMemoryIncrease += glyph->path()->approximateBytesUsed();
    }
    return glyph->path() !=nullptr;
}

prepareImages()

SkSpan< const SkGlyph * > SkStrike::prepareImages	(	SkSpan< const SkPackedGlyphID >	glyphIDs,
		const SkGlyph *	results[]
	)

Definition at line 230 of file SkStrike.cpp.

                                                                          {
    const SkGlyph** cursor = results;
    Monitor m{this};
    for (auto glyphID : glyphIDs) {
        SkGlyph* glyph = this->glyph(glyphID);
        this->prepareForImage(glyph);
        *cursor++ = glyph;
    }
 
    return {results, glyphIDs.size()};
}

preparePaths()

SkSpan< const SkGlyph * > SkStrike::preparePaths	(	SkSpan< const SkGlyphID >	glyphIDs,
		const SkGlyph *	results[]
	)

Definition at line 224 of file SkStrike.cpp.

                                                                    {
    Monitor m{this};
    return this->internalPrepare(glyphIDs, kMetricsAndPath, results);
}

roundingSpec()

const SkGlyphPositionRoundingSpec & SkStrike::roundingSpec ( ) const

inlineoverridevirtual

Implements sktext::StrikeForGPU.

Definition at line 107 of file SkStrike.h.

                                                                     {
        return fRoundingSpec;
    }

strikePromise()

sktext::SkStrikePromise SkStrike::strikePromise ( )

inlineoverridevirtual

Implements sktext::StrikeForGPU.

Definition at line 111 of file SkStrike.h.

                                                   {
        return sktext::SkStrikePromise(sk_ref_sp<SkStrike>(this));
    }

strikeSpec()

const SkStrikeSpec & SkStrike::strikeSpec ( ) const

inline

Definition at line 121 of file SkStrike.h.

                                           {
        return fStrikeSpec;
    }

unlock()

void SkStrike::unlock ( )

overridevirtual

Implements sktext::StrikeForGPU.

Definition at line 80 of file SkStrike.cpp.

                      {
    const size_t memoryIncrease = fMemoryIncrease;
    fStrikeLock.release();
    this->updateMemoryUsage(memoryIncrease);
}

verifyPinnedStrike()

void SkStrike::verifyPinnedStrike ( ) const

inline

Definition at line 125 of file SkStrike.h.

                                    {
        if (fPinner != nullptr) {
            fPinner->assertValid();
        }
    }

Friends And Related Symbol Documentation

SkStrikeCache

friend class SkStrikeCache

friend

Definition at line 137 of file SkStrike.h.

SkStrikeTestingPeer

friend class SkStrikeTestingPeer

friend

Definition at line 138 of file SkStrike.h.

---

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

• third_party/skia/src/core/SkStrike.cpp
• third_party/skia/src/core/SkStrike.h