Add a GrPathRange class

src/gpu/GrStencilAndCoverTextContext.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrStencilAndCoverTextContext.h"
 #include "GrDrawTarget.h"
-#include "GrFontScaler.h"
 #include "GrGpu.h"
 #include "GrPath.h"
-#include "GrTextStrike.h"
-#include "GrTextStrike_impl.h"
+#include "GrPathRange.h"
 #include "SkAutoKern.h"
 #include "SkDraw.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkGpuDevice.h"
 #include "SkPath.h"
 #include "SkTextMapStateProc.h"
 
-static const int kMaxReservedGlyphs = 64;
+class GrStencilAndCoverTextContext::GlyphPathRange : public GrCacheable {
+    static const int kMaxGlyphCount = 1 << 16; // Glyph IDs are uint16_t's
+    static const int kGlyphGroupSize = 16; // Glyphs get tracked in groups of 16
+    static const bool kIsWrapped = false;
+
+public:
+    static GlyphPathRange* Create(GrContext* context,
+                                  SkGlyphCache* cache,
+                                  const SkStrokeRec& stroke) {
+        static const GrResourceKey::ResourceType gGlyphPathRangeType =
+            GrResourceKey::GenerateResourceType();

[bsalomon, 2014/07/17 17:27:28]

I think the type should come from GrPathRange itself. The domain below will
guarantee that the key won't collide with keys for other path arrays from other
domains. It'll fit better in with the future evolution of the cache.

[Chris Dalton, 2014/07/17 18:15:19]

Acknowledged.

+        static const GrCacheID::Domain gGlyphPathRangeDomain = GrCacheID::GenerateDomain();
+
+        GrCacheID::Key key;
+        key.fData32[0] = cache->getDescriptor().getChecksum();
+        key.fData32[1] = cache->getScalerContext()->getTypeface()->uniqueID();
+        key.fData64[1] = GrPath::ComputeStrokeKey(stroke);
+
+        GrResourceKey resourceKey(GrCacheID(gGlyphPathRangeDomain, key), gGlyphPathRangeType, 0);
+        SkAutoTUnref<GlyphPathRange> glyphs(
+            static_cast<GlyphPathRange*>(context->findAndRefCachedResource(resourceKey)));
+
+        if (NULL == glyphs ||
+            !glyphs->fDesc->equals(cache->getDescriptor() /*checksum collision*/)) {
+            GrGpu* const gpu = context->getGpu();
+            // We reserve a range of kMaxGlyphCount paths because of fallbacks fonts. We
+            // can't know exactly how many glyphs we might need without preloading every
+            // fallback, which we don't want to do at this point.
+            SkAutoTUnref<GrPathRange> pathRange(gpu->createPathRange(kMaxGlyphCount, stroke));
+            glyphs.reset(SkNEW_ARGS(GlyphPathRange, (cache->getDescriptor(), pathRange)));
+            context->addResourceToCache(resourceKey, glyphs);
+        }
+
+        return glyphs.detach();
+    }
+
+    const GrPathRange* pathRange() const { return fPathRange.get(); }
+
+    void preloadGlyph(uint16_t glyphID, SkGlyphCache* cache) {
+        const uint16_t groupIndex = glyphID / kGlyphGroupSize;
+        const uint16_t groupByte = groupIndex >> 3;
+        const uint8_t groupBit = 1 << (groupIndex & 7);
+
+        const bool hasGlyph = fLoadedGlyphs[groupByte] & groupBit;
+        if (hasGlyph) {
+            return;
+        }
+
+        // We track which glyphs are loaded in groups of kGlyphGroupSize. To
+        // mark a glyph loaded we need to load the entire group.
+        const uint16_t groupFirstID = groupIndex * kGlyphGroupSize;
+        const uint16_t groupLastID = groupFirstID + kGlyphGroupSize - 1;
+        SkPath skPath;
+        for (int id = groupFirstID; id <= groupLastID; ++id) {
+            const SkGlyph& skGlyph = cache->getGlyphIDMetrics(id);
+            if (const SkPath* skPath = cache->findPath(skGlyph)) {
+                fPathRange->initAt(id, *skPath);
+            } // GrGpu::drawPaths will silently ignore undefined paths.
+        }
+
+        fLoadedGlyphs[groupByte] |= groupBit;
+        this->didChangeGpuMemorySize();
+    }
+
+    // GrCacheable overrides
+    virtual size_t gpuMemorySize() const SK_OVERRIDE { return fPathRange->gpuMemorySize(); }
+    virtual bool isValidOnGpu() const SK_OVERRIDE { return fPathRange->isValidOnGpu(); }
+
+private:
+    GlyphPathRange(const SkDescriptor& desc, GrPathRange* pathRange)
+        : fDesc(desc.copy())
+        , fPathRange(pathRange) {
+        memset(fLoadedGlyphs, 0, sizeof(fLoadedGlyphs));
+    }
+
+    ~GlyphPathRange() {
+        SkDescriptor::Free(fDesc);
+    }
+
+    static const int kMaxGroupCount = (kMaxGlyphCount + (kGlyphGroupSize - 1)) / kGlyphGroupSize;
+    SkDescriptor* const fDesc;
+    uint8_t fLoadedGlyphs[(kMaxGroupCount + 7) >> 3]; // One bit per glyph group
+    SkRefPtr<GrPathRange> fPathRange;
+
+    typedef GrCacheable INHERITED;
+};
+
 
 GrStencilAndCoverTextContext::GrStencilAndCoverTextContext(
     GrContext* context, const SkDeviceProperties& properties)
     : GrTextContext(context, properties)
