Add SkGlyphRunList - v2

Extend the glyph run system with a glyph run list. This
allows the processing of text blobs.

Add original text an cluster to runs for PDF.

PS - the original had read off the end of a buffer problem.

Change-Id: I9430f0c27aaa3d9458bfe3caba5f433b72fdf84c
Reviewed-on: https://skia-review.googlesource.com/136792
Reviewed-by: Ben Wagner <bungeman@google.com>
Commit-Queue: Herb Derby <herb@google.com>

1 files changed, 195 insertions, 61 deletions

diff --git a/src/core/SkGlyphRun.cpp b/src/core/SkGlyphRun.cpp
index 29c1dfdb78..61909656c0 100644
--- a/src/core/SkGlyphRun.cpp
+++ b/src/core/SkGlyphRun.cpp
@@ -19,9 +19,12 @@
 #include "SkPaint.h"
 #include "SkPaintPriv.h"
 #include "SkStrikeCache.h"
+#include "SkTextBlob.h"
+#include "SkTextBlobRunIterator.h"
 #include "SkTo.h"
 #include "SkUtils.h"
 
+namespace {
 static SkTypeface::Encoding convert_encoding(SkPaint::TextEncoding encoding) {
     switch (encoding) {
         case  SkPaint::kUTF8_TextEncoding: return SkTypeface::kUTF8_Encoding;
@@ -30,8 +33,15 @@ static SkTypeface::Encoding convert_encoding(SkPaint::TextEncoding encoding) {
         default: return SkTypeface::kUTF32_Encoding;
     }
 }
+}  // namespace
+
 
 // -- SkGlyphSet ----------------------------------------------------------------------------------
+uint32_t SkGlyphSet::uniqueSize() {
+    // The size is how big the vector is grown since being passed into reuse.
+    return fUniqueGlyphIDs->size() - fStartOfUniqueIDs;
+}
+
 uint16_t SkGlyphSet::add(SkGlyphID glyphID) {
     static constexpr SkGlyphID  kUndefGlyph{0};
 
@@ -44,11 +54,13 @@ uint16_t SkGlyphSet::add(SkGlyphID glyphID) {
     }
 
     auto index = fIndices[glyphID];
-    if (index < fUniqueGlyphIDs->size() && (*fUniqueGlyphIDs)[index] == glyphID) {
+
+    // Remember we start at the end of what ever was passed in.
+    if (index < this->uniqueSize() && (*fUniqueGlyphIDs)[fStartOfUniqueIDs + index] == glyphID) {
         return index;
     }
 
-    uint16_t newIndex = SkTo<uint16_t>(fUniqueGlyphIDs->size());
+    uint16_t newIndex = SkTo<uint16_t>(this->uniqueSize());
     fUniqueGlyphIDs->push_back(glyphID);
     fIndices[glyphID] = newIndex;
     return newIndex;
@@ -58,15 +70,12 @@ void SkGlyphSet::reuse(uint32_t glyphUniverseSize, std::vector<SkGlyphID>* uniqu
     SkASSERT(glyphUniverseSize <= (1 << 16));
     fUniverseSize = glyphUniverseSize;
     fUniqueGlyphIDs = uniqueGlyphIDs;
-    // If we're hanging onto these arrays for a long time, we don't want their size to drift
-    // endlessly upwards. It's unusual to see more than 256 unique glyphs used in a run,
-    // or a typeface with more than 4096 possible glyphs.
-    if (fUniqueGlyphIDs->size() > 256) {
-        fUniqueGlyphIDs->resize(256);
-        fUniqueGlyphIDs->shrink_to_fit();
-    }
-    fUniqueGlyphIDs->clear();
 
+    // Capture the vector end to act as the start of a new unique id vector.
+    fStartOfUniqueIDs = uniqueGlyphIDs->size();
+
+    // If we're hanging onto these arrays for a long time, we don't want their size to drift
+    // endlessly upwards. It's unusual to see a typeface with more than 4096 possible glyphs.
     if (glyphUniverseSize < 4096 && fIndices.size() > 4096) {
         fIndices.resize(4096);
         fIndices.shrink_to_fit();
@@ -77,6 +86,21 @@ void SkGlyphSet::reuse(uint32_t glyphUniverseSize, std::vector<SkGlyphID>* uniqu
 }
 
 // -- SkGlyphRun -----------------------------------------------------------------------------------
+SkGlyphRun::SkGlyphRun(SkSpan<uint16_t>   denseIndex,
+                       SkSpan<SkPoint>    positions,
+                       SkSpan<SkGlyphID>  scratchGlyphs,
+                       SkSpan<SkGlyphID>  uniqueGlyphIDs,
+                       SkSpan<const char> text,
+                       SkSpan<uint32_t>   clusters)
+        : fDenseIndex{denseIndex}, fPositions{positions}
+        , fTemporaryShuntGlyphIDs{scratchGlyphs}
+        , fUniqueGlyphIDs{uniqueGlyphIDs}
+        , fText{text}
+        , fClusters{clusters} {
+    SkASSERT(denseIndex.size() == positions.size());
+    SkASSERT(denseIndex.size() == scratchGlyphs.size());
+}
+
 
 void SkGlyphRun::temporaryShuntToDrawPosText(const SkPaint& paint, SkBaseDevice* device) {
 
@@ -93,78 +117,108 @@ void SkGlyphRun::temporaryShuntToCallback(TemporaryShuntCallback callback) {
     callback(this->runSize(), bytes, pos);
 }
 
+// -- SkGlyphRunList -------------------------------------------------------------------------------
+SkGlyphRunList::SkGlyphRunList(SkSpan<SkGlyphRun> glyphRuns, uint64_t uniqueID)
+        : fUniqueID{uniqueID}
+        , fGlyphRuns{glyphRuns} { }
 
 // -- SkGlyphRunBuilder ----------------------------------------------------------------------------
 void SkGlyphRunBuilder::prepareDrawText(
         const SkPaint& paint, const void* bytes, size_t byteLength, SkPoint origin) {
-
-    this->initializeDenseAndUnique(paint, bytes, byteLength);
-
-    fScratchAdvances.resize(this->uniqueSize());
-    {
-        auto cache = SkStrikeCache::FindOrCreateStrikeExclusive(paint);
-        cache->getAdvances(SkSpan<SkGlyphID>{fUniqueGlyphs}, fScratchAdvances.data());
-    }
-
-    SkPoint endOfLastGlyph = origin;
-
-    for (size_t i = 0; i < this->runSize(); i++) {
-        fPositions.push_back(endOfLastGlyph);
-        endOfLastGlyph += fScratchAdvances[fDenseIndex[i]];
+    this->initialize();
+    SkSpan<const char> originalText((const char*)bytes, byteLength);
+    if (paint.getTextEncoding() != SkPaint::kUTF8_TextEncoding) {
+        originalText = SkSpan<const char>();
     }
-
-    if (paint.getTextAlign() != SkPaint::kLeft_Align) {
-        SkVector len = endOfLastGlyph - origin;
-        if (paint.getTextAlign() == SkPaint::kCenter_Align) {
-            len.scale(SK_ScalarHalf);
-        }
-        for (size_t i = 0; i < this->runSize(); i++) {
-            fPositions[i] -= len;
-        }
-    }
-
+    this->drawText(paint, bytes, byteLength, origin, originalText, SkSpan<uint32_t>());
 }
 
 void SkGlyphRunBuilder::prepareDrawPosTextH(const SkPaint& paint, const void* bytes,
                                             size_t byteLength, const SkScalar* xpos,
                                             SkScalar constY) {
-
-    this->initializeDenseAndUnique(paint, bytes, byteLength);
-
-    for (size_t i = 0; i < runSize(); i++) {
-        fPositions.push_back(SkPoint::Make(xpos[i], constY));
-    }
+    this->initialize();
+    this->drawPosTextH(
+            paint, bytes, byteLength, xpos, constY, SkSpan<const char>(), SkSpan<uint32_t>());
 }
 
 void SkGlyphRunBuilder::prepareDrawPosText(const SkPaint& paint, const void* bytes,
                                            size_t byteLength, const SkPoint* pos) {
-    this->initializeDenseAndUnique(paint, bytes, byteLength);
+    this->initialize();
+    this->drawPosText(paint, bytes, byteLength, pos, SkSpan<const char>(), SkSpan<uint32_t>());
+}
 
-    for (size_t i = 0; i < runSize(); i++) {
-        fPositions.push_back(pos[i]);
+void SkGlyphRunBuilder::prepareTextBlob(
+        const SkPaint& paint, const SkTextBlob& blob, SkPoint origin) {
+    this->initialize();
+    fUniqueID = blob.uniqueID();
+
+    SkPaint runPaint = paint;
+
+    for (SkTextBlobRunIterator it(&blob); !it.done(); it.next()) {
+        // applyFontToPaint() always overwrites the exact same attributes,
+        // so it is safe to not re-seed the paint for this reason.
+        it.applyFontToPaint(&runPaint);
+
+        // These better be glyphs
+        SkASSERT(runPaint.getTextEncoding() == SkPaint::kGlyphID_TextEncoding);
+
+        auto text = SkSpan<const char>(it.text(), it.textSize());
+        auto clusters = SkSpan<uint32_t>(it.clusters(), it.glyphCount());
+        size_t glyphLen = it.glyphCount() * sizeof(SkGlyphID);
+        const SkPoint& offset = it.offset();
+
+        switch (it.positioning()) {
+            case SkTextBlob::kDefault_Positioning: {
+                auto dtOrigin = origin + offset;
+                this->drawText(runPaint, it.glyphs(), glyphLen, dtOrigin, text, clusters);
+            }
+            break;
+            case SkTextBlob::kHorizontal_Positioning: {
+                auto constY = origin.y() + offset.y();
+                this->drawPosTextH(
+                        runPaint, it.glyphs(), glyphLen, it.pos(), constY, text, clusters);
+            }
+            break;
+            case SkTextBlob::kFull_Positioning:
+                this->drawPosText(
+                        runPaint, it.glyphs(), glyphLen, (const SkPoint*)it.pos(), text, clusters);
+            break;
+            default:
+                SK_ABORT("unhandled positioning mode");
+        }
     }
 }
 
 SkGlyphRun* SkGlyphRunBuilder::useGlyphRun() {
-    fScratchGlyphRun.~SkGlyphRun();
-    new ((void*)&fScratchGlyphRun) SkGlyphRun{SkSpan<uint16_t>(fDenseIndex),
-                                              SkSpan<SkPoint>(fPositions),
-                                              SkSpan<SkGlyphID>(
-                                                      fTemporaryShuntGlyphIDs, fDenseIndex.size()),
-                                              SkSpan<SkGlyphID>(fUniqueGlyphs)};
-    return &fScratchGlyphRun;
+    auto glyphRunList = this->useGlyphRunList();
+    SkASSERT(glyphRunList->size() == 1);
+    return &(*glyphRunList)[0];
 }
 
-void SkGlyphRunBuilder::initializeDenseAndUnique(
-        const SkPaint& paint, const void* bytes, size_t byteLength) {
+SkGlyphRunList* SkGlyphRunBuilder::useGlyphRunList() {
+    new ((void*)&fScratchGlyphRunList) SkGlyphRunList{SkSpan<SkGlyphRun>(fGlyphRuns), fUniqueID};
+    return &fScratchGlyphRunList;
+}
+
+size_t SkGlyphRunBuilder::runSize() const { return fDenseIndex.size() - fLastDenseIndex; }
+
+size_t SkGlyphRunBuilder::uniqueSize() const { return fUniqueGlyphs.size() - fLastUniqueIndex; }
 
+void SkGlyphRunBuilder::initialize() {
+    fUniqueID = 0;
     fDenseIndex.clear();
     fPositions.clear();
     fUniqueGlyphs.clear();
-    fTemporaryShuntGlyphIDs = nullptr;
+    fGlyphRuns.clear();
+    fLastDenseIndex = 0;
+    fLastUniqueIndex = 0;
+}
+
+SkGlyphID* SkGlyphRunBuilder::addDenseAndUnique(
+        const SkPaint& paint, const void* bytes, size_t byteLength) {
 
     size_t runSize = 0;
-    const SkGlyphID* glyphIDs = nullptr;
+    SkGlyphID* glyphIDs = nullptr;
     auto encoding = paint.getTextEncoding();
     auto typeface = SkPaintPriv::GetTypefaceOrDefault(paint);
     if (encoding != SkPaint::kGlyphID_TextEncoding) {
@@ -178,18 +232,98 @@ void SkGlyphRunBuilder::initializeDenseAndUnique(
         }
     } else {
         runSize = byteLength / 2;
-        glyphIDs = (const SkGlyphID*)bytes;
+        glyphIDs = (SkGlyphID*)bytes;
     }
 
     SkASSERT(glyphIDs != nullptr);
 
-    if (runSize == 0) { return; }
-    fTemporaryShuntGlyphIDs = glyphIDs;
+    if (runSize > 0) {
+        fGlyphSet.reuse(typeface->countGlyphs(), &fUniqueGlyphs);
+        for (size_t i = 0; i < runSize; i++) {
+            fDenseIndex.push_back(fGlyphSet.add(glyphIDs[i]));
+        }
+    }
+
+    return glyphIDs;
+}
+
+void SkGlyphRunBuilder::addGlyphRunToList(
+        SkGlyphID* temporaryShuntGlyphIDs, SkSpan<const char> text, SkSpan<uint32_t> clusters) {
+
+    // Ignore empty runs.
+    if (fDenseIndex.size() != fLastDenseIndex) {
+        auto runSize = this->runSize();
+        auto uniqueSize = this->uniqueSize();
+
+        fGlyphRuns.emplace_back(
+                SkSpan<uint16_t>(&fDenseIndex[fLastDenseIndex], runSize),
+                SkSpan<SkPoint>(&fPositions[fLastDenseIndex], runSize),
+                SkSpan<SkGlyphID>(temporaryShuntGlyphIDs, runSize),
+                SkSpan<SkGlyphID>(&fUniqueGlyphs[fLastDenseIndex], uniqueSize),
+                text,
+                clusters);
+
+        fLastDenseIndex = fDenseIndex.size();
+        fLastUniqueIndex = fUniqueGlyphs.size();
+    }
+}
+
+void SkGlyphRunBuilder::drawText(
+        const SkPaint& paint, const void* bytes, size_t byteLength, SkPoint origin,
+        SkSpan<const char> text, SkSpan<uint32_t> clusters) {
+
+    SkGlyphID* temporaryShuntGlyphIDs = this->addDenseAndUnique(paint, bytes, byteLength);
+
+    fScratchAdvances.resize(this->uniqueSize());
+    {
+        auto cache = SkStrikeCache::FindOrCreateStrikeExclusive(paint);
+        cache->getAdvances(SkSpan<SkGlyphID>{fUniqueGlyphs}, fScratchAdvances.data());
+    }
+
+    SkPoint endOfLastGlyph = origin;
+
+    for (size_t i = 0; i < this->runSize(); i++) {
+        fPositions.push_back(endOfLastGlyph);
+        endOfLastGlyph += fScratchAdvances[fDenseIndex[i]];
+    }
+
+    if (paint.getTextAlign() != SkPaint::kLeft_Align) {
+        SkVector len = endOfLastGlyph - origin;
+        if (paint.getTextAlign() == SkPaint::kCenter_Align) {
+            len.scale(SK_ScalarHalf);
+        }
+        for (size_t i = fLastDenseIndex; i < this->runSize(); i++) {
+            fPositions[i] -= len;
+        }
+    }
+
+    this->addGlyphRunToList(temporaryShuntGlyphIDs, text, clusters);
+}
 
-    fGlyphSet.reuse(typeface->countGlyphs(), &fUniqueGlyphs);
-    for (size_t i = 0; i < runSize; i++) {
-        fDenseIndex.push_back(fGlyphSet.add(glyphIDs[i]));
+void SkGlyphRunBuilder::drawPosTextH(const SkPaint& paint, const void* bytes,
+                                     size_t byteLength, const SkScalar* xpos,
+                                     SkScalar constY,
+                                     SkSpan<const char> text, SkSpan<uint32_t> clusters) {
+
+    SkGlyphID* temporaryShuntGlyphIDs = this->addDenseAndUnique(paint, bytes, byteLength);
+
+    for (size_t i = 0; i < runSize(); i++) {
+        fPositions.push_back(SkPoint::Make(xpos[i], constY));
+    }
+
+    this->addGlyphRunToList(temporaryShuntGlyphIDs, text, clusters);
+}
+
+void SkGlyphRunBuilder::drawPosText(const SkPaint& paint, const void* bytes,
+                                    size_t byteLength, const SkPoint* pos,
+                                    SkSpan<const char> text, SkSpan<uint32_t> clusters) {
+    SkGlyphID* temporaryShuntGlyphIDs = this->addDenseAndUnique(paint, bytes, byteLength);
+
+    for (size_t i = 0; i < runSize(); i++) {
+        fPositions.push_back(pos[i]);
     }
+
+    this->addGlyphRunToList(temporaryShuntGlyphIDs, text, clusters);
 }