1 /*
2 * Copyright 2019 Google Inc.
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 "modules/skparagraph/tests/SkShaperJSONWriter.h"
9
10 #include "include/core/SkFont.h"
11 #include "include/core/SkSpan.h"
12 #include "include/core/SkString.h"
13 #include "include/core/SkTypeface.h"
14 #include "include/private/base/SkTo.h"
15 #include "src/base/SkUTF.h"
16 #include "src/utils/SkJSONWriter.h"
17
18 #include <algorithm>
19 #include <cstddef>
20 #include <limits>
21 #include <string>
22 #include <type_traits>
23
SkShaperJSONWriter(SkJSONWriter * JSONWriter,const char * utf8,size_t size)24 SkShaperJSONWriter::SkShaperJSONWriter(SkJSONWriter* JSONWriter, const char* utf8, size_t size)
25 : fJSONWriter{JSONWriter}
26 , fUTF8{utf8, size} {}
27
beginLine()28 void SkShaperJSONWriter::beginLine() { }
29
runInfo(const SkShaper::RunHandler::RunInfo & info)30 void SkShaperJSONWriter::runInfo(const SkShaper::RunHandler::RunInfo& info) { }
31
commitRunInfo()32 void SkShaperJSONWriter::commitRunInfo() { }
33
34 SkShaper::RunHandler::Buffer
runBuffer(const SkShaper::RunHandler::RunInfo & info)35 SkShaperJSONWriter::runBuffer(const SkShaper::RunHandler::RunInfo& info) {
36 fGlyphs.resize(info.glyphCount);
37 fPositions.resize(info.glyphCount);
38 fClusters.resize(info.glyphCount);
39 return {fGlyphs.data(), fPositions.data(), nullptr, fClusters.data(), {0, 0}};
40 }
41
is_one_to_one(const char utf8[],size_t utf8Begin,size_t utf8End,std::vector<uint32_t> & clusters)42 static bool is_one_to_one(const char utf8[], size_t utf8Begin, size_t utf8End,
43 std::vector<uint32_t>& clusters) {
44 size_t lastUtf8Index = utf8End;
45
46 auto checkCluster = [&](size_t clusterIndex) {
47 if (clusters[clusterIndex] >= lastUtf8Index) {
48 return false;
49 }
50 size_t utf8ClusterSize = lastUtf8Index - clusters[clusterIndex];
51 if (SkUTF::CountUTF8(&utf8[clusters[clusterIndex]], utf8ClusterSize) != 1) {
52 return false;
53 }
54 lastUtf8Index = clusters[clusterIndex];
55 return true;
56 };
57
58 if (clusters.front() <= clusters.back()) {
59 // left-to-right clusters
60 size_t clusterCursor = clusters.size();
61 while (clusterCursor > 0) {
62 if (!checkCluster(--clusterCursor)) { return false; }
63 }
64 } else {
65 // right-to-left clusters
66 size_t clusterCursor = 0;
67 while (clusterCursor < clusters.size()) {
68 if (!checkCluster(clusterCursor++)) { return false; }
69 }
70 }
71
72 return true;
73 }
74
commitRunBuffer(const SkShaper::RunHandler::RunInfo & info)75 void SkShaperJSONWriter::commitRunBuffer(const SkShaper::RunHandler::RunInfo& info) {
76 fJSONWriter->beginObject("run", true);
77
78 // Font name
79 SkString fontName;
80 info.fFont.getTypeface()->getFamilyName(&fontName);
81 fJSONWriter->appendString("font name", fontName);
82
83 // Font size
84 fJSONWriter->appendFloat("font size", info.fFont.getSize());
85
86 if (info.fBidiLevel > 0) {
87 std::string bidiType = info.fBidiLevel % 2 == 0 ? "left-to-right" : "right-to-left";
88 std::string bidiOutput = bidiType + " lvl " + std::to_string(info.fBidiLevel);
89 fJSONWriter->appendString("BiDi", bidiOutput);
90 }
91
92 if (is_one_to_one(fUTF8.c_str(), info.utf8Range.begin(), info.utf8Range.end(), fClusters)) {
93 std::string utf8{&fUTF8[info.utf8Range.begin()], info.utf8Range.size()};
94 fJSONWriter->appendString("UTF8", utf8);
95
96 fJSONWriter->beginArray("glyphs", false);
97 for (auto glyphID : fGlyphs) {
98 fJSONWriter->appendU32(glyphID);
99 }
100 fJSONWriter->endArray();
101
102 fJSONWriter->beginArray("clusters", false);
103 for (auto cluster : fClusters) {
104 fJSONWriter->appendU32(cluster);
105 }
106 fJSONWriter->endArray();
107 } else {
108 VisualizeClusters(fUTF8.c_str(),
109 info.utf8Range.begin(), info.utf8Range.end(),
110 SkSpan(fGlyphs),
111 SkSpan(fClusters),
112 [this](size_t codePointCount, SkSpan<const char> utf1to1,
113 SkSpan<const SkGlyphID> glyph1to1) {
114 this->displayMToN(codePointCount, utf1to1, glyph1to1);
115 });
116 }
117
118 if (info.glyphCount > 1) {
119 fJSONWriter->beginArray("horizontal positions", false);
120 for (auto position : fPositions) {
121 fJSONWriter->appendFloat(position.x());
122 }
123 fJSONWriter->endArray();
124 }
125
126 fJSONWriter->beginArray("advances", false);
127 for (size_t i = 1; i < info.glyphCount; i++) {
128 fJSONWriter->appendFloat(fPositions[i].fX - fPositions[i-1].fX);
129 }
130 SkPoint lastAdvance = info.fAdvance - (fPositions.back() - fPositions.front());
131 fJSONWriter->appendFloat(lastAdvance.fX);
132 fJSONWriter->endArray();
133
134 fJSONWriter->endObject();
135 }
136
BreakupClusters(size_t utf8Begin,size_t utf8End,SkSpan<const uint32_t> clusters,const BreakupClustersCallback & processMToN)137 void SkShaperJSONWriter::BreakupClusters(size_t utf8Begin, size_t utf8End,
138 SkSpan<const uint32_t> clusters,
139 const BreakupClustersCallback& processMToN) {
140
141 if (clusters.front() <= clusters.back()) {
142 // Handle left-to-right text direction
143 size_t glyphStartIndex = 0;
144 for (size_t glyphEndIndex = 0; glyphEndIndex < clusters.size(); glyphEndIndex++) {
145
146 if (clusters[glyphStartIndex] == clusters[glyphEndIndex]) { continue; }
147
148 processMToN(glyphStartIndex, glyphEndIndex,
149 clusters[glyphStartIndex], clusters[glyphEndIndex]);
150
151 glyphStartIndex = glyphEndIndex;
152 }
153
154 processMToN(glyphStartIndex, clusters.size(), clusters[glyphStartIndex], utf8End);
155
156 } else {
157 // Handle right-to-left text direction.
158 SkASSERT(clusters.size() >= 2);
159 size_t glyphStartIndex = 0;
160 uint32_t utf8EndIndex = utf8End;
161 for (size_t glyphEndIndex = 0; glyphEndIndex < clusters.size(); glyphEndIndex++) {
162
163 if (clusters[glyphStartIndex] == clusters[glyphEndIndex]) { continue; }
164
165 processMToN(glyphStartIndex, glyphEndIndex,
166 clusters[glyphStartIndex], utf8EndIndex);
167
168 utf8EndIndex = clusters[glyphStartIndex];
169 glyphStartIndex = glyphEndIndex;
170 }
171 processMToN(glyphStartIndex, clusters.size(), utf8Begin, clusters[glyphStartIndex-1]);
172 }
173 }
174
VisualizeClusters(const char * utf8,size_t utf8Begin,size_t utf8End,SkSpan<const SkGlyphID> glyphIDs,SkSpan<const uint32_t> clusters,const VisualizeClustersCallback & processMToN)175 void SkShaperJSONWriter::VisualizeClusters(const char* utf8, size_t utf8Begin, size_t utf8End,
176 SkSpan<const SkGlyphID> glyphIDs,
177 SkSpan<const uint32_t> clusters,
178 const VisualizeClustersCallback& processMToN) {
179
180 size_t glyphRangeStart, glyphRangeEnd;
181 uint32_t utf8RangeStart, utf8RangeEnd;
182
183 auto resetRanges = [&]() {
184 glyphRangeStart = std::numeric_limits<size_t>::max();
185 glyphRangeEnd = 0;
186 utf8RangeStart = std::numeric_limits<uint32_t>::max();
187 utf8RangeEnd = 0;
188 };
189
190 auto checkRangesAndProcess = [&]() {
191 if (glyphRangeStart < glyphRangeEnd) {
192 size_t glyphRangeCount = glyphRangeEnd - glyphRangeStart;
193 SkSpan<const char> utf8Span{&utf8[utf8RangeStart], utf8RangeEnd - utf8RangeStart};
194 SkSpan<const SkGlyphID> glyphSpan{&glyphIDs[glyphRangeStart], glyphRangeCount};
195
196 // Glyph count is the same as codepoint count for 1:1.
197 processMToN(glyphRangeCount, utf8Span, glyphSpan);
198 }
199 resetRanges();
200 };
201
202 auto gatherRuns = [&](size_t glyphStartIndex, size_t glyphEndIndex,
203 uint32_t utf8StartIndex, uint32_t utf8EndIndex) {
204 int possibleCount = SkUTF::CountUTF8(&utf8[utf8StartIndex], utf8EndIndex - utf8StartIndex);
205 if (possibleCount == -1) { return; }
206 size_t codePointCount = SkTo<size_t>(possibleCount);
207 if (codePointCount == 1 && glyphEndIndex - glyphStartIndex == 1) {
208 glyphRangeStart = std::min(glyphRangeStart, glyphStartIndex);
209 glyphRangeEnd = std::max(glyphRangeEnd, glyphEndIndex );
210 utf8RangeStart = std::min(utf8RangeStart, utf8StartIndex );
211 utf8RangeEnd = std::max(utf8RangeEnd, utf8EndIndex );
212 } else {
213 checkRangesAndProcess();
214
215 SkSpan<const char> utf8Span{&utf8[utf8StartIndex], utf8EndIndex - utf8StartIndex};
216 SkSpan<const SkGlyphID> glyphSpan{&glyphIDs[glyphStartIndex],
217 glyphEndIndex - glyphStartIndex};
218
219 processMToN(codePointCount, utf8Span, glyphSpan);
220 }
221 };
222
223 resetRanges();
224 BreakupClusters(utf8Begin, utf8End, clusters, gatherRuns);
225 checkRangesAndProcess();
226 }
227
displayMToN(size_t codePointCount,SkSpan<const char> utf8,SkSpan<const SkGlyphID> glyphIDs)228 void SkShaperJSONWriter::displayMToN(size_t codePointCount,
229 SkSpan<const char> utf8,
230 SkSpan<const SkGlyphID> glyphIDs) {
231 std::string nString = std::to_string(codePointCount);
232 std::string mString = std::to_string(glyphIDs.size());
233 std::string clusterName = "cluster " + nString + " to " + mString;
234 fJSONWriter->beginObject(clusterName.c_str(), true);
235 std::string utf8String{utf8.data(), utf8.size()};
236 fJSONWriter->appendString("UTF", utf8String);
237 fJSONWriter->beginArray("glyphsIDs", false);
238 for (auto glyphID : glyphIDs) {
239 fJSONWriter->appendU32(glyphID);
240 }
241 fJSONWriter->endArray();
242 fJSONWriter->endObject();
243 }
244