Restore text alloc optimizations.

src/gpu/GrBitmapTextContext.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBitmapTextContext.h"
 #include "GrAtlas.h"
 #include "GrDrawTarget.h"
@@ skipping 33 matching lines @@
 extern const GrVertexAttrib gTextVertexWithColorAttribs[] = {
     {kVec2f_GrVertexAttribType,  0,                                 kPosition_GrVertexAttribBinding},
     {kVec4ub_GrVertexAttribType, sizeof(SkPoint),                   kColor_GrVertexAttribBinding},
     {kVec2f_GrVertexAttribType,  sizeof(SkPoint) + sizeof(GrColor), kEffect_GrVertexAttribBinding}
 };
 
 };
 
 GrBitmapTextContext::GrBitmapTextContext(GrContext* context,
                                          const SkDeviceProperties& properties)
-                                       : GrTextContext(context, properties) {
-    fStrike = NULL;
-
-    fCurrTexture = NULL;
-    fCurrVertex = 0;
-    fEffectTextureUniqueID = SK_InvalidUniqueID;
-
-    fVertices = NULL;
-    fMaxVertices = 0;
-
+                                       : GrTextContext(context, properties)
+                                       , fStrike(NULL)
+                                       , fEffectTextureUniqueID(SK_InvalidUniqueID)
+                                       , fVertices(NULL)
+                                       , fVertexCount(0)
+                                       , fCurrVertex(0) {
     fVertexBounds.setLargestInverted();
 }
 
 GrBitmapTextContext::~GrBitmapTextContext() {
     this->flushGlyphs();
 }
 
 bool GrBitmapTextContext::canDraw(const SkPaint& paint) {
     return !SkDraw::ShouldDrawTextAsPaths(paint, fContext->getMatrix());
 }
@@ skipping 10 matching lines @@
         return;
     }
 
     GrDrawState* drawState = fDrawTarget->drawState();
     GrDrawState::AutoRestoreEffects are(drawState);
     drawState->setFromPaint(fPaint, SkMatrix::I(), fContext->getRenderTarget());
 
     if (fCurrVertex > 0) {
         // setup our sampler state for our text texture/atlas
         SkASSERT(SkIsAlign4(fCurrVertex));
-        SkASSERT(fCurrTexture);
         GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kNone_FilterMode);
 
-        uint32_t textureUniqueID = fCurrTexture->getUniqueID();
+        GrTexture* currTexture = fStrike->getTexture();
+        SkASSERT(currTexture);
+        uint32_t textureUniqueID = currTexture->getUniqueID();
         
         if (textureUniqueID != fEffectTextureUniqueID) {
-            fCachedEffect.reset(GrCustomCoordsTextureEffect::Create(fCurrTexture, params));
+            fCachedEffect.reset(GrCustomCoordsTextureEffect::Create(currTexture, params));
             fEffectTextureUniqueID = textureUniqueID;
         }
 
         // This effect could be stored with one of the cache objects (atlas?)
         int coordsIdx = drawState->hasColorVertexAttribute() ? kGlyphCoordsWithColorAttributeIndex :
                                                                kGlyphCoordsNoColorAttributeIndex;
         drawState->addCoverageEffect(fCachedEffect.get(), coordsIdx);
         SkASSERT(NULL != fStrike);
         switch (fStrike->getMaskFormat()) {
             // Color bitmap text
@@ skipping 31 matching lines @@
                 SkASSERT(drawState->hasColorVertexAttribute());
                 break;
             default:
                 SkFAIL("Unexepected mask format.");
         }
         int nGlyphs = fCurrVertex / 4;
         fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
         fDrawTarget->drawIndexedInstances(kTriangles_GrPrimitiveType,
                                           nGlyphs,
                                           4, 6, &fVertexBounds);
-
-        fDrawTarget->resetVertexSource();
-        fVertices = NULL;
-        fMaxVertices = 0;
+        fVertexCount = 0;
         fCurrVertex = 0;
         fVertexBounds.setLargestInverted();
-        SkSafeSetNull(fCurrTexture);
     }
