Avoid regenerating cached textblobs on integer scrolls

src/gpu/GrAtlasTextContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrAtlasTextContext.h"
 
 #include "GrAtlas.h"
 #include "GrBatch.h"
@@ skipping 73 matching lines @@
 }
 
 bool GrAtlasTextContext::canDraw(const GrRenderTarget*,
                                  const GrClip&,
                                  const GrPaint&,
                                  const SkPaint& skPaint,
                                  const SkMatrix& viewMatrix) {
     return !SkDraw::ShouldDrawTextAsPaths(skPaint, viewMatrix);
 }
 
-bool GrAtlasTextContext::MustRegenerateBlob(const BitmapTextBlob& blob, const SkPaint& paint,
+bool GrAtlasTextContext::MustRegenerateBlob(SkScalar* outTransX, SkScalar* outTransY,
+                                            const BitmapTextBlob& blob, const SkPaint& paint,
                                             const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
-    // We always regenerate blobs with patheffects or mask filters we could cache these
-    // TODO find some way to cache the maskfilter / patheffects on the textblob
-    return !blob.fViewMatrix.cheapEqualTo(viewMatrix) || blob.fX != x || blob.fY != y ||
-            paint.getMaskFilter() || paint.getPathEffect() || paint.getStyle() != blob.fStyle;
+    // Color can affect the mask
+    // TODO we can adjust the color within specific gamma slots
+    if (blob.fColor != paint.getColor()) {
+        return true;
+    }
+
+    if (blob.fViewMatrix.hasPerspective() != viewMatrix.hasPerspective()) {
+        return true;
+    }
+
+    if (blob.fViewMatrix.hasPerspective() && !blob.fViewMatrix.cheapEqualTo(viewMatrix)) {
+        return true;
+    }
+
+    if (blob.fViewMatrix.getScaleX() != viewMatrix.getScaleX() ||
+        blob.fViewMatrix.getScaleY() != viewMatrix.getScaleY() ||
+        blob.fViewMatrix.getSkewX() != viewMatrix.getSkewX() ||
+        blob.fViewMatrix.getSkewY() != viewMatrix.getSkewY()) {
+        return true;
+    }
+
+    // We can update the positions in the cachedtextblobs without regenerating the whole blob, but
+    // only for integer translations.
+    // This cool bit of math will determine the necessary translation to apply to the already
+    // generated vertex coordinates to move them to the correct position
+    SkScalar transX = viewMatrix.getTranslateX() +
+                      viewMatrix.getScaleX() * (x - blob.fX) +
+                      viewMatrix.getSkewX() * (y - blob.fY) -
+                      blob.fViewMatrix.getTranslateX();
+    SkScalar transY = viewMatrix.getTranslateY() +
+                      viewMatrix.getSkewY() * (x - blob.fX) +
+                      viewMatrix.getScaleY() * (y - blob.fY) -
+                      blob.fViewMatrix.getTranslateY();
+    if (SkScalarFraction(transX) > SK_ScalarNearlyZero ||
+        SkScalarFraction(transY) > SK_ScalarNearlyZero) {
+        return true;
+    }
+
+#ifdef SK_DEBUG
+    static const SkScalar kMinDiscernableTranslation = 0.0625;
+    // As a safeguard when debugging, we store the total error across all translations and print if
+    // the error becomes discernable.  This is pretty unlikely to occur given the tight bounds above
+    // on translation
+    blob.fTotalXError += SkScalarAbs(SkScalarFraction(transX));
+    blob.fTotalYError += SkScalarAbs(SkScalarFraction(transY));
+    if (blob.fTotalXError > kMinDiscernableTranslation ||
+        blob.fTotalYError > kMinDiscernableTranslation) {
+        SkDebugf("Exceeding error threshold for bitmap text translation");
+    }
+#endif
+    (*outTransX) = transX;
+    (*outTransY) = transY;
+    return false;
 }
 
 
 inline SkGlyphCache* GrAtlasTextContext::setupCache(BitmapTextBlob::Run* run,
                                                     const SkPaint& skPaint,
                                                     const SkMatrix& viewMatrix) {
     skPaint.getScalerContextDescriptor(&run->fDescriptor, &fDeviceProperties, &viewMatrix, false);
     run->fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
     return SkGlyphCache::DetachCache(run->fTypeface, run->fDescriptor.getDesc());
 }
 
 void GrAtlasTextContext::drawTextBlob(GrRenderTarget* rt, const GrClip& clip,
                                       const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                       const SkTextBlob* blob, SkScalar x, SkScalar y,
                                       SkDrawFilter* drawFilter, const SkIRect& clipBounds) {
     uint32_t uniqueID = blob->uniqueID();
-    BitmapTextBlob* cacheBlob = fCache->find(uniqueID);
+    SkAutoTUnref<BitmapTextBlob> cacheBlob;
+    // TODO start caching these, mix bits into the key
+    bool canCache = !(skPaint.getPathEffect() ||
+                      skPaint.getMaskFilter() ||
+                      skPaint.getColorFilter() ||
+                      skPaint.getStyle() != SkPaint::kFill_Style ||
+                      drawFilter);
+
+    if (canCache) {
+        cacheBlob.reset(SkSafeRef(fCache->find(uniqueID)));
+    }
+
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
+    SkScalar transX = 0.f;
+    SkScalar transY = 0.f;
+
     if (cacheBlob) {
-        if (MustRegenerateBlob(*cacheBlob, skPaint, viewMatrix, x, y)) {
+        if (MustRegenerateBlob(&transX, &transY, *cacheBlob, skPaint, viewMatrix, x, y)) {
             // We have to remake the blob because changes may invalidate our masks.
             // TODO we could probably get away reuse most of the time if the pointer is unique,
             // but we'd have to clear the subrun information
             fCache->remove(cacheBlob);
-            cacheBlob = fCache->createCachedBlob(blob, kGrayTextVASize);
+            cacheBlob.reset(SkRef(fCache->createCachedBlob(blob, kGrayTextVASize)));
             this->regenerateTextBlob(cacheBlob, skPaint, viewMatrix, blob, x, y, drawFilter,
                                      clipRect);
         } else {
+            // If we can reuse the blob, then make sure we update the blob's viewmatrix and x/y
+            // offsets to reflect the results of any translations we may apply in generateGeometry
+            cacheBlob->fViewMatrix = viewMatrix;
+            cacheBlob->fX = x;
+            cacheBlob->fY = y;
             fCache->makeMRU(cacheBlob);
         }
     } else {
-        cacheBlob = fCache->createCachedBlob(blob, kGrayTextVASize);
+        if (canCache) {
+            cacheBlob.reset(SkRef(fCache->createCachedBlob(blob, kGrayTextVASize)));
+        } else {
+            cacheBlob.reset(fCache->createBlob(blob, kGrayTextVASize));
+        }
         this->regenerateTextBlob(cacheBlob, skPaint, viewMatrix, blob, x, y, drawFilter, clipRect);
     }
 
     // Though for the time being runs in the textblob can override the paint, they only touch font
     // info.
     GrPaint grPaint;
     SkPaint2GrPaintShader(fContext, rt, skPaint, viewMatrix, true, &grPaint);
 
     this->flush(fContext->getTextTarget(), blob, cacheBlob, rt, skPaint, grPaint, drawFilter,
-                clip, viewMatrix, clipBounds, x, y);
+                clip, viewMatrix, clipBounds, x, y, transX, transY);
 }
 
 void GrAtlasTextContext::regenerateTextBlob(BitmapTextBlob* cacheBlob,
                                             const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                             const SkTextBlob* blob, SkScalar x, SkScalar y,
                                             SkDrawFilter* drawFilter, const SkIRect& clipRect) {
     cacheBlob->fViewMatrix = viewMatrix;
     cacheBlob->fX = x;
     cacheBlob->fY = y;
+    cacheBlob->fColor = skPaint.getColor();
     cacheBlob->fStyle = skPaint.getStyle();
 
     // Regenerate textblob
     SkPaint runPaint = skPaint;
     SkTextBlob::RunIterator it(blob);
     for (int run = 0; !it.done(); it.next(), run++) {
         int glyphCount = it.glyphCount();
         size_t textLen = glyphCount * sizeof(uint16_t);
         const SkPoint& offset = it.offset();
         // applyFontToPaint() always overwrites the exact same attributes,
@@ skipping 15 matching lines @@
             PerSubRunInfo& newRun = cacheBlob->fRuns[run].fSubRunInfo.back();
             PerSubRunInfo& lastRun = cacheBlob->fRuns[run - 1].fSubRunInfo.back();
 
             newRun.fVertexStartIndex = lastRun.fVertexEndIndex;
             newRun.fVertexEndIndex = lastRun.fVertexEndIndex;
 
             newRun.fGlyphStartIndex = lastRun.fGlyphEndIndex;
             newRun.fGlyphEndIndex = lastRun.fGlyphEndIndex;
         }
 
-        if (SkDraw::ShouldDrawTextAsPaths(skPaint, viewMatrix)) {
+        if (SkDraw::ShouldDrawTextAsPaths(runPaint, viewMatrix)) {
             cacheBlob->fRuns[run].fDrawAsPaths = true;
             continue;
         }
         cacheBlob->fRuns[run].fDrawAsPaths = false;
 
         switch (it.positioning()) {
             case SkTextBlob::kDefault_Positioning:
                 this->internalDrawText(cacheBlob, run, cache, runPaint, viewMatrix,
                                        (const char *)it.glyphs(), textLen,
                                        x + offset.x(), y + offset.y(), clipRect);
@@ skipping 330 matching lines @@
         return;
     }
 
     int x = vx + glyph->fBounds.fLeft;
     int y = vy + glyph->fBounds.fTop;
 
     // keep them as ints until we've done the clip-test
     int width = glyph->fBounds.width();
     int height = glyph->fBounds.height();
 
+#if 0
+    // Not checking the clip bounds might introduce a performance regression.  However, its not
+    // clear if this is still true today with the larger tiles we use in Chrome.  For repositionable
+    // blobs, we want to make sure we have all of the glyphs, so clipping them out is not ideal.
+    // We could store the cliprect in the key, but then we'd lose the ability to do integer scrolls
+    // TODO verify this
     // check if we clipped out
     if (clipRect.quickReject(x, y, x + width, y + height)) {
         return;
     }
+#endif
 
     // If the glyph is too large we fall back to paths
     if (fCurrStrike->glyphTooLargeForAtlas(glyph)) {
         if (NULL == glyph->fPath) {
             SkPath* path = SkNEW(SkPath);
             if (!scaler->getGlyphPath(glyph->glyphID(), path)) {
                 // flag the glyph as being dead?
                 SkDELETE(path);
                 return;
             }
@@ skipping 38 matching lines @@
     intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices + subRun->fVertexEndIndex);
 
     // V0
     SkPoint* position = reinterpret_cast<SkPoint*>(vertex);
     position->set(r.fLeft, r.fTop);
     if (kA8_GrMaskFormat == format) {
         SkColor* colorPtr = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
         *colorPtr = color;
     }
     vertex += vertexStride;
-
     // V1
     position = reinterpret_cast<SkPoint*>(vertex);
     position->set(r.fLeft, r.fBottom);
     if (kA8_GrMaskFormat == format) {
         SkColor* colorPtr = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
         *colorPtr = color;
     }
     vertex += vertexStride;
 
     // V2
@@ skipping 21 matching lines @@
 public:
     typedef GrAtlasTextContext::BitmapTextBlob Blob;
     typedef Blob::Run Run;
     typedef Run::SubRunInfo TextInfo;
     struct Geometry {
         Geometry() {}
         Geometry(const Geometry& geometry)
             : fBlob(SkRef(geometry.fBlob.get()))
             , fRun(geometry.fRun)
             , fSubRun(geometry.fSubRun)
-            , fColor(geometry.fColor) {}
+            , fColor(geometry.fColor)
+            , fTransX(geometry.fTransX)
+            , fTransY(geometry.fTransY) {}
         SkAutoTUnref<Blob> fBlob;
         int fRun;
         int fSubRun;
         GrColor fColor;
+        SkScalar fTransX;
+        SkScalar fTransY;
     };
 
     static GrBatch* Create(const Geometry& geometry, GrMaskFormat maskFormat,
                            int glyphCount, GrBatchFontCache* fontCache) {
         return SkNEW_ARGS(BitmapTextBatch, (geometry, maskFormat, glyphCount, fontCache));
     }
 
     const char* name() const override { return "BitmapTextBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
@@ skipping 99 matching lines @@
         int instancesToFlush = 0;
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
             Blob* blob = args.fBlob;
             Run& run = blob->fRuns[args.fRun];
             TextInfo& info = run.fSubRunInfo[args.fSubRun];
 
             uint64_t currentAtlasGen = fFontCache->atlasGeneration(fMaskFormat);
             bool regenerateTextureCoords = info.fAtlasGeneration != currentAtlasGen;
             bool regenerateColors = kA8_GrMaskFormat == fMaskFormat && run.fColor != args.fColor;
+            bool regeneratePositions = args.fTransX != 0.f || args.fTransY != 0.f;
             int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
 
             // We regenerate both texture coords and colors in the blob itself, and update the
             // atlas generation.  If we don't end up purging any unused plots, we can avoid
             // regenerating the coords.  We could take a finer grained approach to updating texture
             // coords but its not clear if the extra bookkeeping would offset any gains.
             // To avoid looping over the glyphs twice, we do one loop and conditionally update color
             // or coords as needed.  One final note, if we have to break a run for an atlas eviction
             // then we can't really trust the atlas has all of the correct data.  Atlas evictions
             // should be pretty rare, so we just always regenerate in those cases
-            if (regenerateTextureCoords || regenerateColors) {
+            if (regenerateTextureCoords || regenerateColors || regeneratePositions) {
                 // first regenerate texture coordinates / colors if need be
                 const SkDescriptor* desc = NULL;
                 SkGlyphCache* cache = NULL;
                 GrFontScaler* scaler = NULL;
                 GrBatchTextStrike* strike = NULL;
                 bool brokenRun = false;
                 if (regenerateTextureCoords) {
                     info.fBulkUseToken.reset();
                     desc = run.fDescriptor.getDesc();
                     cache = SkGlyphCache::DetachCache(run.fTypeface, desc);
@@ skipping 33 matching lines @@
                         this->regenerateTextureCoords(glyph, vertex, vertexStride);
                     }
 
                     if (regenerateColors) {
                         intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
                         vertex += info.fVertexStartIndex;
                         vertex += vertexStride * glyphIdx * kVerticesPerGlyph + sizeof(SkPoint);
                         this->regenerateColors(vertex, vertexStride, args.fColor);
                     }
 
+                    if (regeneratePositions) {
+                        intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
+                        vertex += info.fVertexStartIndex;
+                        vertex += vertexStride * glyphIdx * kVerticesPerGlyph;
+                        SkScalar transX = args.fTransX;
+                        SkScalar transY = args.fTransY;
+                        this->regeneratePositions(vertex, vertexStride, transX, transY);
+                    }
                     instancesToFlush++;
                 }
 
+                // We my have changed the color so update it here
+                run.fColor = args.fColor;
                 if (regenerateTextureCoords) {
                     SkGlyphCache::AttachCache(cache);
                     info.fAtlasGeneration = brokenRun ? GrBatchAtlas::kInvalidAtlasGeneration :
                                                         fFontCache->atlasGeneration(fMaskFormat);
                 }
             } else {
                 instancesToFlush += glyphCount;
 
                 // set use tokens for all of the glyphs in our subrun.  This is only valid if we
                 // have a valid atlas generation
@@ skipping 59 matching lines @@
     }
 
     void regenerateColors(intptr_t vertex, size_t vertexStride, GrColor color) {
         for (int i = 0; i < kVerticesPerGlyph; i++) {
             SkColor* vcolor = reinterpret_cast<SkColor*>(vertex);
             *vcolor = color;
             vertex += vertexStride;
         }
     }
 
+    void regeneratePositions(intptr_t vertex, size_t vertexStride, SkScalar transX,
+                             SkScalar transY) {
+        for (int i = 0; i < kVerticesPerGlyph; i++) {
+            SkPoint* point = reinterpret_cast<SkPoint*>(vertex);
+            point->fX += transX;
+            point->fY += transY;
+            vertex += vertexStride;
+        }
+    }
+
     void initDraw(GrBatchTarget* batchTarget,
                   const GrGeometryProcessor* gp,
                   const GrPipeline* pipeline) {
         batchTarget->initDraw(gp, pipeline);
 
         // TODO remove this when batch is everywhere
         GrPipelineInfo init;
         init.fColorIgnored = fBatch.fColorIgnored;
         init.fOverrideColor = GrColor_ILLEGAL;
         init.fCoverageIgnored = fBatch.fCoverageIgnored;
@@ skipping 86 matching lines @@
             break;
         case SkTextBlob::kFull_Positioning:
             this->drawPosTextAsPath(runPaint, viewMatrix, (const char*)it.glyphs(),
                                     textLen, it.pos(), 2, SkPoint::Make(x, y), clipBounds);
             break;
     }
 }
 
 inline void GrAtlasTextContext::flushRun(GrDrawTarget* target, GrPipelineBuilder* pipelineBuilder,
                                          BitmapTextBlob* cacheBlob, int run, GrColor color,
-                                         uint8_t paintAlpha) {
+                                         uint8_t paintAlpha, SkScalar transX, SkScalar transY) {
     for (int subRun = 0; subRun < cacheBlob->fRuns[run].fSubRunInfo.count(); subRun++) {
         const PerSubRunInfo& info = cacheBlob->fRuns[run].fSubRunInfo[subRun];
         int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
         if (0 == glyphCount) {
             continue;
         }
 
         GrMaskFormat format = info.fMaskFormat;
         GrColor subRunColor = kARGB_GrMaskFormat == format ?
                               SkColorSetARGB(paintAlpha, paintAlpha, paintAlpha, paintAlpha) :
                               color;
 
         BitmapTextBatch::Geometry geometry;
         geometry.fBlob.reset(SkRef(cacheBlob));
         geometry.fRun = run;
         geometry.fSubRun = subRun;
         geometry.fColor = subRunColor;
+        geometry.fTransX = transX;
+        geometry.fTransY = transY;
         SkAutoTUnref<GrBatch> batch(BitmapTextBatch::Create(geometry, format, glyphCount,
                                                             fContext->getBatchFontCache()));
 
         target->drawBatch(pipelineBuilder, batch, &cacheBlob->fRuns[run].fVertexBounds);
     }
 }
 
 inline void GrAtlasTextContext::flushBigGlyphs(BitmapTextBlob* cacheBlob, GrRenderTarget* rt,
-                                               const GrPaint& grPaint, const GrClip& clip) {
+                                               const GrPaint& grPaint, const GrClip& clip,
+                                               SkScalar transX, SkScalar transY) {
     for (int i = 0; i < cacheBlob->fBigGlyphs.count(); i++) {
-        const BitmapTextBlob::BigGlyph& bigGlyph = cacheBlob->fBigGlyphs[i];
+        BitmapTextBlob::BigGlyph& bigGlyph = cacheBlob->fBigGlyphs[i];
+        bigGlyph.fVx += SkScalarTruncToInt(transX);
+        bigGlyph.fVy += SkScalarTruncToInt(transY);
         SkMatrix translate;
-        translate.setTranslate(SkIntToScalar(bigGlyph.fVx), SkIntToScalar(bigGlyph.fVy));
+        translate.setTranslate(SkIntToScalar(bigGlyph.fVx),
+                               SkIntToScalar(bigGlyph.fVy));
         SkPath tmpPath(bigGlyph.fPath);
         tmpPath.transform(translate);
         GrStrokeInfo strokeInfo(SkStrokeRec::kFill_InitStyle);
         fContext->drawPath(rt, clip, grPaint, SkMatrix::I(), tmpPath, strokeInfo);
     }
 }
 
 void GrAtlasTextContext::flush(GrDrawTarget* target,
                                const SkTextBlob* blob,
                                BitmapTextBlob* cacheBlob,
                                GrRenderTarget* rt,
                                const SkPaint& skPaint,
                                const GrPaint& grPaint,
                                SkDrawFilter* drawFilter,
                                const GrClip& clip,
                                const SkMatrix& viewMatrix,
                                const SkIRect& clipBounds,
-                               SkScalar x,
-                               SkScalar y) {
+                               SkScalar x, SkScalar y,
+                               SkScalar transX, SkScalar transY) {
     // We loop through the runs of the blob, flushing each.  If any run is too large, then we flush
     // it as paths
     GrPipelineBuilder pipelineBuilder;
     pipelineBuilder.setFromPaint(grPaint, rt, clip);
 
     GrColor color = grPaint.getColor();
     uint8_t paintAlpha = skPaint.getAlpha();
 
     SkTextBlob::RunIterator it(blob);
     for (int run = 0; !it.done(); it.next(), run++) {
         if (cacheBlob->fRuns[run].fDrawAsPaths) {
             this->flushRunAsPaths(it, skPaint, drawFilter, viewMatrix, clipBounds, x, y);
             continue;
         }
-        this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, paintAlpha);
+        cacheBlob->fRuns[run].fVertexBounds.offset(transX, transY);
+        this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, paintAlpha, transX, transY);
     }
 
     // Now flush big glyphs
-    this->flushBigGlyphs(cacheBlob, rt, grPaint, clip);
+    this->flushBigGlyphs(cacheBlob, rt, grPaint, clip, transX, transY);
 }
 
 void GrAtlasTextContext::flush(GrDrawTarget* target,
                                BitmapTextBlob* cacheBlob,
                                GrRenderTarget* rt,
                                const SkPaint& skPaint,
                                const GrPaint& grPaint,
                                const GrClip& clip,
                                const SkMatrix& viewMatrix) {
     GrPipelineBuilder pipelineBuilder;
     pipelineBuilder.setFromPaint(grPaint, rt, clip);
 
     GrColor color = grPaint.getColor();
     uint8_t paintAlpha = skPaint.getAlpha();
     for (int run = 0; run < cacheBlob->fRunCount; run++) {
-        this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, paintAlpha);
+        this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, paintAlpha, 0, 0);
     }
 
     // Now flush big glyphs
-    this->flushBigGlyphs(cacheBlob, rt, grPaint, clip);
+    this->flushBigGlyphs(cacheBlob, rt, grPaint, clip, 0, 0);
 }