-    , fStroke(SkStrokeRec::kFill_InitStyle) {
+    , fStroke(SkStrokeRec::kFill_InitStyle)
+    , fPendingGlyphCount(0) {
 }
 
 GrStencilAndCoverTextContext::~GrStencilAndCoverTextContext() {
 }
 
 void GrStencilAndCoverTextContext::drawText(const GrPaint& paint,
                                             const SkPaint& skPaint,
                                             const char text[],
                                             size_t byteLength,
                                             SkScalar x, SkScalar y) {
@@ skipping 27 matching lines @@
     if (fNeedsDeviceSpaceGlyphs) {
         SkPoint loc;
         fGlyphTransform.mapXY(x, y, &loc);
         x = loc.fX;
         y = loc.fY;
         glyphCacheTransform = &fGlyphTransform;
     }
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
     SkAutoGlyphCache autoCache(fSkPaint, &fDeviceProperties, glyphCacheTransform);
-    SkGlyphCache* cache = autoCache.getCache();
-    GrFontScaler* scaler = GetGrFontScaler(cache);
-    GrTextStrike* strike =
-        fContext->getFontCache()->getStrike(scaler, true);
+    fGlyphCache = autoCache.getCache();
+    fGlyphs = GlyphPathRange::Create(fContext, fGlyphCache, fStroke);
 
     const char* stop = text + byteLength;
 
     // Measure first if needed.
     if (fSkPaint.getTextAlign() != SkPaint::kLeft_Align) {
         SkFixed    stopX = 0;
         SkFixed    stopY = 0;
 
         const char* textPtr = text;
         while (textPtr < stop) {
             // We don't need x, y here, since all subpixel variants will have the
             // same advance.
-            const SkGlyph& glyph = glyphCacheProc(cache, &textPtr, 0, 0);
+            const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &textPtr, 0, 0);
 
             stopX += glyph.fAdvanceX;
             stopY += glyph.fAdvanceY;
         }
         SkASSERT(textPtr == stop);
 
         SkScalar alignX = SkFixedToScalar(stopX) * fTextRatio;
         SkScalar alignY = SkFixedToScalar(stopY) * fTextRatio;
 
         if (fSkPaint.getTextAlign() == SkPaint::kCenter_Align) {
             alignX = SkScalarHalf(alignX);
             alignY = SkScalarHalf(alignY);
         }
 
         x -= alignX;
         y -= alignY;
     }
 
     SkAutoKern autokern;
 
     SkFixed fixedSizeRatio = SkScalarToFixed(fTextRatio);
 
     SkFixed fx = SkScalarToFixed(x);
     SkFixed fy = SkScalarToFixed(y);
     while (text < stop) {
-        const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
+        const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
         fx += SkFixedMul_portable(autokern.adjust(glyph), fixedSizeRatio);
         if (glyph.fWidth) {
-            this->appendGlyph(GrGlyph::Pack(glyph.getGlyphID(),
-                                            glyph.getSubXFixed(),
-                                            glyph.getSubYFixed()),
-                              SkPoint::Make(
-                                  SkFixedToScalar(fx),
-                                  SkFixedToScalar(fy)),
-                              strike,
-                              scaler);
+            this->appendGlyph(glyph.getGlyphID(), SkFixedToScalar(fx), SkFixedToScalar(fy));
         }
 
         fx += SkFixedMul_portable(glyph.fAdvanceX, fixedSizeRatio);
         fy += SkFixedMul_portable(glyph.fAdvanceY, fixedSizeRatio);
     }
 
     this->finish();
 }
 
 void GrStencilAndCoverTextContext::drawPosText(const GrPaint& paint,
@@ skipping 18 matching lines @@
     // glyphs. That already uses glyph cache without device transforms. Device
     // transform is not part of SkPaint::measureText API, and thus we use the
     // same glyphs as what were measured.
     fGlyphTransform.reset();
 
     this->init(paint, skPaint, byteLength);
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     SkAutoGlyphCache autoCache(fSkPaint, &fDeviceProperties, NULL);
-    SkGlyphCache* cache = autoCache.getCache();
-    GrFontScaler* scaler = GetGrFontScaler(cache);
-    GrTextStrike* strike =
-        fContext->getFontCache()->getStrike(scaler, true);
+    fGlyphCache = autoCache.getCache();
+    fGlyphs = GlyphPathRange::Create(fContext, fGlyphCache, fStroke);
 
     const char* stop = text + byteLength;
     SkTextAlignProcScalar alignProc(fSkPaint.getTextAlign());
     SkTextMapStateProc tmsProc(SkMatrix::I(), constY, scalarsPerPosition);
 
     if (SkPaint::kLeft_Align == fSkPaint.getTextAlign()) {
         while (text < stop) {
             SkPoint loc;
             tmsProc(pos, &loc);
-            const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
+            const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
             if (glyph.fWidth) {
-                this->appendGlyph(GrGlyph::Pack(glyph.getGlyphID(),
-                                                glyph.getSubXFixed(),
-                                                glyph.getSubYFixed()),
-                                  loc,
-                                  strike,
-                                  scaler);
+                this->appendGlyph(glyph.getGlyphID(), loc.x(), loc.y());
             }
             pos += scalarsPerPosition;
         }
     } else {
         while (text < stop) {
-            const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
+            const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
             if (glyph.fWidth) {
                 SkPoint tmsLoc;
                 tmsProc(pos, &tmsLoc);
                 SkPoint loc;
                 alignProc(tmsLoc, glyph, &loc);
 
-                this->appendGlyph(GrGlyph::Pack(glyph.getGlyphID(),
-                                                glyph.getSubXFixed(),
-                                                glyph.getSubYFixed()),
-                                  loc,
-                                  strike,
-                                  scaler);
-
+                this->appendGlyph(glyph.getGlyphID(), loc.x(), loc.y());
             }
             pos += scalarsPerPosition;
         }
     }
 
     this->finish();
 }
 
 bool GrStencilAndCoverTextContext::canDraw(const SkPaint& paint) {
     if (paint.getRasterizer()) {
@@ skipping 81 matching lines @@
     GR_STATIC_CONST_SAME_STENCIL(kStencilPass,
                                  kZero_StencilOp,
                                  kZero_StencilOp,
                                  kNotEqual_StencilFunc,
                                  0xffff,
                                  0x0000,
                                  0xffff);
 
     *fDrawTarget->drawState()->stencil() = kStencilPass;
 
-    size_t reserveAmount;
-    switch (skPaint.getTextEncoding()) {
-        default:
-            SkASSERT(false);
-        case SkPaint::kUTF8_TextEncoding:
-            reserveAmount = textByteLength;
-            break;
-        case SkPaint::kUTF16_TextEncoding:
-            reserveAmount = textByteLength / 2;
-            break;
-        case SkPaint::kUTF32_TextEncoding:
-        case SkPaint::kGlyphID_TextEncoding:
-            reserveAmount = textByteLength / 4;
-            break;
-    }
-    fPaths.setReserve(reserveAmount);
-    fTransforms.setReserve(reserveAmount);
+    SkASSERT(0 == fPendingGlyphCount);
 }
 
-inline void GrStencilAndCoverTextContext::appendGlyph(GrGlyph::PackedID glyphID,
-                                                      const SkPoint& pos,
-                                                      GrTextStrike* strike,
-                                                      GrFontScaler* scaler) {
-    GrGlyph* glyph = strike->getGlyph(glyphID, scaler);
-    if (NULL == glyph || glyph->fBounds.isEmpty()) {
+inline void GrStencilAndCoverTextContext::appendGlyph(uint16_t glyphID, float x, float y) {
+    if (fPendingGlyphCount >= kGlyphBufferSize) {
+        this->flush();
+        SkASSERT(0 == fPendingGlyphCount);
+    }
+
+    fGlyphs->preloadGlyph(glyphID, fGlyphCache);
+
+    fIndexBuffer[fPendingGlyphCount] = glyphID;
+    fTransformBuffer[6 * fPendingGlyphCount + 0] = fTextRatio;
+    fTransformBuffer[6 * fPendingGlyphCount + 1] = 0;
+    fTransformBuffer[6 * fPendingGlyphCount + 2] = x;
+    fTransformBuffer[6 * fPendingGlyphCount + 3] = 0;
+    fTransformBuffer[6 * fPendingGlyphCount + 4] = fTextRatio;
+    fTransformBuffer[6 * fPendingGlyphCount + 5] = y;
+
+    ++fPendingGlyphCount;
+}
+
+void GrStencilAndCoverTextContext::flush() {
+    if (0 == fPendingGlyphCount) {
         return;
     }
 
-    if (scaler->getGlyphPath(glyph->glyphID(), &fTmpPath)) {
-        if (!fTmpPath.isEmpty()) {
-            *fPaths.append() = fContext->createPath(fTmpPath, fStroke);
-            SkMatrix* t = fTransforms.append();
-            t->setTranslate(pos.fX, pos.fY);
-            t->preScale(fTextRatio, fTextRatio);
-        }
-    }
+    fDrawTarget->drawPaths(fGlyphs->pathRange(), fIndexBuffer, fPendingGlyphCount,
+                           fTransformBuffer, kAffine_GrTransformFormat,
+                           SkPath::kWinding_FillType);
+
+    fPendingGlyphCount = 0;
 }
 
 void GrStencilAndCoverTextContext::finish() {
-    if (fPaths.count() > 0) {
-        fDrawTarget->drawPaths(static_cast<size_t>(fPaths.count()),
-                               fPaths.begin(), fTransforms.begin(),
-                               SkPath::kWinding_FillType, fStroke.getStyle());
+    this->flush();
 
-        for (int i = 0; i < fPaths.count(); ++i) {
-            fPaths[i]->unref();
-        }
-        if (fPaths.count() > kMaxReservedGlyphs) {
-            fPaths.reset();
-            fTransforms.reset();
-        } else {
-            fPaths.rewind();
-            fTransforms.rewind();
-        }
-    }
-    fTmpPath.reset();
+    SkSafeUnref(fGlyphs);
+    fGlyphs = NULL;
+    fGlyphCache = NULL;
 
     fDrawTarget->drawState()->stencil()->setDisabled();
     fStateRestore.set(NULL);
     if (fNeedsDeviceSpaceGlyphs) {
         fContext->setMatrix(fGlyphTransform);
     }
     GrTextContext::finish();
 }