+    
+    fDrawTarget->resetVertexSource();
+    fVertices = NULL;
 }
 
 inline void GrBitmapTextContext::init(const GrPaint& paint, const SkPaint& skPaint) {
     GrTextContext::init(paint, skPaint);
 
     fStrike = NULL;
 
-    fCurrTexture = NULL;
+    fVertices = NULL;
+    fVertexCount = 0;
     fCurrVertex = 0;
-
-    fVertices = NULL;
-    fMaxVertices = 0;
 }
 
 inline void GrBitmapTextContext::finish() {
     this->flushGlyphs();
 
     GrTextContext::finish();
 }
 
+void GrBitmapTextContext::allocateVertices(const char text[], size_t byteLength) {
+    SkASSERT(NULL == fVertices);
+    bool useColorVerts = kA8_GrMaskFormat == fStrike->getMaskFormat();
+    if (useColorVerts) {
+        fDrawTarget->drawState()->setVertexAttribs<gTextVertexWithColorAttribs>(
+                                                    SK_ARRAY_COUNT(gTextVertexWithColorAttribs));
+    } else {
+        fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(
+                                                    SK_ARRAY_COUNT(gTextVertexAttribs));
+    }
+    fVertexCount = 4*fSkPaint.textToGlyphs(text, byteLength, NULL);
+    bool success = fDrawTarget->reserveVertexAndIndexSpace(fVertexCount,
+                                                           0,
+                                                           &fVertices,
+                                                           NULL);
+    GrAlwaysAssert(success);
+}
+
 void GrBitmapTextContext::drawText(const GrPaint& paint, const SkPaint& skPaint,
                                    const char text[], size_t byteLength,
                                    SkScalar x, SkScalar y) {
     SkASSERT(byteLength == 0 || text != NULL);
 
     // nothing to draw
     if (text == NULL || byteLength == 0 /*|| fRC->isEmpty()*/) {
         return;
     }
 
     this->init(paint, skPaint);
+    
+    if (NULL == fDrawTarget) {
+        return;
+    }
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     SkAutoGlyphCache    autoCache(fSkPaint, &fDeviceProperties, &fContext->getMatrix());
     SkGlyphCache*       cache = autoCache.getCache();
     GrFontScaler*       fontScaler = GetGrFontScaler(cache);
-
+    if (NULL == fStrike) {
+        fStrike = fContext->getFontCache()->getStrike(fontScaler, false);
+    }
+    
     // transform our starting point
     {
         SkPoint loc;
         fContext->getMatrix().mapXY(x, y, &loc);
         x = loc.fX;
         y = loc.fY;
     }
 
     // need to measure first
     if (fSkPaint.getTextAlign() != SkPaint::kLeft_Align) {
         SkVector    stop;
 
         MeasureText(cache, glyphCacheProc, text, byteLength, &stop);
 
         SkScalar    stopX = stop.fX;
         SkScalar    stopY = stop.fY;
 
         if (fSkPaint.getTextAlign() == SkPaint::kCenter_Align) {
             stopX = SkScalarHalf(stopX);
             stopY = SkScalarHalf(stopY);
         }
         x -= stopX;
         y -= stopY;
     }
 
     const char* stop = text + byteLength;
 
-    SkAutoKern autokern;
+    allocateVertices(text, byteLength);
 
     SkFixed fxMask = ~0;
     SkFixed fyMask = ~0;
     SkFixed halfSampleX, halfSampleY;
     if (cache->isSubpixel()) {
         halfSampleX = halfSampleY = (SK_FixedHalf >> SkGlyph::kSubBits);
         SkAxisAlignment baseline = SkComputeAxisAlignmentForHText(fContext->getMatrix());
         if (kX_SkAxisAlignment == baseline) {
             fyMask = 0;
             halfSampleY = SK_FixedHalf;
         } else if (kY_SkAxisAlignment == baseline) {
             fxMask = 0;
             halfSampleX = SK_FixedHalf;
         }
     } else {
         halfSampleX = halfSampleY = SK_FixedHalf;
     }
 
     SkFixed fx = SkScalarToFixed(x) + halfSampleX;
     SkFixed fy = SkScalarToFixed(y) + halfSampleY;
 
     GrContext::AutoMatrix  autoMatrix;
     autoMatrix.setIdentity(fContext, &fPaint);
 
+    SkAutoKern autokern;

[bsalomon, 2014/08/27 14:32:00]

What be this?

[jvanverth1, 2014/08/27 15:09:35]

It's used in the loop below to adjust the horizontal displacement, based on the
glyph. I moved the definition from above, where it was hanging out without much
context.

     while (text < stop) {
         const SkGlyph& glyph = glyphCacheProc(cache, &text, fx & fxMask, fy & fyMask);
 
         fx += autokern.adjust(glyph);
 
         if (glyph.fWidth) {
             this->drawPackedGlyph(GrGlyph::Pack(glyph.getGlyphID(),
                                           glyph.getSubXFixed(),
                                           glyph.getSubYFixed()),
                                   SkFixedFloorToFixed(fx),
@@ skipping 15 matching lines @@
     SkASSERT(byteLength == 0 || text != NULL);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == NULL || byteLength == 0/* || fRC->isEmpty()*/) {
         return;
     }
 
     this->init(paint, skPaint);
 
+    if (NULL == fDrawTarget) {
+        return;
+    }
+    
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     SkAutoGlyphCache    autoCache(fSkPaint, &fDeviceProperties, &fContext->getMatrix());
     SkGlyphCache*       cache = autoCache.getCache();
     GrFontScaler*       fontScaler = GetGrFontScaler(cache);
+    if (NULL == fStrike) {
+        fStrike = fContext->getFontCache()->getStrike(fontScaler, false);
+    }
 
     // store original matrix before we reset, so we can use it to transform positions
     SkMatrix ctm = fContext->getMatrix();
     GrContext::AutoMatrix  autoMatrix;
     autoMatrix.setIdentity(fContext, &fPaint);
 
+    allocateVertices(text, byteLength);

[bsalomon, 2014/08/27 14:32:00]

this->

[jvanverth1, 2014/08/27 15:31:57]

Done.

+
     const char*        stop = text + byteLength;
     SkTextAlignProc    alignProc(fSkPaint.getTextAlign());
     SkTextMapStateProc tmsProc(ctm, constY, scalarsPerPosition);
     SkFixed halfSampleX = 0, halfSampleY = 0;
 
     if (cache->isSubpixel()) {
         // maybe we should skip the rounding if linearText is set
         SkAxisAlignment baseline = SkComputeAxisAlignmentForHText(ctm);
 
         SkFixed fxMask = ~0;
@@ skipping 111 matching lines @@
             }
         }
     }
 
     this->finish();
 }
 
 void GrBitmapTextContext::drawPackedGlyph(GrGlyph::PackedID packed,
                                           SkFixed vx, SkFixed vy,
                                           GrFontScaler* scaler) {
-    if (NULL == fDrawTarget) {
-        return;
-    }
-
-    if (NULL == fStrike) {
-        fStrike = fContext->getFontCache()->getStrike(scaler, false);
-    }
-
     GrGlyph* glyph = fStrike->getGlyph(packed, scaler);
     if (NULL == glyph || glyph->fBounds.isEmpty()) {
         return;
     }
 
     vx += SkIntToFixed(glyph->fBounds.fLeft);
     vy += SkIntToFixed(glyph->fBounds.fTop);
 
     // keep them as ints until we've done the clip-test
     SkFixed width = glyph->fBounds.width();
@@ skipping 20 matching lines @@
             goto HAS_ATLAS;
         }
 
         if (c_DumpFontCache) {
 #ifdef SK_DEVELOPER
             fContext->getFontCache()->dump();
 #endif
         }
 
         // flush any accumulated draws to allow us to free up a plot
