1 /*
2 * Copyright 2022 Google LLC
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "src/text/gpu/GlyphVector.h"
9
10 #include "include/private/base/SkAssert.h"
11 #include "include/private/base/SkTo.h"
12 #include "src/core/SkGlyph.h"
13 #include "src/core/SkReadBuffer.h"
14 #include "src/core/SkStrike.h"
15 #include "src/core/SkStrikeCache.h"
16 #include "src/core/SkWriteBuffer.h"
17 #include "src/text/StrikeForGPU.h"
18 #include "src/text/gpu/SubRunAllocator.h"
19
20 #include <climits>
21 #include <optional>
22 #include <utility>
23
24 class SkStrikeClient;
25
26 using MaskFormat = skgpu::MaskFormat;
27
28 namespace sktext::gpu {
29 class Glyph;
30
31 // -- GlyphVector ----------------------------------------------------------------------------------
GlyphVector(SkStrikePromise && strikePromise,SkSpan<Variant> glyphs)32 GlyphVector::GlyphVector(SkStrikePromise&& strikePromise, SkSpan<Variant> glyphs)
33 : fStrikePromise{std::move(strikePromise)}
34 , fGlyphs{glyphs} {
35 SkASSERT(!fGlyphs.empty());
36 }
37
Make(SkStrikePromise && promise,SkSpan<const SkPackedGlyphID> packedIDs,SubRunAllocator * alloc)38 GlyphVector GlyphVector::Make(SkStrikePromise&& promise,
39 SkSpan<const SkPackedGlyphID> packedIDs,
40 SubRunAllocator* alloc) {
41 SkASSERT(!packedIDs.empty());
42 auto packedIDToVariant = [] (SkPackedGlyphID packedID) {
43 return Variant{packedID};
44 };
45
46 return GlyphVector{std::move(promise),
47 alloc->makePODArray<Variant>(packedIDs, packedIDToVariant)};
48 }
49
MakeFromBuffer(SkReadBuffer & buffer,const SkStrikeClient * client,SubRunAllocator * alloc)50 std::optional<GlyphVector> GlyphVector::MakeFromBuffer(SkReadBuffer& buffer,
51 const SkStrikeClient* client,
52 SubRunAllocator* alloc) {
53 std::optional<SkStrikePromise> promise =
54 SkStrikePromise::MakeFromBuffer(buffer, client, SkStrikeCache::GlobalStrikeCache());
55 if (!buffer.validate(promise.has_value())) {
56 return std::nullopt;
57 }
58
59 int32_t glyphCount = buffer.read32();
60 // Since the glyph count can never be zero. There was a buffer reading problem.
61 if (!buffer.validate(glyphCount > 0)) {
62 return std::nullopt;
63 }
64
65 // Make sure we can multiply without overflow in the check below.
66 static constexpr int kMaxCount = (int)(INT_MAX / sizeof(uint32_t));
67 if (!buffer.validate(glyphCount <= kMaxCount)) {
68 return std::nullopt;
69 }
70
71 // Check for enough bytes to populate the packedGlyphID array. If not enough something has
72 // gone wrong.
73 if (!buffer.validate(glyphCount * sizeof(uint32_t) <= buffer.available())) {
74 return std::nullopt;
75 }
76
77 Variant* variants = alloc->makePODArray<Variant>(glyphCount);
78 for (int i = 0; i < glyphCount; i++) {
79 variants[i].packedGlyphID = SkPackedGlyphID(buffer.readUInt());
80 }
81 return GlyphVector{std::move(promise.value()), SkSpan(variants, glyphCount)};
82 }
83
flatten(SkWriteBuffer & buffer) const84 void GlyphVector::flatten(SkWriteBuffer& buffer) const {
85 // There should never be a glyph vector with zero glyphs.
86 SkASSERT(!fGlyphs.empty());
87 fStrikePromise.flatten(buffer);
88
89 // Write out the span of packedGlyphIDs.
90 buffer.write32(SkTo<int32_t>(fGlyphs.size()));
91 for (Variant variant : fGlyphs) {
92 buffer.writeUInt(variant.packedGlyphID.value());
93 }
94 }
95
glyphs() const96 SkSpan<const Glyph*> GlyphVector::glyphs() const {
97 return SkSpan(reinterpret_cast<const Glyph**>(fGlyphs.data()), fGlyphs.size());
98 }
99
100 // packedGlyphIDToGlyph must be run in single-threaded mode.
101 // If fSkStrike is not sk_sp<SkStrike> then the conversion to Glyph* has not happened.
packedGlyphIDToGlyph(StrikeCache * cache)102 void GlyphVector::packedGlyphIDToGlyph(StrikeCache* cache) {
103 if (fTextStrike == nullptr) {
104 SkStrike* strike = fStrikePromise.strike();
105 fTextStrike = cache->findOrCreateStrike(strike->strikeSpec());
106
107 // Get all the atlas locations for each glyph.
108 for (Variant& variant : fGlyphs) {
109 variant.glyph = fTextStrike->getGlyph(variant.packedGlyphID);
110 }
111
112 // This must be pinned for the Atlas filling to work.
113 strike->verifyPinnedStrike();
114
115 // Drop the ref to the strike so that it can be purged if needed.
116 fStrikePromise.resetStrike();
117 }
118 }
119 } // namespace sktext::gpu
120