AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "Remove attach and detach glyph cache."

Browse Source 
This reverts commit 61d56b92a4.

Reason for revert: broke gldft text

Original change's description:
> Remove attach and detach glyph cache.
> 
> BUG=skia:7515
> 
> Change-Id: Ib978e3cf4cfffdefe6453feb520e5e73684abf2e
> Reviewed-on: https://skia-review.googlesource.com/112560
> Reviewed-by: Ben Wagner <bungeman@google.com>
> Commit-Queue: Herb Derby <herb@google.com>

TBR=bungeman@google.com,herb@google.com

Change-Id: Id5723a3abcd103ed20197bba2dab06e8074be633
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:7515
Reviewed-on: https://skia-review.googlesource.com/112745
Reviewed-by: Herb Derby <herb@google.com>
Commit-Queue: Herb Derby <herb@google.com>
This commit is contained in:
Herb Derby 2018-03-07 18:05:39 +00:00 committed by Skia Commit-Bot
parent e64b064f87
commit ab6fd7ef91
13 changed files with 160 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bench/PathTextBench.cpp
View File

@ -47,7 +47,7 @@ private:
void onDelayedSetup() override {
SkPaint defaultPaint;
SkAutoGlyphCache agc(defaultPaint, nullptr, &SkMatrix::I());
SkGlyphCache* cache = agc.get();
SkGlyphCache* cache = agc.getCache();
for (int i = 0; i < kNumGlyphs; ++i) {
SkGlyphID id = cache->unicharToGlyph(kGlyphs[i]);
cache->getScalerContext()->getPath(SkPackedGlyphID(id), &fGlyphs[i]);

2
bench/SkGlyphCacheBench.cpp
View File

@ -21,7 +21,7 @@ static void do_font_stuff(SkPaint* paint) {
for (SkScalar i = 8; i < 64; i++) {
paint->setTextSize(i);
SkAutoGlyphCacheNoGamma autoCache(*paint, nullptr, nullptr);
SkGlyphCache* cache = autoCache.get();
SkGlyphCache* cache = autoCache.getCache();
uint16_t glyphs['z'];
for (int c = ' '; c < 'z'; c++) {
glyphs[c] = cache->unicharToGlyph(c);

2
samplecode/SamplePathText.cpp
View File

@ -25,7 +25,7 @@ public:
PathText() {
SkPaint defaultPaint;
SkAutoGlyphCache agc(defaultPaint, nullptr, &SkMatrix::I());
SkGlyphCache* cache = agc.get();
SkGlyphCache* cache = agc.getCache();
SkPath glyphPaths[52];
for (int i = 0; i < 52; ++i) {
// I and l are rects on OS X ...

36
src/core/SkGlyphCache.cpp
View File

@ -505,23 +505,6 @@ SkExclusiveStrikePtr SkGlyphCache::FindOrCreateStrikeExclusive(
return FindOrCreateStrikeExclusive(desc, creator);
}
SkExclusiveStrikePtr SkGlyphCache::FindOrCreateStrikeExclusive(
const SkPaint& paint,
const SkSurfaceProps* surfaceProps,
SkScalerContextFlags scalerContextFlags,
const SkMatrix* deviceMatrix)
{
SkAutoDescriptor ad;
SkScalerContextEffects effects;
auto desc = SkScalerContext::CreateDescriptorAndEffectsUsingPaint(
paint, surfaceProps, scalerContextFlags, deviceMatrix, &ad, &effects);
auto tf = SkPaintPriv::GetTypefaceOrDefault(paint);
return FindOrCreateStrikeExclusive(*desc, effects, *tf);
}
void SkGlyphCache::AttachCache(SkGlyphCache* cache) {
SkGlyphCache_Globals::AttachCache(cache);
}
@ -803,3 +786,22 @@ void SkGraphics::PurgeFontCache() {
size_t SkGraphics::GetTLSFontCacheLimit() { return 0; }
void SkGraphics::SetTLSFontCacheLimit(size_t bytes) { }
SkGlyphCache* SkGlyphCache::DetachCache(
SkTypeface* typeface, const SkScalerContextEffects& effects, const SkDescriptor* desc)
{
auto cache = FindOrCreateStrikeExclusive(*desc, effects, *typeface);
return cache.release();
}
SkGlyphCache* SkGlyphCache::DetachCacheUsingPaint(const SkPaint& paint,
const SkSurfaceProps* surfaceProps,
SkScalerContextFlags scalerContextFlags,
const SkMatrix* deviceMatrix) {
SkAutoDescriptor ad;
SkScalerContextEffects effects;
auto desc = SkScalerContext::CreateDescriptorAndEffectsUsingPaint(
paint, surfaceProps, scalerContextFlags, deviceMatrix, &ad, &effects);
return SkGlyphCache::DetachCache(SkPaintPriv::GetTypefaceOrDefault(paint), effects, desc);
}

33
src/core/SkGlyphCache.h
View File

@ -148,12 +148,6 @@ public:
const SkScalerContextEffects& effects,
const SkTypeface& typeface);
static SkExclusiveStrikePtr FindOrCreateStrikeExclusive(
const SkPaint& paint,
const SkSurfaceProps* surfaceProps,
SkScalerContextFlags scalerContextFlags,
const SkMatrix* deviceMatrix);
template <typename ScalerContextCreator>
static SkExclusiveStrikePtr CreateStrikeExclusive(
const SkDescriptor& desc, ScalerContextCreator creator)
@ -173,6 +167,22 @@ public:
return SkExclusiveStrikePtr(new SkGlyphCache(desc, std::move(context)));
}
/** Detach a strike from the global cache matching the specified descriptor. Once detached,
it can be queried/modified by the current thread, and when finished, be reattached to the
global cache with AttachCache(). While detached, if another request is made with the same
descriptor, a different strike will be generated. This is fine. It does mean we can have
more than 1 strike for the same descriptor, but that will eventually get purged, and the
win is that different thread will never block each other while a strike is being used.
DEPRECATED
*/
static SkGlyphCache* DetachCache(
SkTypeface* typeface, const SkScalerContextEffects& effects, const SkDescriptor* desc);
static SkGlyphCache* DetachCacheUsingPaint(const SkPaint& paint,
const SkSurfaceProps* surfaceProps,
SkScalerContextFlags scalerContextFlags,
const SkMatrix* deviceMatrix);
static void Dump();
/** Dump memory usage statistics of all the attaches caches in the process using the
@ -286,17 +296,20 @@ private:
class SkAutoGlyphCache : public SkExclusiveStrikePtr {
public:
/** deprecated: use get() */
SkGlyphCache* getCache() const { return this->get(); }
SkAutoGlyphCache() = default;
SkAutoGlyphCache(SkGlyphCache* cache) : INHERITED(cache) {}
SkAutoGlyphCache(SkTypeface* typeface, const SkScalerContextEffects& effects,
const SkDescriptor* desc)
: INHERITED(SkGlyphCache::FindOrCreateStrikeExclusive(*desc, effects, *typeface)) {}
: INHERITED(SkGlyphCache::DetachCache(typeface, effects, desc))
{}
/** deprecated: always enables fake gamma */
SkAutoGlyphCache(const SkPaint& paint,
const SkSurfaceProps* surfaceProps,
const SkMatrix* matrix)
: INHERITED(
SkGlyphCache::FindOrCreateStrikeExclusive(
SkGlyphCache::DetachCacheUsingPaint(
paint, surfaceProps,
SkScalerContextFlags::kFakeGammaAndBoostContrast, matrix))
{}
@ -305,8 +318,8 @@ public:
SkScalerContextFlags scalerContextFlags,
const SkMatrix* matrix)
: INHERITED(
SkGlyphCache::FindOrCreateStrikeExclusive(
paint, surfaceProps, scalerContextFlags, matrix)) {}
SkGlyphCache::DetachCacheUsingPaint(paint, surfaceProps, scalerContextFlags, matrix))
{}
private:
using INHERITED = SkExclusiveStrikePtr;
};

27
src/core/SkPaint.cpp
View File

@ -431,7 +431,7 @@ int SkPaint::textToGlyphs(const void* textData, size_t byteLength, uint16_t glyp
}
SkAutoGlyphCache autoCache(*this, nullptr, nullptr);
SkGlyphCache* cache = autoCache.get();
SkGlyphCache* cache = autoCache.getCache();
const char* text = (const char*)textData;
const char* stop = text + byteLength;
@ -489,7 +489,7 @@ bool SkPaint::containsText(const void* textData, size_t byteLength) const {
}
SkAutoGlyphCache autoCache(*this, nullptr, nullptr);
SkGlyphCache* cache = autoCache.get();
SkGlyphCache* cache = autoCache.getCache();
switch (this->getTextEncoding()) {
case SkPaint::kUTF8_TextEncoding: {
@ -539,7 +539,7 @@ void SkPaint::glyphsToUnichars(const uint16_t glyphs[], int count, SkUnichar tex
SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
SkAutoGlyphCache autoCache(*this, &props, nullptr);
SkGlyphCache* cache = autoCache.get();
SkGlyphCache* cache = autoCache.getCache();
for (int index = 0; index < count; index++) {
textData[index] = cache->glyphToUnichar(glyphs[index]);
@ -805,7 +805,7 @@ SkScalar SkPaint::measureText(const void* textData, size_t length, SkRect* bound
SkScalar scale = canon.getScale();
SkAutoGlyphCache autoCache(paint, nullptr, nullptr);
SkGlyphCache* cache = autoCache.get();
SkGlyphCache* cache = autoCache.getCache();
SkScalar width = 0;
@ -859,7 +859,7 @@ size_t SkPaint::breakText(const void* textD, size_t length, SkScalar maxWidth,
}
SkAutoGlyphCache autoCache(paint, nullptr, nullptr);
SkGlyphCache* cache = autoCache.get();
SkGlyphCache* cache = autoCache.getCache();
GlyphCacheProc glyphCacheProc = SkPaint::GetGlyphCacheProc(paint.getTextEncoding(),
paint.isDevKernText(),
@ -965,7 +965,7 @@ int SkPaint::getTextWidths(const void* textData, size_t byteLength,
SkScalar scale = canon.getScale();
SkAutoGlyphCache autoCache(paint, nullptr, nullptr);
SkGlyphCache* cache = autoCache.get();
SkGlyphCache* cache = autoCache.getCache();
GlyphCacheProc glyphCacheProc = SkPaint::GetGlyphCacheProc(paint.getTextEncoding(),
paint.isDevKernText(),
nullptr != bounds);
@ -1748,8 +1748,9 @@ SkTextBaseIter::SkTextBaseIter(const char text[], size_t length,
}
// SRGBTODO: Is this correct?
fCache = SkGlyphCache::FindOrCreateStrikeExclusive(
fPaint, nullptr, SkScalerContextFlags::kFakeGammaAndBoostContrast, nullptr);
fCache = SkGlyphCache::DetachCacheUsingPaint(fPaint, nullptr,
SkScalerContextFlags::kFakeGammaAndBoostContrast,
nullptr);
SkPaint::Style style = SkPaint::kFill_Style;
sk_sp<SkPathEffect> pe;
@ -1767,7 +1768,7 @@ SkTextBaseIter::SkTextBaseIter(const char text[], size_t length,
SkScalar xOffset = 0;
if (paint.getTextAlign() != SkPaint::kLeft_Align) { // need to measure first
int count;
SkScalar width = fPaint.measure_text(fCache.get(), text, length, &count, nullptr) * fScale;
SkScalar width = fPaint.measure_text(fCache, text, length, &count, nullptr) * fScale;
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
width = SkScalarHalf(width);
}
@ -1782,9 +1783,13 @@ SkTextBaseIter::SkTextBaseIter(const char text[], size_t length,
fXYIndex = paint.isVerticalText() ? 1 : 0;
}
SkTextBaseIter::~SkTextBaseIter() {
SkGlyphCache::AttachCache(fCache);
}
bool SkTextToPathIter::next(const SkPath** path, SkScalar* xpos) {
if (fText < fStop) {
const SkGlyph& glyph = fGlyphCacheProc(fCache.get(), &fText);
const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
fXPos += (fPrevAdvance + fAutoKern.adjust(glyph)) * fScale;
fPrevAdvance = advance(glyph, fXYIndex); // + fPaint.getTextTracking();
@ -1807,7 +1812,7 @@ bool SkTextToPathIter::next(const SkPath** path, SkScalar* xpos) {
}
bool SkTextInterceptsIter::next(SkScalar* array, int* count) {
const SkGlyph& glyph = fGlyphCacheProc(fCache.get(), &fText);
const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
fXPos += (fPrevAdvance + fAutoKern.adjust(glyph)) * fScale;
fPrevAdvance = advance(glyph, fXYIndex); // + fPaint.getTextTracking();
if (fCache->findPath(glyph)) {

17
src/core/SkTextToPathIter.h
View File

@ -9,21 +9,22 @@
#define SkTextToPathIter_DEFINED
#include "SkAutoKern.h"
#include "SkGlyphCache.h"
#include "SkPaint.h"
class SkGlyphCache;
class SkTextBaseIter {
protected:
SkTextBaseIter(const char text[], size_t length, const SkPaint& paint,
bool applyStrokeAndPathEffects);
~SkTextBaseIter();
SkExclusiveStrikePtr fCache;
SkPaint fPaint;
SkScalar fScale;
SkScalar fPrevAdvance;
const char* fText;
const char* fStop;
SkGlyphCache* fCache;
SkPaint fPaint;
SkScalar fScale;
SkScalar fPrevAdvance;
const char* fText;
const char* fStop;
SkPaint::GlyphCacheProc fGlyphCacheProc;
SkScalar fXPos; // accumulated xpos, returned in next
@ -73,7 +74,7 @@ public:
if (TextType::kPosText == fTextType
&& fPaint.getTextAlign() != SkPaint::kLeft_Align) { // need to measure first
const char* text = fText;
const SkGlyph& glyph = fGlyphCacheProc(fCache.get(), &text);
const SkGlyph& glyph = fGlyphCacheProc(fCache, &text);
SkScalar width = (&glyph.fAdvanceX)[0] * fScale;
if (fPaint.getTextAlign() == SkPaint::kCenter_Align) {
width = SkScalarHalf(width);

13
src/gpu/text/GrAtlasTextBlob.cpp
View File

@ -55,11 +55,11 @@ sk_sp<GrAtlasTextBlob> GrAtlasTextBlob::Make(GrMemoryPool* pool, int glyphCount,
return cacheBlob;
}
SkExclusiveStrikePtr GrAtlasTextBlob::setupCache(int runIndex,
const SkSurfaceProps& props,
SkScalerContextFlags scalerContextFlags,
const SkPaint& skPaint,
const SkMatrix* viewMatrix) {
SkGlyphCache* GrAtlasTextBlob::setupCache(int runIndex,
const SkSurfaceProps& props,
SkScalerContextFlags scalerContextFlags,
const SkPaint& skPaint,
const SkMatrix* viewMatrix) {
GrAtlasTextBlob::Run* run = &fRuns[runIndex];
// if we have an override descriptor for the run, then we should use that
@ -71,8 +71,7 @@ SkExclusiveStrikePtr GrAtlasTextBlob::setupCache(int runIndex,
run->fTypeface = SkPaintPriv::RefTypefaceOrDefault(skPaint);
run->fPathEffect = sk_ref_sp(effects.fPathEffect);
run->fMaskFilter = sk_ref_sp(effects.fMaskFilter);
return SkGlyphCache::FindOrCreateStrikeExclusive(
*desc->getDesc(), effects, *run->fTypeface.get());
return SkGlyphCache::DetachCache(run->fTypeface.get(), effects, desc->getDesc());
}
void GrAtlasTextBlob::appendGlyph(int runIndex,

12
src/gpu/text/GrAtlasTextBlob.h
View File

@ -170,11 +170,11 @@ public:
run.fOverrideDescriptor.reset(new SkAutoDescriptor);
}
SkExclusiveStrikePtr setupCache(int runIndex,
const SkSurfaceProps& props,
SkScalerContextFlags scalerContextFlags,
const SkPaint& skPaint,
const SkMatrix* viewMatrix);
SkGlyphCache* setupCache(int runIndex,
const SkSurfaceProps& props,
SkScalerContextFlags scalerContextFlags,
const SkPaint& skPaint,
const SkMatrix* viewMatrix);
// Appends a glyph to the blob. If the glyph is too large, the glyph will be appended
// as a path.
@ -607,7 +607,7 @@ private:
GrDeferredUploadTarget* fUploadTarget;
GrGlyphCache* fGlyphCache;
GrAtlasManager* fFullAtlasManager;
SkExclusiveStrikePtr* fLazyCache;
SkAutoGlyphCache* fLazyCache;
Run* fRun;
Run::SubRunInfo* fSubRun;
GrColor fColor;

3
src/gpu/text/GrAtlasTextBlobVertexRegenerator.cpp
View File

@ -244,8 +244,7 @@ Regenerator::Result Regenerator::doRegen() {
SkScalerContextEffects effects;
effects.fPathEffect = fRun->fPathEffect.get();
effects.fMaskFilter = fRun->fMaskFilter.get();
*fLazyCache =
SkGlyphCache::FindOrCreateStrikeExclusive(*desc, effects, *fRun->fTypeface.get());
fLazyCache->reset(SkGlyphCache::DetachCache(fRun->fTypeface.get(), effects, desc));
}
if (regenGlyphs) {

148
src/gpu/text/GrAtlasTextContext.cpp
View File

@ -386,18 +386,20 @@ void GrAtlasTextContext::DrawBmpText(GrAtlasTextBlob* blob, int runIndex,
return;
}
sk_sp<GrTextStrike> currStrike = nullptr;
auto cache = blob->setupCache(runIndex, props, scalerContextFlags, paint, &viewMatrix);
sk_sp<GrTextStrike> currStrike;
SkGlyphCache* cache = blob->setupCache(runIndex, props, scalerContextFlags, paint, &viewMatrix);
SkFindAndPlaceGlyph::ProcessText(paint.skPaint().getTextEncoding(), text, byteLength, {x, y},
viewMatrix, paint.skPaint().getTextAlign(), cache.get(),
viewMatrix, paint.skPaint().getTextAlign(), cache,
[&](const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
position += rounding;
BmpAppendGlyph(blob, runIndex, glyphCache, &currStrike,
glyph, SkScalarFloorToScalar(position.fX),
SkScalarFloorToScalar(position.fY),
paint.filteredPremulColor(), cache.get(),
paint.filteredPremulColor(), cache,
SK_Scalar1);
});
SkGlyphCache::AttachCache(cache);
}
void GrAtlasTextContext::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
@ -424,19 +426,20 @@ void GrAtlasTextContext::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
return;
}
sk_sp<GrTextStrike> currStrike = nullptr;
auto cache = blob->setupCache(runIndex, props, scalerContextFlags, paint, &viewMatrix);
sk_sp<GrTextStrike> currStrike;
SkGlyphCache* cache = blob->setupCache(runIndex, props, scalerContextFlags, paint, &viewMatrix);
SkFindAndPlaceGlyph::ProcessPosText(
paint.skPaint().getTextEncoding(), text, byteLength, offset, viewMatrix, pos,
scalarsPerPosition, paint.skPaint().getTextAlign(), cache.get(),
scalarsPerPosition, paint.skPaint().getTextAlign(), cache,
[&](const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
position += rounding;
BmpAppendGlyph(blob, runIndex, glyphCache, &currStrike, glyph,
SkScalarFloorToScalar(position.fX),
SkScalarFloorToScalar(position.fY),
paint.filteredPremulColor(), cache.get(), SK_Scalar1);
paint.filteredPremulColor(), cache, SK_Scalar1);
});
SkGlyphCache::AttachCache(cache);
}
void GrAtlasTextContext::DrawBmpTextAsPaths(GrAtlasTextBlob* blob, int runIndex,
@ -505,7 +508,7 @@ void GrAtlasTextContext::DrawBmpPosTextAsPaths(GrAtlasTextBlob* blob, int runInd
pathPaint.isDevKernText(),
true);
SkAutoGlyphCache autoCache(pathPaint, &props, nullptr);
SkGlyphCache* cache = autoCache.get();
SkGlyphCache* cache = autoCache.getCache();
const char* stop = text + byteLength;
const char* lastText = text;
@ -690,49 +693,42 @@ void GrAtlasTextContext::drawDFText(GrAtlasTextBlob* blob, int runIndex,
// passed-in scaler context flags. (It's only used when we fall-back to bitmap text).
SkScalerContext::CreateDescriptorAndEffectsUsingPaint(
skPaint, &props, SkScalerContextFlags::kNone, nullptr, &desc, &effects);
auto typeface = SkPaintPriv::GetTypefaceOrDefault(skPaint);
SkGlyphCache* origPaintCache =
SkGlyphCache::DetachCache(typeface, effects, desc.getDesc());
SkTArray<SkScalar> positions;
const char* textPtr = text;
SkScalar stopX = 0;
SkScalar stopY = 0;
{
auto tf = SkPaintPriv::GetTypefaceOrDefault(skPaint);
auto origPaintCache = SkGlyphCache::FindOrCreateStrikeExclusive(
*desc.getDesc(), effects, *tf);
const char* textPtr = text;
SkScalar origin = 0;
switch (skPaint.getTextAlign()) {
case SkPaint::kRight_Align:
origin = SK_Scalar1;
break;
case SkPaint::kCenter_Align:
origin = SK_ScalarHalf;
break;
case SkPaint::kLeft_Align:
origin = 0;
break;
}
SkAutoKern autokern;
const char* stop = text + byteLength;
while (textPtr < stop) {
// don't need x, y here, since all subpixel variants will have the
// same advance
const SkGlyph& glyph = glyphCacheProc(origPaintCache.get(), &textPtr);
SkScalar width = SkFloatToScalar(glyph.fAdvanceX) + autokern.adjust(glyph);
positions.push_back(stopX + origin * width);
SkScalar height = SkFloatToScalar(glyph.fAdvanceY);
positions.push_back(stopY + origin * height);
stopX += width;
stopY += height;
}
SkASSERT(textPtr == stop);
SkScalar origin = 0;
switch (skPaint.getTextAlign()) {
case SkPaint::kRight_Align: origin = SK_Scalar1; break;
case SkPaint::kCenter_Align: origin = SK_ScalarHalf; break;
case SkPaint::kLeft_Align: origin = 0; break;
}
SkAutoKern autokern;
const char* stop = text + byteLength;
while (textPtr < stop) {
// don't need x, y here, since all subpixel variants will have the
// same advance
const SkGlyph& glyph = glyphCacheProc(origPaintCache, &textPtr);
SkScalar width = SkFloatToScalar(glyph.fAdvanceX) + autokern.adjust(glyph);
positions.push_back(stopX + origin * width);
SkScalar height = SkFloatToScalar(glyph.fAdvanceY);
positions.push_back(stopY + origin * height);
stopX += width;
stopY += height;
}
SkASSERT(textPtr == stop);
SkGlyphCache::AttachCache(origPaintCache);
// now adjust starting point depending on alignment
SkScalar alignX = stopX;
SkScalar alignY = stopY;
@ -782,40 +778,40 @@ void GrAtlasTextContext::drawDFPosText(GrAtlasTextBlob* blob, int runIndex,
// We apply the fake-gamma by altering the distance in the shader, so we ignore the
// passed-in scaler context flags. (It's only used when we fall-back to bitmap text).
{
auto cache =
SkGlyphCache* cache =
blob->setupCache(runIndex, props, SkScalerContextFlags::kNone, dfPaint, nullptr);
SkPaint::GlyphCacheProc glyphCacheProc =
SkPaint::GlyphCacheProc glyphCacheProc =
SkPaint::GetGlyphCacheProc(dfPaint.getTextEncoding(), dfPaint.isDevKernText(), true);
const char* stop = text + byteLength;
const char* stop = text + byteLength;
SkPaint::Align align = dfPaint.getTextAlign();
SkScalar alignMul = SkPaint::kCenter_Align == align ? SK_ScalarHalf :
(SkPaint::kRight_Align == align ? SK_Scalar1 : 0);
while (text < stop) {
const char* lastText = text;
// the last 2 parameters are ignored
const SkGlyph& glyph = glyphCacheProc(cache.get(), &text);
SkPaint::Align align = dfPaint.getTextAlign();
SkScalar alignMul = SkPaint::kCenter_Align == align ? SK_ScalarHalf :
(SkPaint::kRight_Align == align ? SK_Scalar1 : 0);
while (text < stop) {
const char* lastText = text;
// the last 2 parameters are ignored
const SkGlyph& glyph = glyphCacheProc(cache, &text);
if (glyph.fWidth) {
SkPoint glyphPos(offset);
glyphPos.fX += pos[0] - SkFloatToScalar(glyph.fAdvanceX) * alignMul * textRatio;
glyphPos.fY += (2 == scalarsPerPosition ? pos[1] : 0) -
SkFloatToScalar(glyph.fAdvanceY) * alignMul * textRatio;
if (glyph.fWidth) {
SkPoint glyphPos(offset);
glyphPos.fX += pos[0] - SkFloatToScalar(glyph.fAdvanceX) * alignMul * textRatio;
glyphPos.fY += (2 == scalarsPerPosition ? pos[1] : 0) -
SkFloatToScalar(glyph.fAdvanceY) * alignMul * textRatio;
if (glyph.fMaskFormat != SkMask::kARGB32_Format) {
DfAppendGlyph(blob, runIndex, glyphCache, &currStrike, glyph, glyphPos.fX,
glyphPos.fY, paint.filteredPremulColor(), cache.get(), textRatio);
} else {
// can't append color glyph to SDF batch, send to fallback
fallbackTextHelper.appendText(glyph, SkToInt(text - lastText), lastText,
glyphPos);
}
pos += scalarsPerPosition;
if (glyph.fMaskFormat != SkMask::kARGB32_Format) {
DfAppendGlyph(blob, runIndex, glyphCache, &currStrike, glyph, glyphPos.fX,
glyphPos.fY, paint.filteredPremulColor(), cache, textRatio);
} else {
// can't append color glyph to SDF batch, send to fallback
fallbackTextHelper.appendText(glyph, SkToInt(text - lastText), lastText, glyphPos);
}
}
pos += scalarsPerPosition;
}
SkGlyphCache::AttachCache(cache);
fallbackTextHelper.drawText(blob, runIndex, glyphCache, props, paint, scalerContextFlags);
}
@ -887,7 +883,7 @@ void GrAtlasTextContext::FallbackTextHelper::drawText(GrAtlasTextBlob* blob, int
if (fFallbackTxt.count()) {
blob->initOverride(runIndex);
blob->setHasBitmap();
SkExclusiveStrikePtr cache;
SkGlyphCache* cache = nullptr;
const SkPaint& skPaint = paint.skPaint();
SkPaint::GlyphCacheProc glyphCacheProc =
SkPaint::GetGlyphCacheProc(skPaint.getTextEncoding(),
@ -917,12 +913,14 @@ void GrAtlasTextContext::FallbackTextHelper::drawText(GrAtlasTextBlob* blob, int
const char* stop = text + fFallbackTxt.count();
SkPoint* glyphPos = fFallbackPos.begin();
while (text < stop) {
const SkGlyph& glyph = glyphCacheProc(cache.get(), &text);
const SkGlyph& glyph = glyphCacheProc(cache, &text);
GrAtlasTextContext::BmpAppendGlyph(blob, runIndex, glyphCache, &currStrike, glyph,
glyphPos->fX, glyphPos->fY, textColor,
cache.get(), textRatio);
cache, textRatio);
glyphPos++;
}
SkGlyphCache::AttachCache(cache);
}
}

2
src/gpu/text/GrTextUtils.cpp
View File

@ -81,7 +81,7 @@ bool GrTextUtils::PathTextIter::next(const SkGlyph** skGlyph, const SkPath** pat
SkASSERT(path);
SkASSERT(xpos);
if (fText < fStop) {
const SkGlyph& glyph = fGlyphCacheProc(fCache.get(), &fText);
const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
fXPos += (fPrevAdvance + fAutoKern.adjust(glyph)) * fScale;
SkASSERT(0 == fXYIndex || 1 == fXYIndex);

6
src/xps/SkXPSDevice.cpp
View File

@ -1877,7 +1877,7 @@ HRESULT SkXPSDevice::CreateTypefaceUse(const SkPaint& paint,
newTypefaceUse.xpsFont = xpsFontResource.release();
SkAutoGlyphCache agc(paint, &this->surfaceProps(), &SkMatrix::I());
SkGlyphCache* glyphCache = agc.get();
SkGlyphCache* glyphCache = agc.getCache();
unsigned int glyphCount = glyphCache->getGlyphCount();
newTypefaceUse.glyphsUsed = new SkBitSet(glyphCount);
@ -2064,7 +2064,7 @@ void SkXPSDevice::drawText(const void* text, size_t byteLen,
const SkMatrix& matrix = SkMatrix::I();
SkAutoGlyphCache autoCache(paint, &this->surfaceProps(), &matrix);
SkGlyphCache* cache = autoCache.get();
SkGlyphCache* cache = autoCache.getCache();
// Advance width and offsets for glyphs measured in hundredths of the font em size
// (XPS Spec 5.1.3).
@ -2122,7 +2122,7 @@ void SkXPSDevice::drawPosText(const void* text, size_t byteLen,
const SkMatrix& matrix = SkMatrix::I();
SkAutoGlyphCache autoCache(paint, &this->surfaceProps(), &matrix);
SkGlyphCache* cache = autoCache.get();
SkGlyphCache* cache = autoCache.getCache();
// Advance width and offsets for glyphs measured in hundredths of the font em size
// (XPS Spec 5.1.3).