+        int remainingVertexCount = fVertexCount - fCurrVertex;
         this->flushGlyphs();
         fContext->flush();
 
+        // need to reallocate the vertex buffer for the remaining glyphs
+        fVertexCount = remainingVertexCount;
+        bool success = fDrawTarget->reserveVertexAndIndexSpace(fVertexCount,
+                                                               0,
+                                                               &fVertices,
+                                                               NULL);
+        GrAlwaysAssert(success);
+
         // we should have an unused plot now
         if (fContext->getFontCache()->freeUnusedPlot(fStrike) &&
             fStrike->addGlyphToAtlas(glyph, scaler)) {
             goto HAS_ATLAS;
         }
 
         if (NULL == glyph->fPath) {
             SkPath* path = SkNEW(SkPath);
             if (!scaler->getGlyphPath(glyph->glyphID(), path)) {
                 // flag the glyph as being dead?
@@ skipping 19 matching lines @@
     GrDrawTarget::DrawToken drawToken = fDrawTarget->getCurrentDrawToken();
     glyph->fPlot->setDrawToken(drawToken);
 
     // now promote them to fixed (TODO: Rethink using fixed pt).
     width = SkIntToFixed(width);
     height = SkIntToFixed(height);
 
     GrTexture* texture = glyph->fPlot->texture();
     SkASSERT(texture);
 
-    if (fCurrTexture != texture || fCurrVertex + 4 > fMaxVertices) {
-        this->flushGlyphs();
-        fCurrTexture = texture;
-        fCurrTexture->ref();
-    }
-
-    bool useColorVerts = kA8_GrMaskFormat == fStrike->getMaskFormat();
-
-    if (NULL == fVertices) {
-       // If we need to reserve vertices allow the draw target to suggest
-        // a number of verts to reserve and whether to perform a flush.
-        fMaxVertices = kMinRequestedVerts;
-        if (useColorVerts) {
-            fDrawTarget->drawState()->setVertexAttribs<gTextVertexWithColorAttribs>(
-                SK_ARRAY_COUNT(gTextVertexWithColorAttribs));
-        } else {
-            fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(
-                SK_ARRAY_COUNT(gTextVertexAttribs));
-        }
-        bool flush = fDrawTarget->geometryHints(&fMaxVertices, NULL);
-        if (flush) {
-            this->flushGlyphs();
-            fContext->flush();
-            if (useColorVerts) {
-                fDrawTarget->drawState()->setVertexAttribs<gTextVertexWithColorAttribs>(
-                  SK_ARRAY_COUNT(gTextVertexWithColorAttribs));
-            } else {
-                fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(
-                  SK_ARRAY_COUNT(gTextVertexAttribs));
-            }
-        }
-        fMaxVertices = kDefaultRequestedVerts;
-        // ignore return, no point in flushing again.
-        fDrawTarget->geometryHints(&fMaxVertices, NULL);
-
-        int maxQuadVertices = 4 * fContext->getQuadIndexBuffer()->maxQuads();
-        if (fMaxVertices < kMinRequestedVerts) {
-            fMaxVertices = kDefaultRequestedVerts;
-        } else if (fMaxVertices > maxQuadVertices) {
-            // don't exceed the limit of the index buffer
-            fMaxVertices = maxQuadVertices;
-        }
-        bool success = fDrawTarget->reserveVertexAndIndexSpace(fMaxVertices,
-                                                               0,
-                                                               &fVertices,
-                                                               NULL);
-        GrAlwaysAssert(success);
-    }
-
     SkFixed tx = SkIntToFixed(glyph->fAtlasLocation.fX);
     SkFixed ty = SkIntToFixed(glyph->fAtlasLocation.fY);
 
     SkRect r;
     r.fLeft = SkFixedToFloat(vx);
     r.fTop = SkFixedToFloat(vy);
     r.fRight = SkFixedToFloat(vx + width);
     r.fBottom = SkFixedToFloat(vy + height);
 
     fVertexBounds.growToInclude(r);
 
+    bool useColorVerts = kA8_GrMaskFormat == fStrike->getMaskFormat();
     size_t vertSize = useColorVerts ? (2 * sizeof(SkPoint) + sizeof(GrColor)) :
                                       (2 * sizeof(SkPoint));
 
     SkASSERT(vertSize == fDrawTarget->getDrawState().getVertexSize());
 
     SkPoint* positions = reinterpret_cast<SkPoint*>(
         reinterpret_cast<intptr_t>(fVertices) + vertSize * fCurrVertex);
     positions->setRectFan(r.fLeft, r.fTop, r.fRight, r.fBottom, vertSize);
 
     // The texture coords are last in both the with and without color vertex layouts.
@@ skipping 10 matching lines @@
         }
         // color comes after position.
         GrColor* colors = reinterpret_cast<GrColor*>(positions + 1);
         for (int i = 0; i < 4; ++i) {
            *colors = fPaint.getColor();
            colors = reinterpret_cast<GrColor*>(reinterpret_cast<intptr_t>(colors) + vertSize);
         }
     }
     fCurrVertex += 4;
 }