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
+
+public:
+    static GlyphPathRange* Create(GrContext* context,
+                                  SkGlyphCache* cache,
+                                  const SkStrokeRec& stroke) {
+        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),
+                                  GrPathRange::resourceType(), 0);
+        SkAutoTUnref<GlyphPathRange> glyphs(
+            static_cast<GlyphPathRange*>(context->findAndRefCachedResource(resourceKey)));
+
+        if (NULL == glyphs ||
+            !glyphs->fDesc->equals(cache->getDescriptor() /*checksum collision*/)) {
+            glyphs.reset(SkNEW_ARGS(GlyphPathRange, (context, cache->getDescriptor(), stroke)));
+            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 = 0 != (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(GrContext* context, const SkDescriptor& desc, const SkStrokeRec& stroke)
+        : fDesc(desc.copy())
+        // 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.
+        , fPathRange(context->getGpu()->createPathRange(kMaxGlyphCount, stroke)) {
+        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
+    SkAutoTUnref<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();
+    }
+
+    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, GrDrawTarget::kAffine_PathTransformType,
+                           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();
 }