blob: 3386f7c3f53c835e8679924d91792b67cbf7d3f8 [file] [log] [blame]
Ben Wagnera25fbef2017-08-30 13:56:19 -04001/*
2 * Copyright 2016 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
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "include/core/SkFont.h"
9#include "include/core/SkFontArguments.h"
10#include "include/core/SkFontMetrics.h"
11#include "include/core/SkFontMgr.h"
12#include "include/core/SkFontTypes.h"
13#include "include/core/SkPaint.h"
14#include "include/core/SkPoint.h"
15#include "include/core/SkRect.h"
16#include "include/core/SkRefCnt.h"
17#include "include/core/SkScalar.h"
18#include "include/core/SkStream.h"
19#include "include/core/SkTypeface.h"
20#include "include/core/SkTypes.h"
21#include "include/private/SkBitmaskEnum.h"
22#include "include/private/SkMalloc.h"
23#include "include/private/SkTArray.h"
24#include "include/private/SkTFitsIn.h"
25#include "include/private/SkTemplates.h"
26#include "include/private/SkTo.h"
27#include "modules/skshaper/include/SkShaper.h"
Ben Wagner24ee4e02019-10-11 10:36:10 -040028#include "src/core/SkSpan.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050029#include "src/core/SkTDPQueue.h"
30#include "src/utils/SkUTF.h"
Ben Wagner17774242018-08-07 14:31:33 -040031
32#include <hb.h>
Ben Wagner1383a382019-04-03 17:53:53 -040033#include <hb-icu.h>
Ben Wagner17774242018-08-07 14:31:33 -040034#include <hb-ot.h>
Ben Wagner17774242018-08-07 14:31:33 -040035#include <unicode/ubidi.h>
Ben Wagner1383a382019-04-03 17:53:53 -040036#include <unicode/ubrk.h>
37#include <unicode/umachine.h>
Ben Wagner17774242018-08-07 14:31:33 -040038#include <unicode/urename.h>
Ben Wagner1383a382019-04-03 17:53:53 -040039#include <unicode/uscript.h>
40#include <unicode/ustring.h>
Ben Wagner17774242018-08-07 14:31:33 -040041#include <unicode/utext.h>
42#include <unicode/utypes.h>
43
Ben Wagner0ec8ec22018-09-04 18:17:13 -040044#include <cstring>
Ben Wagner17774242018-08-07 14:31:33 -040045#include <memory>
Ben Wagner1383a382019-04-03 17:53:53 -040046#include <type_traits>
Ben Wagner17774242018-08-07 14:31:33 -040047#include <utility>
Ben Wagnera25fbef2017-08-30 13:56:19 -040048
Hal Canary61021922019-02-06 12:29:11 -050049#if defined(SK_USING_THIRD_PARTY_ICU)
Hal Canary32498f02019-02-04 15:36:31 -050050#include "SkLoadICU.h"
Hal Canary61021922019-02-06 12:29:11 -050051#endif
Hal Canary32498f02019-02-04 15:36:31 -050052
Ben Wagner24ee4e02019-10-11 10:36:10 -040053// HB_FEATURE_GLOBAL_START and HB_FEATURE_GLOBAL_END were not added until HarfBuzz 2.0
54// They would have always worked, they just hadn't been named yet.
55#if !defined(HB_FEATURE_GLOBAL_START)
56# define HB_FEATURE_GLOBAL_START 0
57#endif
58#if !defined(HB_FEATURE_GLOBAL_END)
59# define HB_FEATURE_GLOBAL_END ((unsigned int) -1)
60#endif
61
Ben Wagner2fc14742019-02-06 16:37:44 -050062namespace skstd {
63template <> struct is_bitmask_enum<hb_buffer_flags_t> : std::true_type {};
64}
65
Ben Wagnera25fbef2017-08-30 13:56:19 -040066namespace {
Ben Wagner24ee4e02019-10-11 10:36:10 -040067template <typename T,typename P,P* p> using resource = std::unique_ptr<T, SkFunctionWrapper<P, p>>;
68using HBBlob = resource<hb_blob_t , decltype(hb_blob_destroy) , hb_blob_destroy >;
69using HBFace = resource<hb_face_t , decltype(hb_face_destroy) , hb_face_destroy >;
70using HBFont = resource<hb_font_t , decltype(hb_font_destroy) , hb_font_destroy >;
71using HBBuffer = resource<hb_buffer_t , decltype(hb_buffer_destroy), hb_buffer_destroy>;
72using ICUBiDi = resource<UBiDi , decltype(ubidi_close) , ubidi_close >;
73using ICUBrk = resource<UBreakIterator, decltype(ubrk_close) , ubrk_close >;
74using ICUUText = resource<UText , decltype(utext_close) , utext_close >;
Ben Wagnera25fbef2017-08-30 13:56:19 -040075
76HBBlob stream_to_blob(std::unique_ptr<SkStreamAsset> asset) {
77 size_t size = asset->getLength();
78 HBBlob blob;
79 if (const void* base = asset->getMemoryBase()) {
80 blob.reset(hb_blob_create((char*)base, SkToUInt(size),
81 HB_MEMORY_MODE_READONLY, asset.release(),
82 [](void* p) { delete (SkStreamAsset*)p; }));
83 } else {
84 // SkDebugf("Extra SkStreamAsset copy\n");
85 void* ptr = size ? sk_malloc_throw(size) : nullptr;
86 asset->read(ptr, size);
87 blob.reset(hb_blob_create((char*)ptr, SkToUInt(size),
88 HB_MEMORY_MODE_READONLY, ptr, sk_free));
89 }
90 SkASSERT(blob);
91 hb_blob_make_immutable(blob.get());
92 return blob;
93}
Ben Wagnera25fbef2017-08-30 13:56:19 -040094
Ben Wagnerf61c9362019-02-13 12:01:45 -050095hb_position_t skhb_position(SkScalar value) {
96 // Treat HarfBuzz hb_position_t as 16.16 fixed-point.
97 constexpr int kHbPosition1 = 1 << 16;
98 return SkScalarRoundToInt(value * kHbPosition1);
99}
100
101hb_bool_t skhb_glyph(hb_font_t* hb_font,
102 void* font_data,
103 hb_codepoint_t unicode,
104 hb_codepoint_t variation_selector,
105 hb_codepoint_t* glyph,
106 void* user_data) {
107 SkFont& font = *reinterpret_cast<SkFont*>(font_data);
108
109 *glyph = font.unicharToGlyph(unicode);
110 return *glyph != 0;
111}
112
113hb_bool_t skhb_nominal_glyph(hb_font_t* hb_font,
114 void* font_data,
115 hb_codepoint_t unicode,
116 hb_codepoint_t* glyph,
117 void* user_data) {
118 return skhb_glyph(hb_font, font_data, unicode, 0, glyph, user_data);
119}
120
121unsigned skhb_nominal_glyphs(hb_font_t *hb_font, void *font_data,
122 unsigned int count,
123 const hb_codepoint_t *unicodes,
124 unsigned int unicode_stride,
125 hb_codepoint_t *glyphs,
126 unsigned int glyph_stride,
127 void *user_data) {
128 SkFont& font = *reinterpret_cast<SkFont*>(font_data);
129
130 // Batch call textToGlyphs since entry cost is not cheap.
131 // Copy requred because textToGlyphs is dense and hb is strided.
132 SkAutoSTMalloc<256, SkUnichar> unicode(count);
133 for (unsigned i = 0; i < count; i++) {
134 unicode[i] = *unicodes;
135 unicodes = SkTAddOffset<const hb_codepoint_t>(unicodes, unicode_stride);
136 }
137 SkAutoSTMalloc<256, SkGlyphID> glyph(count);
Ben Wagner51e15a62019-05-07 15:38:46 -0400138 font.textToGlyphs(unicode.get(), count * sizeof(SkUnichar), SkTextEncoding::kUTF32,
Ben Wagnerf61c9362019-02-13 12:01:45 -0500139 glyph.get(), count);
140
141 // Copy the results back to the sparse array.
Ben Wagnerbedbb072019-07-31 15:21:03 -0400142 unsigned int done;
143 for (done = 0; done < count && glyph[done] != 0; done++) {
144 *glyphs = glyph[done];
Ben Wagnerf61c9362019-02-13 12:01:45 -0500145 glyphs = SkTAddOffset<hb_codepoint_t>(glyphs, glyph_stride);
146 }
Ben Wagnerbedbb072019-07-31 15:21:03 -0400147 // return 'done' to allow HarfBuzz to synthesize with NFC and spaces, return 'count' to avoid
148 return done;
Ben Wagnerf61c9362019-02-13 12:01:45 -0500149}
150
151hb_position_t skhb_glyph_h_advance(hb_font_t* hb_font,
152 void* font_data,
Ben Wagner32b45b32020-01-22 13:47:07 -0500153 hb_codepoint_t hbGlyph,
Ben Wagnerf61c9362019-02-13 12:01:45 -0500154 void* user_data) {
155 SkFont& font = *reinterpret_cast<SkFont*>(font_data);
156
157 SkScalar advance;
Ben Wagner32b45b32020-01-22 13:47:07 -0500158 SkGlyphID skGlyph = SkTo<SkGlyphID>(hbGlyph);
Ben Wagnerf61c9362019-02-13 12:01:45 -0500159
Ben Wagner32b45b32020-01-22 13:47:07 -0500160 font.getWidths(&skGlyph, 1, &advance);
Ben Wagnerf61c9362019-02-13 12:01:45 -0500161 if (!font.isSubpixel()) {
162 advance = SkScalarRoundToInt(advance);
163 }
164 return skhb_position(advance);
165}
166
167void skhb_glyph_h_advances(hb_font_t* hb_font,
168 void* font_data,
169 unsigned count,
170 const hb_codepoint_t* glyphs,
171 unsigned int glyph_stride,
172 hb_position_t* advances,
173 unsigned int advance_stride,
174 void* user_data) {
175 SkFont& font = *reinterpret_cast<SkFont*>(font_data);
176
177 // Batch call getWidths since entry cost is not cheap.
178 // Copy requred because getWidths is dense and hb is strided.
179 SkAutoSTMalloc<256, SkGlyphID> glyph(count);
180 for (unsigned i = 0; i < count; i++) {
181 glyph[i] = *glyphs;
182 glyphs = SkTAddOffset<const hb_codepoint_t>(glyphs, glyph_stride);
183 }
184 SkAutoSTMalloc<256, SkScalar> advance(count);
185 font.getWidths(glyph.get(), count, advance.get());
186
187 if (!font.isSubpixel()) {
188 for (unsigned i = 0; i < count; i++) {
189 advance[i] = SkScalarRoundToInt(advance[i]);
190 }
191 }
192
193 // Copy the results back to the sparse array.
194 for (unsigned i = 0; i < count; i++) {
195 *advances = skhb_position(advance[i]);
196 advances = SkTAddOffset<hb_position_t>(advances, advance_stride);
197 }
198}
199
200// HarfBuzz callback to retrieve glyph extents, mainly used by HarfBuzz for
201// fallback mark positioning, i.e. the situation when the font does not have
202// mark anchors or other mark positioning rules, but instead HarfBuzz is
203// supposed to heuristically place combining marks around base glyphs. HarfBuzz
204// does this by measuring "ink boxes" of glyphs, and placing them according to
205// Unicode mark classes. Above, below, centered or left or right, etc.
206hb_bool_t skhb_glyph_extents(hb_font_t* hb_font,
207 void* font_data,
Ben Wagner32b45b32020-01-22 13:47:07 -0500208 hb_codepoint_t hbGlyph,
Ben Wagnerf61c9362019-02-13 12:01:45 -0500209 hb_glyph_extents_t* extents,
210 void* user_data) {
211 SkFont& font = *reinterpret_cast<SkFont*>(font_data);
Ben Wagnerf61c9362019-02-13 12:01:45 -0500212 SkASSERT(extents);
213
214 SkRect sk_bounds;
Ben Wagner32b45b32020-01-22 13:47:07 -0500215 SkGlyphID skGlyph = SkTo<SkGlyphID>(hbGlyph);
Ben Wagnerf61c9362019-02-13 12:01:45 -0500216
Ben Wagner32b45b32020-01-22 13:47:07 -0500217 font.getWidths(&skGlyph, 1, nullptr, &sk_bounds);
Ben Wagnerf61c9362019-02-13 12:01:45 -0500218 if (!font.isSubpixel()) {
219 sk_bounds.set(sk_bounds.roundOut());
220 }
221
222 // Skia is y-down but HarfBuzz is y-up.
223 extents->x_bearing = skhb_position(sk_bounds.fLeft);
224 extents->y_bearing = skhb_position(-sk_bounds.fTop);
225 extents->width = skhb_position(sk_bounds.width());
226 extents->height = skhb_position(-sk_bounds.height());
227 return true;
228}
229
Kevin Lubick867da4b2019-02-22 15:55:39 -0500230#define SK_HB_VERSION_CHECK(x, y, z) \
231 (HB_VERSION_MAJOR > (x)) || \
232 (HB_VERSION_MAJOR == (x) && HB_VERSION_MINOR > (y)) || \
233 (HB_VERSION_MAJOR == (x) && HB_VERSION_MINOR == (y) && HB_VERSION_MICRO >= (z))
234
Ben Wagnerf61c9362019-02-13 12:01:45 -0500235hb_font_funcs_t* skhb_get_font_funcs() {
236 static hb_font_funcs_t* const funcs = []{
237 // HarfBuzz will use the default (parent) implementation if they aren't set.
238 hb_font_funcs_t* const funcs = hb_font_funcs_create();
239 hb_font_funcs_set_variation_glyph_func(funcs, skhb_glyph, nullptr, nullptr);
240 hb_font_funcs_set_nominal_glyph_func(funcs, skhb_nominal_glyph, nullptr, nullptr);
Kevin Lubick867da4b2019-02-22 15:55:39 -0500241#if SK_HB_VERSION_CHECK(2, 0, 0)
Ben Wagnerf61c9362019-02-13 12:01:45 -0500242 hb_font_funcs_set_nominal_glyphs_func(funcs, skhb_nominal_glyphs, nullptr, nullptr);
Kevin Lubick867da4b2019-02-22 15:55:39 -0500243#else
244 sk_ignore_unused_variable(skhb_nominal_glyphs);
245#endif
Ben Wagnerf61c9362019-02-13 12:01:45 -0500246 hb_font_funcs_set_glyph_h_advance_func(funcs, skhb_glyph_h_advance, nullptr, nullptr);
Kevin Lubick867da4b2019-02-22 15:55:39 -0500247#if SK_HB_VERSION_CHECK(1, 8, 6)
Ben Wagnerf61c9362019-02-13 12:01:45 -0500248 hb_font_funcs_set_glyph_h_advances_func(funcs, skhb_glyph_h_advances, nullptr, nullptr);
Kevin Lubick867da4b2019-02-22 15:55:39 -0500249#else
250 sk_ignore_unused_variable(skhb_glyph_h_advances);
251#endif
Ben Wagnerf61c9362019-02-13 12:01:45 -0500252 hb_font_funcs_set_glyph_extents_func(funcs, skhb_glyph_extents, nullptr, nullptr);
253 hb_font_funcs_make_immutable(funcs);
254 return funcs;
255 }();
256 SkASSERT(funcs);
257 return funcs;
258}
259
260hb_blob_t* skhb_get_table(hb_face_t* face, hb_tag_t tag, void* user_data) {
261 SkTypeface& typeface = *reinterpret_cast<SkTypeface*>(user_data);
262
Mike Reed6d907fa2019-07-24 14:51:34 -0400263 auto data = typeface.copyTableData(tag);
264 if (!data) {
Hal Canary0dfa2082018-10-31 13:02:49 -0400265 return nullptr;
266 }
Mike Reed6d907fa2019-07-24 14:51:34 -0400267 SkData* rawData = data.release();
268 return hb_blob_create(reinterpret_cast<char*>(rawData->writable_data()), rawData->size(),
269 HB_MEMORY_MODE_WRITABLE, rawData, [](void* ctx) {
Ben Wagner89e1f602019-09-27 17:02:53 -0400270 SkSafeUnref(((SkData*)ctx));
Mike Reed6d907fa2019-07-24 14:51:34 -0400271 });
Ben Wagnerf61c9362019-02-13 12:01:45 -0500272}
273
274HBFont create_hb_font(const SkFont& font) {
Ben Wagnere8db3252019-05-29 18:54:26 -0400275 SkASSERT(font.getTypeface());
Ben Wagnera25fbef2017-08-30 13:56:19 -0400276 int index;
Ben Wagnerff84d8a2019-02-26 15:39:41 -0500277 std::unique_ptr<SkStreamAsset> typefaceAsset = font.getTypeface()->openStream(&index);
Ben Wagnerf61c9362019-02-13 12:01:45 -0500278 HBFace face;
Hal Canaryddef43f2018-11-16 10:53:51 -0500279 if (!typefaceAsset) {
Ben Wagnerf61c9362019-02-13 12:01:45 -0500280 face.reset(hb_face_create_for_tables(
281 skhb_get_table,
282 reinterpret_cast<void *>(font.refTypeface().release()),
283 [](void* user_data){ SkSafeUnref(reinterpret_cast<SkTypeface*>(user_data)); }));
284 } else {
285 HBBlob blob(stream_to_blob(std::move(typefaceAsset)));
286 face.reset(hb_face_create(blob.get(), (unsigned)index));
Hal Canaryddef43f2018-11-16 10:53:51 -0500287 }
Ben Wagnera25fbef2017-08-30 13:56:19 -0400288 SkASSERT(face);
289 if (!face) {
Ben Wagnere0001732017-08-31 16:26:26 -0400290 return nullptr;
Ben Wagnera25fbef2017-08-30 13:56:19 -0400291 }
292 hb_face_set_index(face.get(), (unsigned)index);
Ben Wagnerf61c9362019-02-13 12:01:45 -0500293 hb_face_set_upem(face.get(), font.getTypeface()->getUnitsPerEm());
Ben Wagnera25fbef2017-08-30 13:56:19 -0400294
Ben Wagnerf61c9362019-02-13 12:01:45 -0500295 HBFont otFont(hb_font_create(face.get()));
296 SkASSERT(otFont);
297 if (!otFont) {
Ben Wagnere0001732017-08-31 16:26:26 -0400298 return nullptr;
299 }
Ben Wagnerf61c9362019-02-13 12:01:45 -0500300 hb_ot_font_set_funcs(otFont.get());
301 int axis_count = font.getTypeface()->getVariationDesignPosition(nullptr, 0);
Ben Wagnere0001732017-08-31 16:26:26 -0400302 if (axis_count > 0) {
303 SkAutoSTMalloc<4, SkFontArguments::VariationPosition::Coordinate> axis_values(axis_count);
Ben Wagnerf61c9362019-02-13 12:01:45 -0500304 if (font.getTypeface()->getVariationDesignPosition(axis_values, axis_count) == axis_count) {
305 hb_font_set_variations(otFont.get(),
Ben Wagnere0001732017-08-31 16:26:26 -0400306 reinterpret_cast<hb_variation_t*>(axis_values.get()),
307 axis_count);
308 }
309 }
Ben Wagnerf61c9362019-02-13 12:01:45 -0500310
311 // Creating a sub font means that non-available functions
312 // are found from the parent.
313 HBFont skFont(hb_font_create_sub_font(otFont.get()));
314 hb_font_set_funcs(skFont.get(), skhb_get_font_funcs(),
315 reinterpret_cast<void *>(new SkFont(font)),
316 [](void* user_data){ delete reinterpret_cast<SkFont*>(user_data); });
317 int scale = skhb_position(font.getSize());
318 hb_font_set_scale(skFont.get(), scale, scale);
319
320 return skFont;
Ben Wagnere0001732017-08-31 16:26:26 -0400321}
322
Ben Wagner1383a382019-04-03 17:53:53 -0400323/** Replaces invalid utf-8 sequences with REPLACEMENT CHARACTER U+FFFD. */
Hal Canaryf107a2f2018-07-25 16:52:48 -0400324static inline SkUnichar utf8_next(const char** ptr, const char* end) {
325 SkUnichar val = SkUTF::NextUTF8(ptr, end);
Ben Wagner1383a382019-04-03 17:53:53 -0400326 return val < 0 ? 0xFFFD : val;
Hal Canaryf107a2f2018-07-25 16:52:48 -0400327}
328
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400329class IcuBiDiRunIterator final : public SkShaper::BiDiRunIterator {
Ben Wagner8d45a382017-11-16 10:08:28 -0500330public:
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400331 IcuBiDiRunIterator(const char* utf8, const char* end, ICUBiDi bidi)
Ben Wagner8d45a382017-11-16 10:08:28 -0500332 : fBidi(std::move(bidi))
333 , fEndOfCurrentRun(utf8)
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400334 , fBegin(utf8)
335 , fEnd(end)
Ben Wagner8d45a382017-11-16 10:08:28 -0500336 , fUTF16LogicalPosition(0)
337 , fLevel(UBIDI_DEFAULT_LTR)
338 {}
339 void consume() override {
340 SkASSERT(fUTF16LogicalPosition < ubidi_getLength(fBidi.get()));
341 int32_t endPosition = ubidi_getLength(fBidi.get());
342 fLevel = ubidi_getLevelAt(fBidi.get(), fUTF16LogicalPosition);
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400343 SkUnichar u = utf8_next(&fEndOfCurrentRun, fEnd);
Hal Canaryf107a2f2018-07-25 16:52:48 -0400344 fUTF16LogicalPosition += SkUTF::ToUTF16(u);
Ben Wagner8d45a382017-11-16 10:08:28 -0500345 UBiDiLevel level;
346 while (fUTF16LogicalPosition < endPosition) {
347 level = ubidi_getLevelAt(fBidi.get(), fUTF16LogicalPosition);
348 if (level != fLevel) {
349 break;
350 }
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400351 u = utf8_next(&fEndOfCurrentRun, fEnd);
Julia Lavrova526df262019-08-21 17:49:44 -0400352
Hal Canaryf107a2f2018-07-25 16:52:48 -0400353 fUTF16LogicalPosition += SkUTF::ToUTF16(u);
Ben Wagner8d45a382017-11-16 10:08:28 -0500354 }
355 }
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400356 size_t endOfCurrentRun() const override {
357 return fEndOfCurrentRun - fBegin;
Ben Wagner8d45a382017-11-16 10:08:28 -0500358 }
359 bool atEnd() const override {
360 return fUTF16LogicalPosition == ubidi_getLength(fBidi.get());
361 }
362
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400363 UBiDiLevel currentLevel() const override {
Ben Wagner8d45a382017-11-16 10:08:28 -0500364 return fLevel;
365 }
366private:
367 ICUBiDi fBidi;
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400368 char const * fEndOfCurrentRun;
369 char const * const fBegin;
370 char const * const fEnd;
Ben Wagner8d45a382017-11-16 10:08:28 -0500371 int32_t fUTF16LogicalPosition;
372 UBiDiLevel fLevel;
373};
374
Ben Wagner1383a382019-04-03 17:53:53 -0400375class HbIcuScriptRunIterator final : public SkShaper::ScriptRunIterator {
Ben Wagner8d45a382017-11-16 10:08:28 -0500376public:
Ben Wagner1383a382019-04-03 17:53:53 -0400377 HbIcuScriptRunIterator(const char* utf8, size_t utf8Bytes)
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400378 : fCurrent(utf8), fBegin(utf8), fEnd(fCurrent + utf8Bytes)
Ben Wagner8d45a382017-11-16 10:08:28 -0500379 , fCurrentScript(HB_SCRIPT_UNKNOWN)
380 {}
Ben Wagner1383a382019-04-03 17:53:53 -0400381 static hb_script_t hb_script_from_icu(SkUnichar u) {
382 UErrorCode status = U_ZERO_ERROR;
383 UScriptCode scriptCode = uscript_getScript(u, &status);
384
385 if (U_FAILURE (status)) {
386 return HB_SCRIPT_UNKNOWN;
387 }
388
389 return hb_icu_script_to_script(scriptCode);
390 }
Ben Wagner8d45a382017-11-16 10:08:28 -0500391 void consume() override {
392 SkASSERT(fCurrent < fEnd);
Hal Canaryf107a2f2018-07-25 16:52:48 -0400393 SkUnichar u = utf8_next(&fCurrent, fEnd);
Ben Wagner1383a382019-04-03 17:53:53 -0400394 fCurrentScript = hb_script_from_icu(u);
Ben Wagner8d45a382017-11-16 10:08:28 -0500395 while (fCurrent < fEnd) {
396 const char* prev = fCurrent;
Hal Canaryf107a2f2018-07-25 16:52:48 -0400397 u = utf8_next(&fCurrent, fEnd);
Ben Wagner1383a382019-04-03 17:53:53 -0400398 const hb_script_t script = hb_script_from_icu(u);
Ben Wagner8d45a382017-11-16 10:08:28 -0500399 if (script != fCurrentScript) {
400 if (fCurrentScript == HB_SCRIPT_INHERITED || fCurrentScript == HB_SCRIPT_COMMON) {
401 fCurrentScript = script;
402 } else if (script == HB_SCRIPT_INHERITED || script == HB_SCRIPT_COMMON) {
403 continue;
404 } else {
405 fCurrent = prev;
406 break;
407 }
408 }
409 }
410 if (fCurrentScript == HB_SCRIPT_INHERITED) {
411 fCurrentScript = HB_SCRIPT_COMMON;
412 }
413 }
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400414 size_t endOfCurrentRun() const override {
415 return fCurrent - fBegin;
Ben Wagner8d45a382017-11-16 10:08:28 -0500416 }
417 bool atEnd() const override {
418 return fCurrent == fEnd;
419 }
420
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400421 SkFourByteTag currentScript() const override {
422 return SkSetFourByteTag(HB_UNTAG(fCurrentScript));
Ben Wagner8d45a382017-11-16 10:08:28 -0500423 }
424private:
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400425 char const * fCurrent;
426 char const * const fBegin;
427 char const * const fEnd;
Ben Wagner8d45a382017-11-16 10:08:28 -0500428 hb_script_t fCurrentScript;
429};
430
Ben Wagner8d45a382017-11-16 10:08:28 -0500431class RunIteratorQueue {
432public:
Ben Wagner1ca50522019-10-01 17:54:28 -0400433 void insert(SkShaper::RunIterator* runIterator, int priority) {
434 fEntries.insert({runIterator, priority});
Ben Wagner8d45a382017-11-16 10:08:28 -0500435 }
436
437 bool advanceRuns() {
Ben Wagner1ca50522019-10-01 17:54:28 -0400438 const SkShaper::RunIterator* leastRun = fEntries.peek().runIterator;
Ben Wagner8d45a382017-11-16 10:08:28 -0500439 if (leastRun->atEnd()) {
440 SkASSERT(this->allRunsAreAtEnd());
441 return false;
442 }
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400443 const size_t leastEnd = leastRun->endOfCurrentRun();
444 SkShaper::RunIterator* currentRun = nullptr;
445 SkDEBUGCODE(size_t previousEndOfCurrentRun);
Ben Wagner1ca50522019-10-01 17:54:28 -0400446 while ((currentRun = fEntries.peek().runIterator)->endOfCurrentRun() <= leastEnd) {
447 int priority = fEntries.peek().priority;
448 fEntries.pop();
Ben Wagner8d45a382017-11-16 10:08:28 -0500449 SkDEBUGCODE(previousEndOfCurrentRun = currentRun->endOfCurrentRun());
450 currentRun->consume();
451 SkASSERT(previousEndOfCurrentRun < currentRun->endOfCurrentRun());
Ben Wagner1ca50522019-10-01 17:54:28 -0400452 fEntries.insert({currentRun, priority});
Ben Wagner8d45a382017-11-16 10:08:28 -0500453 }
454 return true;
455 }
456
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400457 size_t endOfCurrentRun() const {
Ben Wagner1ca50522019-10-01 17:54:28 -0400458 return fEntries.peek().runIterator->endOfCurrentRun();
Ben Wagner8d45a382017-11-16 10:08:28 -0500459 }
460
461private:
462 bool allRunsAreAtEnd() const {
Ben Wagner1ca50522019-10-01 17:54:28 -0400463 for (int i = 0; i < fEntries.count(); ++i) {
464 if (!fEntries.at(i).runIterator->atEnd()) {
Ben Wagner8d45a382017-11-16 10:08:28 -0500465 return false;
466 }
467 }
468 return true;
469 }
470
Ben Wagner1ca50522019-10-01 17:54:28 -0400471 struct Entry {
472 SkShaper::RunIterator* runIterator;
473 int priority;
474 };
475 static bool CompareEntry(Entry const& a, Entry const& b) {
476 size_t aEnd = a.runIterator->endOfCurrentRun();
477 size_t bEnd = b.runIterator->endOfCurrentRun();
478 return aEnd < bEnd || (aEnd == bEnd && a.priority < b.priority);
Ben Wagner8d45a382017-11-16 10:08:28 -0500479 }
Ben Wagner1ca50522019-10-01 17:54:28 -0400480 SkTDPQueue<Entry, CompareEntry> fEntries;
Ben Wagner8d45a382017-11-16 10:08:28 -0500481};
482
483struct ShapedGlyph {
484 SkGlyphID fID;
485 uint32_t fCluster;
486 SkPoint fOffset;
487 SkVector fAdvance;
488 bool fMayLineBreakBefore;
489 bool fMustLineBreakBefore;
490 bool fHasVisual;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400491 bool fGraphemeBreakBefore;
492 bool fUnsafeToBreak;
Ben Wagner8d45a382017-11-16 10:08:28 -0500493};
494struct ShapedRun {
Ben Wagner7415a422019-03-25 15:38:22 -0400495 ShapedRun(SkShaper::RunHandler::Range utf8Range, const SkFont& font, UBiDiLevel level,
496 std::unique_ptr<ShapedGlyph[]> glyphs, size_t numGlyphs, SkVector advance = {0, 0})
497 : fUtf8Range(utf8Range), fFont(font), fLevel(level)
498 , fGlyphs(std::move(glyphs)), fNumGlyphs(numGlyphs), fAdvance(advance)
Ben Wagner8d45a382017-11-16 10:08:28 -0500499 {}
500
Ben Wagner7415a422019-03-25 15:38:22 -0400501 SkShaper::RunHandler::Range fUtf8Range;
Mike Reed6d595682018-12-05 17:28:14 -0500502 SkFont fFont;
Ben Wagner8d45a382017-11-16 10:08:28 -0500503 UBiDiLevel fLevel;
504 std::unique_ptr<ShapedGlyph[]> fGlyphs;
Ben Wagner7415a422019-03-25 15:38:22 -0400505 size_t fNumGlyphs;
506 SkVector fAdvance;
Ben Wagner8d45a382017-11-16 10:08:28 -0500507};
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400508struct ShapedLine {
509 SkTArray<ShapedRun> runs;
510 SkVector fAdvance = { 0, 0 };
511};
Ben Wagner8d45a382017-11-16 10:08:28 -0500512
Ben Wagner1383a382019-04-03 17:53:53 -0400513constexpr bool is_LTR(UBiDiLevel level) {
Ben Wagner8d45a382017-11-16 10:08:28 -0500514 return (level & 1) == 0;
515}
516
Ben Wagner1383a382019-04-03 17:53:53 -0400517void append(SkShaper::RunHandler* handler, const SkShaper::RunHandler::RunInfo& runInfo,
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400518 const ShapedRun& run, size_t startGlyphIndex, size_t endGlyphIndex) {
Ben Wagner7415a422019-03-25 15:38:22 -0400519 SkASSERT(startGlyphIndex <= endGlyphIndex);
520 const size_t glyphLen = endGlyphIndex - startGlyphIndex;
Florin Malita9867f612018-12-12 10:54:49 -0500521
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400522 const auto buffer = handler->runBuffer(runInfo);
Florin Malita9867f612018-12-12 10:54:49 -0500523 SkASSERT(buffer.glyphs);
524 SkASSERT(buffer.positions);
525
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400526 SkVector advance = {0,0};
Ben Wagner7415a422019-03-25 15:38:22 -0400527 for (size_t i = 0; i < glyphLen; i++) {
Ben Wagner8d45a382017-11-16 10:08:28 -0500528 // Glyphs are in logical order, but output ltr since PDF readers seem to expect that.
Ben Wagner7415a422019-03-25 15:38:22 -0400529 const ShapedGlyph& glyph = run.fGlyphs[is_LTR(run.fLevel) ? startGlyphIndex + i
530 : endGlyphIndex - 1 - i];
Florin Malita9867f612018-12-12 10:54:49 -0500531 buffer.glyphs[i] = glyph.fID;
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400532 if (buffer.offsets) {
533 buffer.positions[i] = advance + buffer.point;
Ben Wagnerbdf2c872019-10-24 17:06:37 -0400534 buffer.offsets[i] = glyph.fOffset;
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400535 } else {
Ben Wagnerbdf2c872019-10-24 17:06:37 -0400536 buffer.positions[i] = advance + buffer.point + glyph.fOffset;
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400537 }
Florin Malita9867f612018-12-12 10:54:49 -0500538 if (buffer.clusters) {
539 buffer.clusters[i] = glyph.fCluster;
540 }
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400541 advance += glyph.fAdvance;
Ben Wagner8d45a382017-11-16 10:08:28 -0500542 }
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400543 handler->commitRunBuffer(runInfo);
Ben Wagner8d45a382017-11-16 10:08:28 -0500544}
545
Ben Wagner1383a382019-04-03 17:53:53 -0400546void emit(const ShapedLine& line, SkShaper::RunHandler* handler) {
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400547 // Reorder the runs and glyphs per line and write them out.
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400548 handler->beginLine();
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400549
550 int numRuns = line.runs.size();
551 SkAutoSTMalloc<4, UBiDiLevel> runLevels(numRuns);
552 for (int i = 0; i < numRuns; ++i) {
553 runLevels[i] = line.runs[i].fLevel;
554 }
555 SkAutoSTMalloc<4, int32_t> logicalFromVisual(numRuns);
556 ubidi_reorderVisual(runLevels, numRuns, logicalFromVisual);
557
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400558 for (int i = 0; i < numRuns; ++i) {
559 int logicalIndex = logicalFromVisual[i];
560
561 const auto& run = line.runs[logicalIndex];
562 const SkShaper::RunHandler::RunInfo info = {
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400563 run.fFont,
564 run.fLevel,
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400565 run.fAdvance,
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400566 run.fNumGlyphs,
567 run.fUtf8Range
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400568 };
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400569 handler->runInfo(info);
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400570 }
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400571 handler->commitRunInfo();
572 for (int i = 0; i < numRuns; ++i) {
573 int logicalIndex = logicalFromVisual[i];
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400574
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400575 const auto& run = line.runs[logicalIndex];
576 const SkShaper::RunHandler::RunInfo info = {
577 run.fFont,
578 run.fLevel,
579 run.fAdvance,
580 run.fNumGlyphs,
581 run.fUtf8Range
582 };
583 append(handler, info, run, 0, run.fNumGlyphs);
584 }
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400585
Florin Malita500133b2019-02-07 10:56:55 -0500586 handler->commitLine();
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400587}
588
Ben Wagner8d45a382017-11-16 10:08:28 -0500589struct ShapedRunGlyphIterator {
590 ShapedRunGlyphIterator(const SkTArray<ShapedRun>& origRuns)
591 : fRuns(&origRuns), fRunIndex(0), fGlyphIndex(0)
592 { }
593
594 ShapedRunGlyphIterator(const ShapedRunGlyphIterator& that) = default;
595 ShapedRunGlyphIterator& operator=(const ShapedRunGlyphIterator& that) = default;
596 bool operator==(const ShapedRunGlyphIterator& that) const {
597 return fRuns == that.fRuns &&
598 fRunIndex == that.fRunIndex &&
599 fGlyphIndex == that.fGlyphIndex;
600 }
601 bool operator!=(const ShapedRunGlyphIterator& that) const {
602 return fRuns != that.fRuns ||
603 fRunIndex != that.fRunIndex ||
604 fGlyphIndex != that.fGlyphIndex;
605 }
606
607 ShapedGlyph* next() {
608 const SkTArray<ShapedRun>& runs = *fRuns;
609 SkASSERT(fRunIndex < runs.count());
610 SkASSERT(fGlyphIndex < runs[fRunIndex].fNumGlyphs);
611
612 ++fGlyphIndex;
613 if (fGlyphIndex == runs[fRunIndex].fNumGlyphs) {
614 fGlyphIndex = 0;
615 ++fRunIndex;
616 if (fRunIndex >= runs.count()) {
617 return nullptr;
618 }
619 }
620 return &runs[fRunIndex].fGlyphs[fGlyphIndex];
621 }
622
623 ShapedGlyph* current() {
624 const SkTArray<ShapedRun>& runs = *fRuns;
625 if (fRunIndex >= runs.count()) {
626 return nullptr;
627 }
628 return &runs[fRunIndex].fGlyphs[fGlyphIndex];
629 }
630
631 const SkTArray<ShapedRun>* fRuns;
632 int fRunIndex;
Ben Wagner7415a422019-03-25 15:38:22 -0400633 size_t fGlyphIndex;
Ben Wagner8d45a382017-11-16 10:08:28 -0500634};
635
Ben Wagner51874e32019-04-04 15:21:20 -0400636class ShaperHarfBuzz : public SkShaper {
Ben Wagnerb0591942019-02-15 14:46:18 -0500637public:
Florin Malita42684332019-07-26 14:54:40 -0400638 ShaperHarfBuzz(HBBuffer, ICUBrk line, ICUBrk grapheme, sk_sp<SkFontMgr>);
639
Ben Wagner51874e32019-04-04 15:21:20 -0400640protected:
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400641 ICUBrk fLineBreakIterator;
642 ICUBrk fGraphemeBreakIterator;
643
Ben Wagner51874e32019-04-04 15:21:20 -0400644 ShapedRun shape(const char* utf8, size_t utf8Bytes,
645 const char* utf8Start,
646 const char* utf8End,
647 const BiDiRunIterator&,
648 const LanguageRunIterator&,
649 const ScriptRunIterator&,
Ben Wagner24ee4e02019-10-11 10:36:10 -0400650 const FontRunIterator&,
651 const Feature*, size_t featuresSize) const;
Ben Wagner51874e32019-04-04 15:21:20 -0400652private:
Florin Malita42684332019-07-26 14:54:40 -0400653 const sk_sp<SkFontMgr> fFontMgr;
654 HBBuffer fBuffer;
Ben Wagner51874e32019-04-04 15:21:20 -0400655
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400656 void shape(const char* utf8, size_t utf8Bytes,
657 const SkFont&,
658 bool leftToRight,
659 SkScalar width,
660 RunHandler*) const override;
Ben Wagnerb0591942019-02-15 14:46:18 -0500661
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400662 void shape(const char* utf8Text, size_t textBytes,
663 FontRunIterator&,
664 BiDiRunIterator&,
665 ScriptRunIterator&,
666 LanguageRunIterator&,
667 SkScalar width,
668 RunHandler*) const override;
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400669
Ben Wagner24ee4e02019-10-11 10:36:10 -0400670 void shape(const char* utf8Text, size_t textBytes,
671 FontRunIterator&,
672 BiDiRunIterator&,
673 ScriptRunIterator&,
674 LanguageRunIterator&,
675 const Feature*, size_t featuresSize,
676 SkScalar width,
677 RunHandler*) const override;
678
Ben Wagner51874e32019-04-04 15:21:20 -0400679 virtual void wrap(char const * const utf8, size_t utf8Bytes,
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400680 const BiDiRunIterator&,
681 const LanguageRunIterator&,
682 const ScriptRunIterator&,
683 const FontRunIterator&,
684 RunIteratorQueue& runSegmenter,
Ben Wagner24ee4e02019-10-11 10:36:10 -0400685 const Feature*, size_t featuresSize,
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400686 SkScalar width,
Ben Wagner51874e32019-04-04 15:21:20 -0400687 RunHandler*) const = 0;
Ben Wagner8d45a382017-11-16 10:08:28 -0500688};
689
Ben Wagner51874e32019-04-04 15:21:20 -0400690class ShaperDrivenWrapper : public ShaperHarfBuzz {
691public:
692 using ShaperHarfBuzz::ShaperHarfBuzz;
693private:
694 void wrap(char const * const utf8, size_t utf8Bytes,
695 const BiDiRunIterator&,
696 const LanguageRunIterator&,
697 const ScriptRunIterator&,
698 const FontRunIterator&,
699 RunIteratorQueue& runSegmenter,
Ben Wagner24ee4e02019-10-11 10:36:10 -0400700 const Feature*, size_t featuresSize,
Ben Wagner51874e32019-04-04 15:21:20 -0400701 SkScalar width,
702 RunHandler*) const override;
703};
Ben Wagnerb0591942019-02-15 14:46:18 -0500704
Ben Wagner51874e32019-04-04 15:21:20 -0400705class ShapeThenWrap : public ShaperHarfBuzz {
706public:
707 using ShaperHarfBuzz::ShaperHarfBuzz;
708private:
709 void wrap(char const * const utf8, size_t utf8Bytes,
710 const BiDiRunIterator&,
711 const LanguageRunIterator&,
712 const ScriptRunIterator&,
713 const FontRunIterator&,
714 RunIteratorQueue& runSegmenter,
Ben Wagner24ee4e02019-10-11 10:36:10 -0400715 const Feature*, size_t featuresSize,
Ben Wagner51874e32019-04-04 15:21:20 -0400716 SkScalar width,
717 RunHandler*) const override;
718};
719
Ben Wagner6bb79bb2019-05-15 10:50:20 -0400720class ShapeDontWrapOrReorder : public ShaperHarfBuzz {
721public:
722 using ShaperHarfBuzz::ShaperHarfBuzz;
723private:
724 void wrap(char const * const utf8, size_t utf8Bytes,
725 const BiDiRunIterator&,
726 const LanguageRunIterator&,
727 const ScriptRunIterator&,
728 const FontRunIterator&,
729 RunIteratorQueue& runSegmenter,
Ben Wagner24ee4e02019-10-11 10:36:10 -0400730 const Feature*, size_t featuresSize,
Ben Wagner6bb79bb2019-05-15 10:50:20 -0400731 SkScalar width,
732 RunHandler*) const override;
733};
734
Florin Malita42684332019-07-26 14:54:40 -0400735static std::unique_ptr<SkShaper> MakeHarfBuzz(sk_sp<SkFontMgr> fontmgr, bool correct) {
Ben Wagner51874e32019-04-04 15:21:20 -0400736 #if defined(SK_USING_THIRD_PARTY_ICU)
Hal Canary61021922019-02-06 12:29:11 -0500737 if (!SkLoadICU()) {
Ben Wagner51874e32019-04-04 15:21:20 -0400738 SkDEBUGF("SkLoadICU() failed!\n");
739 return nullptr;
Hal Canary61021922019-02-06 12:29:11 -0500740 }
Ben Wagner51874e32019-04-04 15:21:20 -0400741 #endif
742 HBBuffer buffer(hb_buffer_create());
743 if (!buffer) {
744 SkDEBUGF("Could not create hb_buffer");
745 return nullptr;
746 }
Ben Wagner8d45a382017-11-16 10:08:28 -0500747
Ben Wagner8d45a382017-11-16 10:08:28 -0500748 UErrorCode status = U_ZERO_ERROR;
Ben Wagner51874e32019-04-04 15:21:20 -0400749 ICUBrk lineBreakIterator(ubrk_open(UBRK_LINE, "th", nullptr, 0, &status));
750 if (!lineBreakIterator || U_FAILURE(status)) {
751 SkDEBUGF("Could not create line break iterator: %s", u_errorName(status));
752 return nullptr;
Ben Wagner8d45a382017-11-16 10:08:28 -0500753 }
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400754
Ben Wagner51874e32019-04-04 15:21:20 -0400755 ICUBrk graphemeBreakIterator(ubrk_open(UBRK_CHARACTER, "th", nullptr, 0, &status));
756 if (!graphemeBreakIterator || U_FAILURE(status)) {
757 SkDEBUGF("Could not create grapheme break iterator: %s", u_errorName(status));
758 return nullptr;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400759 }
760
Ben Wagner51874e32019-04-04 15:21:20 -0400761 if (correct) {
Mike Kleinf46d5ca2019-12-11 10:45:01 -0500762 return std::make_unique<ShaperDrivenWrapper>(std::move(buffer),
Florin Malita42684332019-07-26 14:54:40 -0400763 std::move(lineBreakIterator),
764 std::move(graphemeBreakIterator),
765 std::move(fontmgr));
Ben Wagner51874e32019-04-04 15:21:20 -0400766 } else {
Mike Kleinf46d5ca2019-12-11 10:45:01 -0500767 return std::make_unique<ShapeThenWrap>(std::move(buffer),
Florin Malita42684332019-07-26 14:54:40 -0400768 std::move(lineBreakIterator),
769 std::move(graphemeBreakIterator),
770 std::move(fontmgr));
Ben Wagner51874e32019-04-04 15:21:20 -0400771 }
Ben Wagnera25fbef2017-08-30 13:56:19 -0400772}
773
Florin Malita42684332019-07-26 14:54:40 -0400774ShaperHarfBuzz::ShaperHarfBuzz(HBBuffer buffer, ICUBrk line, ICUBrk grapheme,
775 sk_sp<SkFontMgr> fontmgr)
Ben Wagner51874e32019-04-04 15:21:20 -0400776 : fLineBreakIterator(std::move(line))
777 , fGraphemeBreakIterator(std::move(grapheme))
Florin Malita42684332019-07-26 14:54:40 -0400778 , fFontMgr(std::move(fontmgr))
Ben Wagner51874e32019-04-04 15:21:20 -0400779 , fBuffer(std::move(buffer))
780{}
Ben Wagnera25fbef2017-08-30 13:56:19 -0400781
Ben Wagner51874e32019-04-04 15:21:20 -0400782void ShaperHarfBuzz::shape(const char* utf8, size_t utf8Bytes,
783 const SkFont& srcFont,
784 bool leftToRight,
785 SkScalar width,
786 RunHandler* handler) const
Ben Wagner8d45a382017-11-16 10:08:28 -0500787{
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400788 UBiDiLevel defaultLevel = leftToRight ? UBIDI_DEFAULT_LTR : UBIDI_DEFAULT_RTL;
789
Ben Wagner1383a382019-04-03 17:53:53 -0400790 std::unique_ptr<BiDiRunIterator> bidi(MakeIcuBiDiRunIterator(utf8, utf8Bytes, defaultLevel));
Ben Wagner8d45a382017-11-16 10:08:28 -0500791 if (!bidi) {
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400792 return;
Ben Wagnera25fbef2017-08-30 13:56:19 -0400793 }
Ben Wagnera25fbef2017-08-30 13:56:19 -0400794
Ben Wagner1383a382019-04-03 17:53:53 -0400795 std::unique_ptr<LanguageRunIterator> language(MakeStdLanguageRunIterator(utf8, utf8Bytes));
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400796 if (!language) {
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400797 return;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400798 }
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400799
Ben Wagner1383a382019-04-03 17:53:53 -0400800 std::unique_ptr<ScriptRunIterator> script(MakeHbIcuScriptRunIterator(utf8, utf8Bytes));
Ben Wagner8d45a382017-11-16 10:08:28 -0500801 if (!script) {
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400802 return;
Ben Wagnera25fbef2017-08-30 13:56:19 -0400803 }
Ben Wagnera25fbef2017-08-30 13:56:19 -0400804
Florin Malita42684332019-07-26 14:54:40 -0400805 std::unique_ptr<FontRunIterator> font(
806 MakeFontMgrRunIterator(utf8, utf8Bytes, srcFont,
807 fFontMgr ? fFontMgr : SkFontMgr::RefDefault()));
Ben Wagner8d45a382017-11-16 10:08:28 -0500808 if (!font) {
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400809 return;
Ben Wagnera25fbef2017-08-30 13:56:19 -0400810 }
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400811
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400812 this->shape(utf8, utf8Bytes, *font, *bidi, *script, *language, width, handler);
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400813}
814
Ben Wagner51874e32019-04-04 15:21:20 -0400815void ShaperHarfBuzz::shape(const char* utf8, size_t utf8Bytes,
816 FontRunIterator& font,
817 BiDiRunIterator& bidi,
818 ScriptRunIterator& script,
819 LanguageRunIterator& language,
820 SkScalar width,
821 RunHandler* handler) const
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400822{
Ben Wagner24ee4e02019-10-11 10:36:10 -0400823 this->shape(utf8, utf8Bytes, font, bidi, script, language, nullptr, 0, width, handler);
824}
825
826void ShaperHarfBuzz::shape(const char* utf8, size_t utf8Bytes,
827 FontRunIterator& font,
828 BiDiRunIterator& bidi,
829 ScriptRunIterator& script,
830 LanguageRunIterator& language,
831 const Feature* features, size_t featuresSize,
832 SkScalar width,
833 RunHandler* handler) const
834{
Ben Wagner1ca50522019-10-01 17:54:28 -0400835 SkASSERT(handler);
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400836 RunIteratorQueue runSegmenter;
Ben Wagner1ca50522019-10-01 17:54:28 -0400837 runSegmenter.insert(&font, 3); // The font iterator is always run last in case of tie.
838 runSegmenter.insert(&bidi, 2);
839 runSegmenter.insert(&script, 1);
840 runSegmenter.insert(&language, 0);
Ben Wagnera25fbef2017-08-30 13:56:19 -0400841
Ben Wagner24ee4e02019-10-11 10:36:10 -0400842 this->wrap(utf8, utf8Bytes, bidi, language, script, font, runSegmenter,
843 features, featuresSize, width, handler);
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400844}
845
Ben Wagner51874e32019-04-04 15:21:20 -0400846void ShaperDrivenWrapper::wrap(char const * const utf8, size_t utf8Bytes,
847 const BiDiRunIterator& bidi,
848 const LanguageRunIterator& language,
849 const ScriptRunIterator& script,
850 const FontRunIterator& font,
851 RunIteratorQueue& runSegmenter,
Ben Wagner24ee4e02019-10-11 10:36:10 -0400852 const Feature* features, size_t featuresSize,
Ben Wagner51874e32019-04-04 15:21:20 -0400853 SkScalar width,
854 RunHandler* handler) const
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400855{
856 ShapedLine line;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400857
858 const char* utf8Start = nullptr;
859 const char* utf8End = utf8;
860 while (runSegmenter.advanceRuns()) { // For each item
861 utf8Start = utf8End;
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400862 utf8End = utf8 + runSegmenter.endOfCurrentRun();
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400863
Ben Wagner7415a422019-03-25 15:38:22 -0400864 ShapedRun model(RunHandler::Range(), SkFont(), 0, nullptr, 0);
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400865 bool modelNeedsRegenerated = true;
Ben Wagner7415a422019-03-25 15:38:22 -0400866 int modelGlyphOffset = 0;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400867
868 struct TextProps {
869 int glyphLen = 0;
870 SkVector advance = {0, 0};
871 };
872 // map from character position to [safe to break, glyph position, advance]
873 std::unique_ptr<TextProps[]> modelText;
874 int modelTextOffset = 0;
Ben Wagner7415a422019-03-25 15:38:22 -0400875 SkVector modelAdvanceOffset = {0, 0};
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400876
877 while (utf8Start < utf8End) { // While there are still code points left in this item
878 size_t utf8runLength = utf8End - utf8Start;
879 if (modelNeedsRegenerated) {
880 model = shape(utf8, utf8Bytes,
881 utf8Start, utf8End,
Ben Wagner24ee4e02019-10-11 10:36:10 -0400882 bidi, language, script, font,
883 features, featuresSize);
Ben Wagner7415a422019-03-25 15:38:22 -0400884 modelGlyphOffset = 0;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400885
886 SkVector advance = {0, 0};
887 modelText.reset(new TextProps[utf8runLength + 1]());
Ben Wagnerb9cc1c62019-02-14 14:12:48 -0500888 size_t modelStartCluster = utf8Start - utf8;
Ben Wagner7415a422019-03-25 15:38:22 -0400889 for (size_t i = 0; i < model.fNumGlyphs; ++i) {
Ben Wagner84cc4612019-02-14 17:13:21 -0500890 SkASSERT(modelStartCluster <= model.fGlyphs[i].fCluster);
Ben Wagner2fe1e232019-02-14 17:37:02 -0500891 SkASSERT( model.fGlyphs[i].fCluster < (size_t)(utf8End - utf8));
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400892 if (!model.fGlyphs[i].fUnsafeToBreak) {
Ben Wagnerb9cc1c62019-02-14 14:12:48 -0500893 modelText[model.fGlyphs[i].fCluster - modelStartCluster].glyphLen = i;
894 modelText[model.fGlyphs[i].fCluster - modelStartCluster].advance = advance;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400895 }
896 advance += model.fGlyphs[i].fAdvance;
897 }
898 // Assume it is always safe to break after the end of an item
899 modelText[utf8runLength].glyphLen = model.fNumGlyphs;
900 modelText[utf8runLength].advance = model.fAdvance;
901 modelTextOffset = 0;
Ben Wagner7415a422019-03-25 15:38:22 -0400902 modelAdvanceOffset = {0, 0};
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400903 modelNeedsRegenerated = false;
904 }
905
906 // TODO: break iterator per item, but just reset position if needed?
907 // Maybe break iterator with model?
908 UBreakIterator& breakIterator = *fLineBreakIterator;
909 {
910 UErrorCode status = U_ZERO_ERROR;
Ben Wagner723a8772019-08-16 11:36:58 -0400911 UText sUtf8UText = UTEXT_INITIALIZER;
912 ICUUText utf8UText(utext_openUTF8(&sUtf8UText, utf8Start, utf8runLength, &status));
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400913 if (U_FAILURE(status)) {
914 SkDebugf("Could not create utf8UText: %s", u_errorName(status));
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400915 return;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400916 }
Ben Wagner723a8772019-08-16 11:36:58 -0400917 ubrk_setUText(&breakIterator, utf8UText.get(), &status);
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400918 if (U_FAILURE(status)) {
919 SkDebugf("Could not setText on break iterator: %s", u_errorName(status));
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400920 return;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400921 }
922 }
923
Ben Wagner7415a422019-03-25 15:38:22 -0400924 ShapedRun best(RunHandler::Range(), SkFont(), 0, nullptr, 0,
925 { SK_ScalarNegativeInfinity, SK_ScalarNegativeInfinity });
926 bool bestIsInvalid = true;
927 bool bestUsesModelForGlyphs = false;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400928 SkScalar widthLeft = width - line.fAdvance.fX;
929
930 for (int32_t breakIteratorCurrent = ubrk_next(&breakIterator);
931 breakIteratorCurrent != UBRK_DONE;
932 breakIteratorCurrent = ubrk_next(&breakIterator))
933 {
934 // TODO: if past a safe to break, future safe to break will be at least as long
935
936 // TODO: adjust breakIteratorCurrent by ignorable whitespace
Ben Wagner7415a422019-03-25 15:38:22 -0400937 bool candidateUsesModelForGlyphs = false;
938 ShapedRun candidate = [&](const TextProps& props){
939 if (props.glyphLen) {
940 candidateUsesModelForGlyphs = true;
941 return ShapedRun(RunHandler::Range(utf8Start - utf8, breakIteratorCurrent),
Ben Wagner1e08a7c2019-03-27 15:37:13 -0400942 font.currentFont(), bidi.currentLevel(),
Ben Wagner7415a422019-03-25 15:38:22 -0400943 std::unique_ptr<ShapedGlyph[]>(),
944 props.glyphLen - modelGlyphOffset,
945 props.advance - modelAdvanceOffset);
946 } else {
947 return shape(utf8, utf8Bytes,
948 utf8Start, utf8Start + breakIteratorCurrent,
Ben Wagner24ee4e02019-10-11 10:36:10 -0400949 bidi, language, script, font,
950 features, featuresSize);
Ben Wagner7415a422019-03-25 15:38:22 -0400951 }
952 }(modelText[breakIteratorCurrent + modelTextOffset]);
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400953 auto score = [widthLeft](const ShapedRun& run) -> SkScalar {
954 if (run.fAdvance.fX < widthLeft) {
Ben Wagner7415a422019-03-25 15:38:22 -0400955 return run.fUtf8Range.size();
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400956 } else {
957 return widthLeft - run.fAdvance.fX;
958 }
959 };
Ben Wagner7415a422019-03-25 15:38:22 -0400960 if (bestIsInvalid || score(best) < score(candidate)) {
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400961 best = std::move(candidate);
Ben Wagner7415a422019-03-25 15:38:22 -0400962 bestIsInvalid = false;
963 bestUsesModelForGlyphs = candidateUsesModelForGlyphs;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400964 }
965 }
966
967 // If nothing fit (best score is negative) and the line is not empty
968 if (width < line.fAdvance.fX + best.fAdvance.fX && !line.runs.empty()) {
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400969 emit(line, handler);
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400970 line.runs.reset();
971 line.fAdvance = {0, 0};
972 } else {
Ben Wagner7415a422019-03-25 15:38:22 -0400973 if (bestUsesModelForGlyphs) {
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400974 best.fGlyphs.reset(new ShapedGlyph[best.fNumGlyphs]);
Ben Wagner7415a422019-03-25 15:38:22 -0400975 memcpy(best.fGlyphs.get(), model.fGlyphs.get() + modelGlyphOffset,
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400976 best.fNumGlyphs * sizeof(ShapedGlyph));
Ben Wagner7415a422019-03-25 15:38:22 -0400977 modelGlyphOffset += best.fNumGlyphs;
978 modelTextOffset += best.fUtf8Range.size();
979 modelAdvanceOffset += best.fAdvance;
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400980 } else {
981 modelNeedsRegenerated = true;
982 }
Ben Wagner7415a422019-03-25 15:38:22 -0400983 utf8Start += best.fUtf8Range.size();
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400984 line.fAdvance += best.fAdvance;
985 line.runs.emplace_back(std::move(best));
986
987 // If item broken, emit line (prevent remainder from accidentally fitting)
988 if (utf8Start != utf8End) {
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400989 emit(line, handler);
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400990 line.runs.reset();
991 line.fAdvance = {0, 0};
992 }
993 }
994 }
995 }
Ben Wagner3bdb69c2019-04-01 19:01:09 -0400996 emit(line, handler);
Ben Wagner0ec8ec22018-09-04 18:17:13 -0400997}
998
Ben Wagner51874e32019-04-04 15:21:20 -0400999void ShapeThenWrap::wrap(char const * const utf8, size_t utf8Bytes,
1000 const BiDiRunIterator& bidi,
1001 const LanguageRunIterator& language,
1002 const ScriptRunIterator& script,
1003 const FontRunIterator& font,
1004 RunIteratorQueue& runSegmenter,
Ben Wagner24ee4e02019-10-11 10:36:10 -04001005 const Feature* features, size_t featuresSize,
Ben Wagner51874e32019-04-04 15:21:20 -04001006 SkScalar width,
1007 RunHandler* handler) const
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001008{
1009 SkTArray<ShapedRun> runs;
1010{
1011 UBreakIterator& lineBreakIterator = *fLineBreakIterator;
1012 UBreakIterator& graphemeBreakIterator = *fGraphemeBreakIterator;
Ben Wagner8d45a382017-11-16 10:08:28 -05001013 {
1014 UErrorCode status = U_ZERO_ERROR;
Ben Wagner723a8772019-08-16 11:36:58 -04001015 UText sUtf8UText = UTEXT_INITIALIZER;
1016 ICUUText utf8UText(utext_openUTF8(&sUtf8UText, utf8, utf8Bytes, &status));
Ben Wagner8d45a382017-11-16 10:08:28 -05001017 if (U_FAILURE(status)) {
1018 SkDebugf("Could not create utf8UText: %s", u_errorName(status));
Ben Wagner3bdb69c2019-04-01 19:01:09 -04001019 return;
Ben Wagner8d45a382017-11-16 10:08:28 -05001020 }
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001021
Ben Wagner723a8772019-08-16 11:36:58 -04001022 ubrk_setUText(&lineBreakIterator, utf8UText.get(), &status);
Ben Wagner8d45a382017-11-16 10:08:28 -05001023 if (U_FAILURE(status)) {
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001024 SkDebugf("Could not setText on line break iterator: %s", u_errorName(status));
Ben Wagner3bdb69c2019-04-01 19:01:09 -04001025 return;
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001026 }
Ben Wagner723a8772019-08-16 11:36:58 -04001027 ubrk_setUText(&graphemeBreakIterator, utf8UText.get(), &status);
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001028 if (U_FAILURE(status)) {
1029 SkDebugf("Could not setText on grapheme break iterator: %s", u_errorName(status));
Ben Wagner3bdb69c2019-04-01 19:01:09 -04001030 return;
Ben Wagner8d45a382017-11-16 10:08:28 -05001031 }
Ben Wagnera25fbef2017-08-30 13:56:19 -04001032 }
1033
Ben Wagner8d45a382017-11-16 10:08:28 -05001034 const char* utf8Start = nullptr;
1035 const char* utf8End = utf8;
1036 while (runSegmenter.advanceRuns()) {
1037 utf8Start = utf8End;
Ben Wagner1e08a7c2019-03-27 15:37:13 -04001038 utf8End = utf8 + runSegmenter.endOfCurrentRun();
Ben Wagner8d45a382017-11-16 10:08:28 -05001039
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001040 runs.emplace_back(shape(utf8, utf8Bytes,
1041 utf8Start, utf8End,
Ben Wagner24ee4e02019-10-11 10:36:10 -04001042 bidi, language, script, font,
1043 features, featuresSize));
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001044 ShapedRun& run = runs.back();
Ben Wagnera25fbef2017-08-30 13:56:19 -04001045
Ben Wagner8d45a382017-11-16 10:08:28 -05001046 uint32_t previousCluster = 0xFFFFFFFF;
Ben Wagner7415a422019-03-25 15:38:22 -04001047 for (size_t i = 0; i < run.fNumGlyphs; ++i) {
Ben Wagner8d45a382017-11-16 10:08:28 -05001048 ShapedGlyph& glyph = run.fGlyphs[i];
Ben Wagnerb9cc1c62019-02-14 14:12:48 -05001049 int32_t glyphCluster = glyph.fCluster;
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001050
1051 int32_t lineBreakIteratorCurrent = ubrk_current(&lineBreakIterator);
1052 while (lineBreakIteratorCurrent != UBRK_DONE &&
1053 lineBreakIteratorCurrent < glyphCluster)
Ben Wagner8d45a382017-11-16 10:08:28 -05001054 {
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001055 lineBreakIteratorCurrent = ubrk_next(&lineBreakIterator);
Ben Wagner2868b782017-08-31 14:12:27 -04001056 }
Ben Wagner8d45a382017-11-16 10:08:28 -05001057 glyph.fMayLineBreakBefore = glyph.fCluster != previousCluster &&
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001058 lineBreakIteratorCurrent == glyphCluster;
1059
1060 int32_t graphemeBreakIteratorCurrent = ubrk_current(&graphemeBreakIterator);
1061 while (graphemeBreakIteratorCurrent != UBRK_DONE &&
1062 graphemeBreakIteratorCurrent < glyphCluster)
1063 {
1064 graphemeBreakIteratorCurrent = ubrk_next(&graphemeBreakIterator);
1065 }
1066 glyph.fGraphemeBreakBefore = glyph.fCluster != previousCluster &&
1067 graphemeBreakIteratorCurrent == glyphCluster;
1068
Ben Wagner8d45a382017-11-16 10:08:28 -05001069 previousCluster = glyph.fCluster;
Ben Wagnera25fbef2017-08-30 13:56:19 -04001070 }
1071 }
Ben Wagner8d45a382017-11-16 10:08:28 -05001072}
1073
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001074// Iterate over the glyphs in logical order to find potential line lengths.
Ben Wagner8d45a382017-11-16 10:08:28 -05001075{
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001076 /** The position of the beginning of the line. */
1077 ShapedRunGlyphIterator beginning(runs);
1078
1079 /** The position of the candidate line break. */
1080 ShapedRunGlyphIterator candidateLineBreak(runs);
1081 SkScalar candidateLineBreakWidth = 0;
1082
1083 /** The position of the candidate grapheme break. */
1084 ShapedRunGlyphIterator candidateGraphemeBreak(runs);
1085 SkScalar candidateGraphemeBreakWidth = 0;
1086
1087 /** The position of the current location. */
1088 ShapedRunGlyphIterator current(runs);
1089 SkScalar currentWidth = 0;
1090 while (ShapedGlyph* glyph = current.current()) {
1091 // 'Break' at graphemes until a line boundary, then only at line boundaries.
1092 // Only break at graphemes if no line boundary is valid.
1093 if (current != beginning) {
1094 if (glyph->fGraphemeBreakBefore || glyph->fMayLineBreakBefore) {
1095 // TODO: preserve line breaks <= grapheme breaks
1096 // and prevent line breaks inside graphemes
1097 candidateGraphemeBreak = current;
1098 candidateGraphemeBreakWidth = currentWidth;
1099 if (glyph->fMayLineBreakBefore) {
1100 candidateLineBreak = current;
1101 candidateLineBreakWidth = currentWidth;
1102 }
1103 }
Ben Wagner8d45a382017-11-16 10:08:28 -05001104 }
1105
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001106 SkScalar glyphWidth = glyph->fAdvance.fX;
1107 // Break when overwidth, the glyph has a visual representation, and some space is used.
1108 if (width < currentWidth + glyphWidth && glyph->fHasVisual && candidateGraphemeBreakWidth > 0){
1109 if (candidateLineBreak != beginning) {
1110 beginning = candidateLineBreak;
1111 currentWidth -= candidateLineBreakWidth;
1112 candidateGraphemeBreakWidth -= candidateLineBreakWidth;
1113 candidateLineBreakWidth = 0;
1114 } else if (candidateGraphemeBreak != beginning) {
1115 beginning = candidateGraphemeBreak;
1116 candidateLineBreak = beginning;
1117 currentWidth -= candidateGraphemeBreakWidth;
1118 candidateGraphemeBreakWidth = 0;
1119 candidateLineBreakWidth = 0;
1120 } else {
1121 SK_ABORT("");
1122 }
1123
1124 if (width < currentWidth) {
1125 if (width < candidateGraphemeBreakWidth) {
1126 candidateGraphemeBreak = candidateLineBreak;
1127 candidateGraphemeBreakWidth = candidateLineBreakWidth;
1128 }
1129 current = candidateGraphemeBreak;
1130 currentWidth = candidateGraphemeBreakWidth;
1131 }
1132
1133 glyph = beginning.current();
1134 if (glyph) {
1135 glyph->fMustLineBreakBefore = true;
1136 }
1137
1138 } else {
1139 current.next();
1140 currentWidth += glyphWidth;
Ben Wagner8d45a382017-11-16 10:08:28 -05001141 }
Ben Wagner8d45a382017-11-16 10:08:28 -05001142 }
1143}
1144
1145// Reorder the runs and glyphs per line and write them out.
1146{
1147 ShapedRunGlyphIterator previousBreak(runs);
1148 ShapedRunGlyphIterator glyphIterator(runs);
Ben Wagner8d45a382017-11-16 10:08:28 -05001149 int previousRunIndex = -1;
1150 while (glyphIterator.current()) {
Ben Wagner00330082019-09-16 15:56:51 -04001151 const ShapedRunGlyphIterator current = glyphIterator;
Ben Wagner8d45a382017-11-16 10:08:28 -05001152 ShapedGlyph* nextGlyph = glyphIterator.next();
1153
Ben Wagner00330082019-09-16 15:56:51 -04001154 if (previousRunIndex != current.fRunIndex) {
Mike Reedb5784ac2018-11-12 09:35:15 -05001155 SkFontMetrics metrics;
Ben Wagner00330082019-09-16 15:56:51 -04001156 runs[current.fRunIndex].fFont.getMetrics(&metrics);
1157 previousRunIndex = current.fRunIndex;
Ben Wagner8d45a382017-11-16 10:08:28 -05001158 }
1159
1160 // Nothing can be written until the baseline is known.
1161 if (!(nextGlyph == nullptr || nextGlyph->fMustLineBreakBefore)) {
1162 continue;
1163 }
1164
Ben Wagner00330082019-09-16 15:56:51 -04001165 int numRuns = current.fRunIndex - previousBreak.fRunIndex + 1;
Ben Wagner8d45a382017-11-16 10:08:28 -05001166 SkAutoSTMalloc<4, UBiDiLevel> runLevels(numRuns);
1167 for (int i = 0; i < numRuns; ++i) {
1168 runLevels[i] = runs[previousBreak.fRunIndex + i].fLevel;
1169 }
1170 SkAutoSTMalloc<4, int32_t> logicalFromVisual(numRuns);
1171 ubidi_reorderVisual(runLevels, numRuns, logicalFromVisual);
1172
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001173 // step through the runs in reverse visual order and the glyphs in reverse logical order
1174 // until a visible glyph is found and force them to the end of the visual line.
1175
Ben Wagner3bdb69c2019-04-01 19:01:09 -04001176 handler->beginLine();
Ben Wagner8d45a382017-11-16 10:08:28 -05001177
Ben Wagner00330082019-09-16 15:56:51 -04001178 struct SubRun { const ShapedRun& run; size_t startGlyphIndex; size_t endGlyphIndex; };
1179 auto makeSubRun = [&runs, &previousBreak, &current, &logicalFromVisual](size_t visualIndex){
1180 int logicalIndex = previousBreak.fRunIndex + logicalFromVisual[visualIndex];
1181 const auto& run = runs[logicalIndex];
Ben Wagner7415a422019-03-25 15:38:22 -04001182 size_t startGlyphIndex = (logicalIndex == previousBreak.fRunIndex)
1183 ? previousBreak.fGlyphIndex
1184 : 0;
Ben Wagner00330082019-09-16 15:56:51 -04001185 size_t endGlyphIndex = (logicalIndex == current.fRunIndex)
1186 ? current.fGlyphIndex + 1
Ben Wagner3bdb69c2019-04-01 19:01:09 -04001187 : run.fNumGlyphs;
Ben Wagner00330082019-09-16 15:56:51 -04001188 return SubRun{ run, startGlyphIndex, endGlyphIndex };
1189 };
1190 auto makeRunInfo = [](const SubRun& sub) {
1191 uint32_t startUtf8 = sub.run.fGlyphs[sub.startGlyphIndex].fCluster;
1192 uint32_t endUtf8 = (sub.endGlyphIndex < sub.run.fNumGlyphs)
1193 ? sub.run.fGlyphs[sub.endGlyphIndex].fCluster
1194 : sub.run.fUtf8Range.end();
Florin Malita950243d2019-01-11 11:08:35 -05001195
Ben Wagner00330082019-09-16 15:56:51 -04001196 SkVector advance = SkVector::Make(0, 0);
1197 for (size_t i = sub.startGlyphIndex; i < sub.endGlyphIndex; ++i) {
1198 advance += sub.run.fGlyphs[i].fAdvance;
1199 }
1200
1201 return RunHandler::RunInfo{
1202 sub.run.fFont,
1203 sub.run.fLevel,
1204 advance,
1205 sub.endGlyphIndex - sub.startGlyphIndex,
1206 RunHandler::Range(startUtf8, endUtf8 - startUtf8)
1207 };
1208 };
1209
1210 for (int i = 0; i < numRuns; ++i) {
1211 handler->runInfo(makeRunInfo(makeSubRun(i)));
1212 }
1213 handler->commitRunInfo();
1214 for (int i = 0; i < numRuns; ++i) {
1215 SubRun sub = makeSubRun(i);
1216 append(handler, makeRunInfo(sub), sub.run, sub.startGlyphIndex, sub.endGlyphIndex);
Ben Wagner8d45a382017-11-16 10:08:28 -05001217 }
1218
Florin Malita500133b2019-02-07 10:56:55 -05001219 handler->commitLine();
1220
Ben Wagner8d45a382017-11-16 10:08:28 -05001221 previousRunIndex = -1;
1222 previousBreak = glyphIterator;
1223 }
1224}
Ben Wagnera25fbef2017-08-30 13:56:19 -04001225}
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001226
Ben Wagner6bb79bb2019-05-15 10:50:20 -04001227void ShapeDontWrapOrReorder::wrap(char const * const utf8, size_t utf8Bytes,
1228 const BiDiRunIterator& bidi,
1229 const LanguageRunIterator& language,
1230 const ScriptRunIterator& script,
1231 const FontRunIterator& font,
1232 RunIteratorQueue& runSegmenter,
Ben Wagner24ee4e02019-10-11 10:36:10 -04001233 const Feature* features, size_t featuresSize,
Ben Wagner6bb79bb2019-05-15 10:50:20 -04001234 SkScalar width,
1235 RunHandler* handler) const
1236{
1237 sk_ignore_unused_variable(width);
1238 SkTArray<ShapedRun> runs;
1239
1240 const char* utf8Start = nullptr;
1241 const char* utf8End = utf8;
1242 while (runSegmenter.advanceRuns()) {
1243 utf8Start = utf8End;
1244 utf8End = utf8 + runSegmenter.endOfCurrentRun();
1245
1246 runs.emplace_back(shape(utf8, utf8Bytes,
1247 utf8Start, utf8End,
Ben Wagner24ee4e02019-10-11 10:36:10 -04001248 bidi, language, script, font,
1249 features, featuresSize));
Ben Wagner6bb79bb2019-05-15 10:50:20 -04001250 }
1251
1252 handler->beginLine();
1253 for (const auto& run : runs) {
1254 const RunHandler::RunInfo info = {
1255 run.fFont,
1256 run.fLevel,
1257 run.fAdvance,
1258 run.fNumGlyphs,
1259 run.fUtf8Range
1260 };
1261 handler->runInfo(info);
1262 }
1263 handler->commitRunInfo();
1264 for (const auto& run : runs) {
1265 const RunHandler::RunInfo info = {
1266 run.fFont,
1267 run.fLevel,
1268 run.fAdvance,
1269 run.fNumGlyphs,
1270 run.fUtf8Range
1271 };
1272 append(handler, info, run, 0, run.fNumGlyphs);
1273 }
1274 handler->commitLine();
1275}
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001276
Ben Wagner51874e32019-04-04 15:21:20 -04001277ShapedRun ShaperHarfBuzz::shape(char const * const utf8,
Ben Wagner7415a422019-03-25 15:38:22 -04001278 size_t const utf8Bytes,
1279 char const * const utf8Start,
Ben Wagner24ee4e02019-10-11 10:36:10 -04001280 char const * const utf8End,
Ben Wagner1e08a7c2019-03-27 15:37:13 -04001281 const BiDiRunIterator& bidi,
1282 const LanguageRunIterator& language,
1283 const ScriptRunIterator& script,
Ben Wagner24ee4e02019-10-11 10:36:10 -04001284 const FontRunIterator& font,
1285 Feature const * const features, size_t const featuresSize) const
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001286{
Ben Wagner7415a422019-03-25 15:38:22 -04001287 size_t utf8runLength = utf8End - utf8Start;
1288 ShapedRun run(RunHandler::Range(utf8Start - utf8, utf8runLength),
Ben Wagner1e08a7c2019-03-27 15:37:13 -04001289 font.currentFont(), bidi.currentLevel(), nullptr, 0);
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001290
1291 hb_buffer_t* buffer = fBuffer.get();
1292 SkAutoTCallVProc<hb_buffer_t, hb_buffer_clear_contents> autoClearBuffer(buffer);
1293 hb_buffer_set_content_type(buffer, HB_BUFFER_CONTENT_TYPE_UNICODE);
1294 hb_buffer_set_cluster_level(buffer, HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS);
1295
Ben Wagner56a48bb2020-01-16 10:07:41 -05001296 // Documentation for HB_BUFFER_FLAG_BOT/EOT at 763e5466c0a03a7c27020e1e2598e488612529a7.
1297 // Currently BOT forces a dotted circle when first codepoint is a mark; EOT has no effect.
1298 // Avoid adding dotted circle, re-evaluate if BOT/EOT change. See https://skbug.com/9618.
1299 // hb_buffer_set_flags(buffer, HB_BUFFER_FLAG_BOT | HB_BUFFER_FLAG_EOT);
Ben Wagner2fc14742019-02-06 16:37:44 -05001300
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001301 // Add precontext.
1302 hb_buffer_add_utf8(buffer, utf8, utf8Start - utf8, utf8Start - utf8, 0);
1303
1304 // Populate the hb_buffer directly with utf8 cluster indexes.
1305 const char* utf8Current = utf8Start;
1306 while (utf8Current < utf8End) {
Ben Wagnerb9cc1c62019-02-14 14:12:48 -05001307 unsigned int cluster = utf8Current - utf8;
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001308 hb_codepoint_t u = utf8_next(&utf8Current, utf8End);
1309 hb_buffer_add(buffer, u, cluster);
1310 }
1311
1312 // Add postcontext.
1313 hb_buffer_add_utf8(buffer, utf8Current, utf8 + utf8Bytes - utf8Current, 0, 0);
1314
Ben Wagner1e08a7c2019-03-27 15:37:13 -04001315 hb_direction_t direction = is_LTR(bidi.currentLevel()) ? HB_DIRECTION_LTR:HB_DIRECTION_RTL;
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001316 hb_buffer_set_direction(buffer, direction);
Ben Wagner1e08a7c2019-03-27 15:37:13 -04001317 hb_buffer_set_script(buffer, hb_script_from_iso15924_tag((hb_tag_t)script.currentScript()));
1318 hb_buffer_set_language(buffer, hb_language_from_string(language.currentLanguage(), -1));
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001319 hb_buffer_guess_segment_properties(buffer);
Ben Wagner1e08a7c2019-03-27 15:37:13 -04001320
1321 // TODO: how to cache hbface (typeface) / hbfont (font)
1322 HBFont hbFont(create_hb_font(font.currentFont()));
1323 if (!hbFont) {
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001324 return run;
1325 }
Ben Wagner24ee4e02019-10-11 10:36:10 -04001326
1327 SkSTArray<32, hb_feature_t> hbFeatures;
1328 for (const auto& feature : SkMakeSpan(features, featuresSize)) {
1329 if (feature.end < SkTo<size_t>(utf8Start - utf8) ||
1330 SkTo<size_t>(utf8End - utf8) <= feature.start)
1331 {
1332 continue;
1333 }
1334 if (feature.start <= SkTo<size_t>(utf8Start - utf8) &&
1335 SkTo<size_t>(utf8End - utf8) <= feature.end)
1336 {
1337 hbFeatures.push_back({ (hb_tag_t)feature.tag, feature.value,
1338 HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END});
1339 } else {
1340 hbFeatures.push_back({ (hb_tag_t)feature.tag, feature.value,
1341 SkTo<unsigned>(feature.start), SkTo<unsigned>(feature.end)});
1342 }
1343 }
1344
1345 hb_shape(hbFont.get(), buffer, hbFeatures.data(), hbFeatures.size());
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001346 unsigned len = hb_buffer_get_length(buffer);
1347 if (len == 0) {
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001348 return run;
1349 }
1350
1351 if (direction == HB_DIRECTION_RTL) {
1352 // Put the clusters back in logical order.
1353 // Note that the advances remain ltr.
1354 hb_buffer_reverse(buffer);
1355 }
1356 hb_glyph_info_t* info = hb_buffer_get_glyph_infos(buffer, nullptr);
1357 hb_glyph_position_t* pos = hb_buffer_get_glyph_positions(buffer, nullptr);
1358
Ben Wagner7415a422019-03-25 15:38:22 -04001359 run = ShapedRun(RunHandler::Range(utf8Start - utf8, utf8runLength),
Ben Wagner1e08a7c2019-03-27 15:37:13 -04001360 font.currentFont(), bidi.currentLevel(),
Ben Wagner454e5fb2019-02-08 17:46:38 -05001361 std::unique_ptr<ShapedGlyph[]>(new ShapedGlyph[len]), len);
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001362 int scaleX, scaleY;
Ben Wagner1e08a7c2019-03-27 15:37:13 -04001363 hb_font_get_scale(hbFont.get(), &scaleX, &scaleY);
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001364 double textSizeY = run.fFont.getSize() / scaleY;
1365 double textSizeX = run.fFont.getSize() / scaleX * run.fFont.getScaleX();
1366 SkVector runAdvance = { 0, 0 };
1367 for (unsigned i = 0; i < len; i++) {
1368 ShapedGlyph& glyph = run.fGlyphs[i];
1369 glyph.fID = info[i].codepoint;
1370 glyph.fCluster = info[i].cluster;
1371 glyph.fOffset.fX = pos[i].x_offset * textSizeX;
Ben Wagnerbdf2c872019-10-24 17:06:37 -04001372 glyph.fOffset.fY = -(pos[i].y_offset * textSizeY); // HarfBuzz y-up, Skia y-down
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001373 glyph.fAdvance.fX = pos[i].x_advance * textSizeX;
Ben Wagnerbdf2c872019-10-24 17:06:37 -04001374 glyph.fAdvance.fY = -(pos[i].y_advance * textSizeY); // HarfBuzz y-up, Skia y-down
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001375
1376 SkRect bounds;
1377 SkScalar advance;
1378 SkPaint p;
1379 run.fFont.getWidthsBounds(&glyph.fID, 1, &advance, &bounds, &p);
1380 glyph.fHasVisual = !bounds.isEmpty(); //!font->currentTypeface()->glyphBoundsAreZero(glyph.fID);
Kevin Lubick867da4b2019-02-22 15:55:39 -05001381#if SK_HB_VERSION_CHECK(1, 5, 0)
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001382 glyph.fUnsafeToBreak = info[i].mask & HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
Kevin Lubick867da4b2019-02-22 15:55:39 -05001383#else
1384 glyph.fUnsafeToBreak = false;
1385#endif
Ben Wagner0ec8ec22018-09-04 18:17:13 -04001386 glyph.fMustLineBreakBefore = false;
1387
1388 runAdvance += glyph.fAdvance;
1389 }
1390 run.fAdvance = runAdvance;
1391
1392 return run;
1393}
Ben Wagner51874e32019-04-04 15:21:20 -04001394
1395} // namespace
1396
1397std::unique_ptr<SkShaper::BiDiRunIterator>
1398SkShaper::MakeIcuBiDiRunIterator(const char* utf8, size_t utf8Bytes, uint8_t bidiLevel) {
1399 // ubidi only accepts utf16 (though internally it basically works on utf32 chars).
1400 // We want an ubidi_setPara(UBiDi*, UText*, UBiDiLevel, UBiDiLevel*, UErrorCode*);
1401 if (!SkTFitsIn<int32_t>(utf8Bytes)) {
1402 SkDEBUGF("Bidi error: text too long");
1403 return nullptr;
1404 }
1405
1406 UErrorCode status = U_ZERO_ERROR;
1407
1408 // Getting the length like this seems to always set U_BUFFER_OVERFLOW_ERROR
1409 int32_t utf16Units;
1410 u_strFromUTF8(nullptr, 0, &utf16Units, utf8, utf8Bytes, &status);
1411 status = U_ZERO_ERROR;
1412 std::unique_ptr<UChar[]> utf16(new UChar[utf16Units]);
1413 u_strFromUTF8(utf16.get(), utf16Units, nullptr, utf8, utf8Bytes, &status);
1414 if (U_FAILURE(status)) {
1415 SkDEBUGF("Invalid utf8 input: %s", u_errorName(status));
1416 return nullptr;
1417 }
1418
1419 ICUBiDi bidi(ubidi_openSized(utf16Units, 0, &status));
1420 if (U_FAILURE(status)) {
1421 SkDEBUGF("Bidi error: %s", u_errorName(status));
1422 return nullptr;
1423 }
1424 SkASSERT(bidi);
1425
1426 // The required lifetime of utf16 isn't well documented.
1427 // It appears it isn't used after ubidi_setPara except through ubidi_getText.
1428 ubidi_setPara(bidi.get(), utf16.get(), utf16Units, bidiLevel, nullptr, &status);
1429 if (U_FAILURE(status)) {
1430 SkDEBUGF("Bidi error: %s", u_errorName(status));
1431 return nullptr;
1432 }
1433
Mike Kleinf46d5ca2019-12-11 10:45:01 -05001434 return std::make_unique<IcuBiDiRunIterator>(utf8, utf8 + utf8Bytes, std::move(bidi));
Ben Wagner51874e32019-04-04 15:21:20 -04001435}
1436
1437std::unique_ptr<SkShaper::ScriptRunIterator>
1438SkShaper::MakeHbIcuScriptRunIterator(const char* utf8, size_t utf8Bytes) {
Mike Kleinf46d5ca2019-12-11 10:45:01 -05001439 return std::make_unique<HbIcuScriptRunIterator>(utf8, utf8Bytes);
Ben Wagner51874e32019-04-04 15:21:20 -04001440}
1441
Florin Malita42684332019-07-26 14:54:40 -04001442std::unique_ptr<SkShaper> SkShaper::MakeShaperDrivenWrapper(sk_sp<SkFontMgr> fontmgr) {
1443 return MakeHarfBuzz(std::move(fontmgr), true);
Ben Wagner51874e32019-04-04 15:21:20 -04001444}
Florin Malita42684332019-07-26 14:54:40 -04001445std::unique_ptr<SkShaper> SkShaper::MakeShapeThenWrap(sk_sp<SkFontMgr> fontmgr) {
1446 return MakeHarfBuzz(std::move(fontmgr), false);
Ben Wagner51874e32019-04-04 15:21:20 -04001447}
Florin Malita42684332019-07-26 14:54:40 -04001448std::unique_ptr<SkShaper> SkShaper::MakeShapeDontWrapOrReorder(sk_sp<SkFontMgr> fontmgr) {
Ben Wagner6bb79bb2019-05-15 10:50:20 -04001449 #if defined(SK_USING_THIRD_PARTY_ICU)
1450 if (!SkLoadICU()) {
1451 SkDEBUGF("SkLoadICU() failed!\n");
1452 return nullptr;
1453 }
1454 #endif
1455 HBBuffer buffer(hb_buffer_create());
1456 if (!buffer) {
1457 SkDEBUGF("Could not create hb_buffer");
1458 return nullptr;
1459 }
1460
Mike Kleinf46d5ca2019-12-11 10:45:01 -05001461 return std::make_unique<ShapeDontWrapOrReorder>(std::move(buffer), nullptr, nullptr,
Florin Malita42684332019-07-26 14:54:40 -04001462 std::move(fontmgr));
Ben Wagner6bb79bb2019-05-15 10:50:20 -04001463}