| /* | |
| * Copyright 2018 The Android Open Source Project | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #include "SkGlyphRun.h" | |
| #include "SkDevice.h" | |
| #include "SkFont.h" | |
| #include "SkFontPriv.h" | |
| #include "SkPaint.h" | |
| #include "SkStrike.h" | |
| #include "SkStrikeCache.h" | |
| #include "SkTextBlob.h" | |
| #include "SkTextBlobPriv.h" | |
| #include "SkTo.h" | |
| #include "SkUtils.h" | |
| // -- SkGlyphRun ----------------------------------------------------------------------------------- | |
| SkGlyphRun::SkGlyphRun(const SkFont& font, | |
| SkSpan<const SkPoint> positions, | |
| SkSpan<const SkGlyphID> glyphIDs, | |
| SkSpan<const char> text, | |
| SkSpan<const uint32_t> clusters) | |
| : fPositions{positions} | |
| , fGlyphIDs{glyphIDs} | |
| , fText{text} | |
| , fClusters{clusters} | |
| , fFont{font} {} | |
| SkGlyphRun::SkGlyphRun(const SkGlyphRun& that, const SkFont& font) | |
| : fPositions{that.fPositions} | |
| , fGlyphIDs{that.fGlyphIDs} | |
| , fText{that.fText} | |
| , fClusters{that.fClusters} | |
| , fFont{font} {} | |
| void SkGlyphRun::filloutGlyphsAndPositions(SkGlyphID* glyphIDs, SkPoint* positions) { | |
| memcpy(glyphIDs, fGlyphIDs.data(), fGlyphIDs.size_bytes()); | |
| memcpy(positions, fPositions.data(), fPositions.size_bytes()); | |
| } | |
| // -- SkGlyphRunList ------------------------------------------------------------------------------- | |
| SkGlyphRunList::SkGlyphRunList() = default; | |
| SkGlyphRunList::SkGlyphRunList( | |
| const SkPaint& paint, | |
| const SkTextBlob* blob, | |
| SkPoint origin, | |
| SkSpan<const SkGlyphRun> glyphRunList) | |
| : fOriginalPaint{&paint} | |
| , fOriginalTextBlob{blob} | |
| , fOrigin{origin} | |
| , fGlyphRuns{glyphRunList} { } | |
| SkGlyphRunList::SkGlyphRunList(const SkGlyphRun& glyphRun, const SkPaint& paint) | |
| : fOriginalPaint{&paint} | |
| , fOriginalTextBlob{nullptr} | |
| , fOrigin{SkPoint::Make(0, 0)} | |
| , fGlyphRuns{SkSpan<const SkGlyphRun>{&glyphRun, 1}} {} | |
| uint64_t SkGlyphRunList::uniqueID() const { | |
| return fOriginalTextBlob != nullptr ? fOriginalTextBlob->uniqueID() | |
| : SK_InvalidUniqueID; | |
| } | |
| bool SkGlyphRunList::anyRunsLCD() const { | |
| for (const auto& r : fGlyphRuns) { | |
| if (r.font().getEdging() == SkFont::Edging::kSubpixelAntiAlias) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool SkGlyphRunList::anyRunsSubpixelPositioned() const { | |
| for (const auto& r : fGlyphRuns) { | |
| if (r.font().isSubpixel()) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool SkGlyphRunList::allFontsFinite() const { | |
| for (const auto& r : fGlyphRuns) { | |
| if (!SkFontPriv::IsFinite(r.font())) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| void SkGlyphRunList::temporaryShuntBlobNotifyAddedToCache(uint32_t cacheID) const { | |
| SkASSERT(fOriginalTextBlob != nullptr); | |
| fOriginalTextBlob->notifyAddedToCache(cacheID); | |
| } | |
| // -- SkGlyphIDSet --------------------------------------------------------------------------------- | |
| // A faster set implementation that does not need any initialization, and reading the set items | |
| // is order the number of items, and not the size of the universe. | |
| // This implementation is based on the paper by Briggs and Torczon, "An Efficient Representation | |
| // for Sparse Sets" | |
| // | |
| // This implementation assumes that the unique glyphs added are appended to a vector that may | |
| // already have unique glyph from a previous computation. This allows the packing of multiple | |
| // UniqueID sequences in a single vector. | |
| SkSpan<const SkGlyphID> SkGlyphIDSet::uniquifyGlyphIDs( | |
| uint32_t universeSize, | |
| SkSpan<const SkGlyphID> glyphIDs, | |
| SkGlyphID* uniqueGlyphIDs, | |
| uint16_t* denseIndices) { | |
| static constexpr SkGlyphID kUndefGlyph{0}; | |
| if (universeSize > fUniverseToUniqueSize) { | |
| fUniverseToUnique.reset(universeSize); | |
| fUniverseToUniqueSize = universeSize; | |
| // If the following bzero becomes a performance problem, the memory can be marked as | |
| // initialized for valgrind and msan. | |
| // valgrind = VALGRIND_MAKE_MEM_DEFINED(fUniverseToUnique, universeSize * sizeof(SkGlyphID)) | |
| // msan = sk_msan_mark_initialized(fUniverseToUnique, universeSize * sizeof(SkGlyphID)) | |
| sk_bzero(fUniverseToUnique, universeSize * sizeof(SkGlyphID)); | |
| } | |
| // No need to clear fUniverseToUnique here... the set insertion algorithm is designed to work | |
| // correctly even when the fUniverseToUnique buffer is uninitialized! | |
| size_t uniqueSize = 0; | |
| size_t denseIndicesCursor = 0; | |
| for (auto glyphID : glyphIDs) { | |
| // If the glyphID is not in range then it is the undefined glyph. | |
| if (glyphID >= universeSize) { | |
| glyphID = kUndefGlyph; | |
| } | |
| // The index into the unique ID vector. | |
| auto uniqueIndex = fUniverseToUnique[glyphID]; | |
| if (uniqueIndex >= uniqueSize || uniqueGlyphIDs[uniqueIndex] != glyphID) { | |
| uniqueIndex = SkTo<uint16_t>(uniqueSize); | |
| uniqueGlyphIDs[uniqueSize] = glyphID; | |
| fUniverseToUnique[glyphID] = uniqueIndex; | |
| uniqueSize += 1; | |
| } | |
| denseIndices[denseIndicesCursor++] = uniqueIndex; | |
| } | |
| // 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 (fUniverseToUniqueSize > 4096) { | |
| fUniverseToUnique.reset(4096); | |
| sk_bzero(fUniverseToUnique, 4096 * sizeof(SkGlyphID)); | |
| fUniverseToUniqueSize = 4096; | |
| } | |
| return SkSpan<const SkGlyphID>(uniqueGlyphIDs, uniqueSize); | |
| } | |
| // -- SkGlyphRunBuilder ---------------------------------------------------------------------------- | |
| void SkGlyphRunBuilder::drawTextUTF8(const SkPaint& paint, const SkFont& font, const void* bytes, | |
| size_t byteLength, SkPoint origin) { | |
| auto glyphIDs = textToGlyphIDs(font, bytes, byteLength, kUTF8_SkTextEncoding); | |
| if (!glyphIDs.empty()) { | |
| this->initialize(glyphIDs.size()); | |
| this->simplifyDrawText(font, glyphIDs, origin, fPositions); | |
| } | |
| this->makeGlyphRunList(paint, nullptr, SkPoint::Make(0, 0)); | |
| } | |
| void SkGlyphRunBuilder::drawTextBlob(const SkPaint& paint, const SkTextBlob& blob, SkPoint origin, | |
| SkBaseDevice* device) { | |
| // Figure out all the storage needed to pre-size everything below. | |
| size_t totalGlyphs = 0; | |
| for (SkTextBlobRunIterator it(&blob); !it.done(); it.next()) { | |
| totalGlyphs += it.glyphCount(); | |
| } | |
| // Pre-size all the buffers so they don't move during processing. | |
| this->initialize(totalGlyphs); | |
| SkPoint* positions = fPositions; | |
| 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. | |
| size_t runSize = it.glyphCount(); | |
| auto text = SkSpan<const char>(it.text(), it.textSize()); | |
| auto clusters = SkSpan<const uint32_t>(it.clusters(), runSize); | |
| const SkPoint& offset = it.offset(); | |
| auto glyphIDs = SkSpan<const SkGlyphID>{it.glyphs(), runSize}; | |
| switch (it.positioning()) { | |
| case SkTextBlobRunIterator::kDefault_Positioning: { | |
| this->simplifyDrawText( | |
| it.font(), glyphIDs, offset, positions, text, clusters); | |
| } | |
| break; | |
| case SkTextBlobRunIterator::kHorizontal_Positioning: { | |
| auto constY = offset.y(); | |
| this->simplifyDrawPosTextH( | |
| it.font(), glyphIDs, it.pos(), constY, positions, text, clusters); | |
| } | |
| break; | |
| case SkTextBlobRunIterator::kFull_Positioning: | |
| this->simplifyDrawPosText( | |
| it.font(), glyphIDs, (const SkPoint*)it.pos(), text, clusters); | |
| break; | |
| case SkTextBlobRunIterator::kRSXform_Positioning: { | |
| if (!this->empty()) { | |
| this->makeGlyphRunList(paint, &blob, origin); | |
| device->drawGlyphRunList(this->useGlyphRunList()); | |
| } | |
| device->drawGlyphRunRSXform(it.font(), it.glyphs(), (const SkRSXform*)it.pos(), | |
| runSize, origin, paint); | |
| // re-init in case we keep looping and need the builder again | |
| this->initialize(totalGlyphs); | |
| } break; | |
| } | |
| positions += runSize; | |
| } | |
| if (!this->empty()) { | |
| this->makeGlyphRunList(paint, &blob, origin); | |
| device->drawGlyphRunList(this->useGlyphRunList()); | |
| } | |
| } | |
| void SkGlyphRunBuilder::drawGlyphsWithPositions(const SkPaint& paint, const SkFont& font, | |
| SkSpan<const SkGlyphID> glyphIDs, const SkPoint* pos) { | |
| if (!glyphIDs.empty()) { | |
| this->initialize(glyphIDs.size()); | |
| this->simplifyDrawPosText(font, glyphIDs, pos); | |
| this->makeGlyphRunList(paint, nullptr, SkPoint::Make(0, 0)); | |
| } | |
| } | |
| const SkGlyphRunList& SkGlyphRunBuilder::useGlyphRunList() { | |
| return fGlyphRunList; | |
| } | |
| void SkGlyphRunBuilder::initialize(size_t totalRunSize) { | |
| if (totalRunSize > fMaxTotalRunSize) { | |
| fMaxTotalRunSize = totalRunSize; | |
| fPositions.reset(fMaxTotalRunSize); | |
| } | |
| fGlyphRunListStorage.clear(); | |
| } | |
| SkSpan<const SkGlyphID> SkGlyphRunBuilder::textToGlyphIDs( | |
| const SkFont& font, const void* bytes, size_t byteLength, SkTextEncoding encoding) { | |
| if (encoding != kGlyphID_SkTextEncoding) { | |
| int count = font.countText(bytes, byteLength, encoding); | |
| if (count > 0) { | |
| fScratchGlyphIDs.resize(count); | |
| font.textToGlyphs(bytes, byteLength, encoding, fScratchGlyphIDs.data(), count); | |
| return SkSpan<const SkGlyphID>{fScratchGlyphIDs}; | |
| } else { | |
| return SkSpan<const SkGlyphID>(); | |
| } | |
| } else { | |
| return SkSpan<const SkGlyphID>((const SkGlyphID*)bytes, byteLength / 2); | |
| } | |
| } | |
| void SkGlyphRunBuilder::makeGlyphRun( | |
| const SkFont& font, | |
| SkSpan<const SkGlyphID> glyphIDs, | |
| SkSpan<const SkPoint> positions, | |
| SkSpan<const char> text, | |
| SkSpan<const uint32_t> clusters) { | |
| // Ignore empty runs. | |
| if (!glyphIDs.empty()) { | |
| fGlyphRunListStorage.emplace_back( | |
| font, | |
| positions, | |
| glyphIDs, | |
| text, | |
| clusters); | |
| } | |
| } | |
| void SkGlyphRunBuilder::makeGlyphRunList( | |
| const SkPaint& paint, const SkTextBlob* blob, SkPoint origin) { | |
| fGlyphRunList.~SkGlyphRunList(); | |
| new (&fGlyphRunList) SkGlyphRunList{ | |
| paint, blob, origin, SkSpan<const SkGlyphRun>{fGlyphRunListStorage}}; | |
| } | |
| void SkGlyphRunBuilder::simplifyDrawText( | |
| const SkFont& font, SkSpan<const SkGlyphID> glyphIDs, | |
| SkPoint origin, SkPoint* positions, | |
| SkSpan<const char> text, SkSpan<const uint32_t> clusters) { | |
| SkASSERT(!glyphIDs.empty()); | |
| auto runSize = glyphIDs.size(); | |
| if (!glyphIDs.empty()) { | |
| fScratchAdvances.resize(runSize); | |
| { | |
| auto cache = SkStrikeCache::FindOrCreateStrikeWithNoDeviceExclusive(font); | |
| cache->getAdvances(glyphIDs, fScratchAdvances.data()); | |
| } | |
| SkPoint endOfLastGlyph = origin; | |
| for (size_t i = 0; i < runSize; i++) { | |
| positions[i] = endOfLastGlyph; | |
| endOfLastGlyph += fScratchAdvances[i]; | |
| } | |
| this->makeGlyphRun( | |
| font, | |
| glyphIDs, | |
| SkSpan<const SkPoint>{positions, runSize}, | |
| text, | |
| clusters); | |
| } | |
| } | |
| void SkGlyphRunBuilder::simplifyDrawPosTextH( | |
| const SkFont& font, SkSpan<const SkGlyphID> glyphIDs, | |
| const SkScalar* xpos, SkScalar constY, SkPoint* positions, | |
| SkSpan<const char> text, SkSpan<const uint32_t> clusters) { | |
| auto posCursor = positions; | |
| for (auto x : SkSpan<const SkScalar>{xpos, glyphIDs.size()}) { | |
| *posCursor++ = SkPoint::Make(x, constY); | |
| } | |
| simplifyDrawPosText(font, glyphIDs, positions, text, clusters); | |
| } | |
| void SkGlyphRunBuilder::simplifyDrawPosText( | |
| const SkFont& font, SkSpan<const SkGlyphID> glyphIDs, | |
| const SkPoint* pos, | |
| SkSpan<const char> text, SkSpan<const uint32_t> clusters) { | |
| auto runSize = glyphIDs.size(); | |
| this->makeGlyphRun( | |
| font, | |
| glyphIDs, | |
| SkSpan<const SkPoint>{pos, runSize}, | |
| text, | |
| clusters); | |
| } |