1 /*
2 * Copyright 2018 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 "SkottiePriv.h"
9
10 #include "SkData.h"
11 #include "SkFontMgr.h"
12 #include "SkMakeUnique.h"
13 #include "SkottieAdapter.h"
14 #include "SkottieJson.h"
15 #include "SkottieValue.h"
16 #include "SkSGColor.h"
17 #include "SkSGDraw.h"
18 #include "SkSGGroup.h"
19 #include "SkSGText.h"
20 #include "SkTypes.h"
21
22 #include <string.h>
23
24 namespace skottie {
25 namespace internal {
26
27 namespace {
28
FontStyle(const AnimationBuilder * abuilder,const char * style)29 SkFontStyle FontStyle(const AnimationBuilder* abuilder, const char* style) {
30 static constexpr struct {
31 const char* fName;
32 const SkFontStyle::Weight fWeight;
33 } gWeightMap[] = {
34 { "ExtraLight", SkFontStyle::kExtraLight_Weight },
35 { "Light" , SkFontStyle::kLight_Weight },
36 { "Regular" , SkFontStyle::kNormal_Weight },
37 { "Medium" , SkFontStyle::kMedium_Weight },
38 { "SemiBold" , SkFontStyle::kSemiBold_Weight },
39 { "Bold" , SkFontStyle::kBold_Weight },
40 { "ExtraBold" , SkFontStyle::kExtraBold_Weight },
41 };
42
43 SkFontStyle::Weight weight = SkFontStyle::kNormal_Weight;
44 for (const auto& w : gWeightMap) {
45 const auto name_len = strlen(w.fName);
46 if (!strncmp(style, w.fName, name_len)) {
47 weight = w.fWeight;
48 style += name_len;
49 break;
50 }
51 }
52
53 static constexpr struct {
54 const char* fName;
55 const SkFontStyle::Slant fSlant;
56 } gSlantMap[] = {
57 { "Italic" , SkFontStyle::kItalic_Slant },
58 { "Oblique", SkFontStyle::kOblique_Slant },
59 };
60
61 SkFontStyle::Slant slant = SkFontStyle::kUpright_Slant;
62 if (*style != '\0') {
63 for (const auto& s : gSlantMap) {
64 if (!strcmp(style, s.fName)) {
65 slant = s.fSlant;
66 style += strlen(s.fName);
67 break;
68 }
69 }
70 }
71
72 if (*style != '\0') {
73 abuilder->log(Logger::Level::kWarning, nullptr, "Unknown font style: %s.", style);
74 }
75
76 return SkFontStyle(weight, SkFontStyle::kNormal_Width, slant);
77 }
78
79 } // namespace
80
matches(const char family[],const char style[]) const81 bool AnimationBuilder::FontInfo::matches(const char family[], const char style[]) const {
82 return 0 == strcmp(fFamily.c_str(), family)
83 && 0 == strcmp(fStyle.c_str(), style);
84 }
85
parseFonts(const skjson::ObjectValue * jfonts,const skjson::ArrayValue * jchars)86 void AnimationBuilder::parseFonts(const skjson::ObjectValue* jfonts,
87 const skjson::ArrayValue* jchars) {
88 // Optional array of font entries, referenced (by name) from text layer document nodes. E.g.
89 // "fonts": {
90 // "list": [
91 // {
92 // "ascent": 75,
93 // "fClass": "",
94 // "fFamily": "Roboto",
95 // "fName": "Roboto-Regular",
96 // "fPath": "https://fonts.googleapis.com/css?family=Roboto",
97 // "fPath": "",
98 // "fStyle": "Regular",
99 // "fWeight": "",
100 // "origin": 1
101 // }
102 // ]
103 // },
104 if (jfonts) {
105 if (const skjson::ArrayValue* jlist = (*jfonts)["list"]) {
106 for (const skjson::ObjectValue* jfont : *jlist) {
107 if (!jfont) {
108 continue;
109 }
110
111 const skjson::StringValue* jname = (*jfont)["fName"];
112 const skjson::StringValue* jfamily = (*jfont)["fFamily"];
113 const skjson::StringValue* jstyle = (*jfont)["fStyle"];
114 const skjson::StringValue* jpath = (*jfont)["fPath"];
115
116 if (!jname || !jname->size() ||
117 !jfamily || !jfamily->size() ||
118 !jstyle || !jstyle->size()) {
119 this->log(Logger::Level::kError, jfont, "Invalid font.");
120 continue;
121 }
122
123 const auto& fmgr = fLazyFontMgr.get();
124
125 // Typeface fallback order:
126 // 1) externally-loaded font (provided by the embedder)
127 // 2) system font (family/style)
128 // 3) system default
129
130 sk_sp<SkTypeface> tf =
131 fmgr->makeFromData(fResourceProvider->loadFont(jname->begin(),
132 jpath ? jpath->begin()
133 : nullptr));
134
135 if (!tf) {
136 tf.reset(fmgr->matchFamilyStyle(jfamily->begin(),
137 FontStyle(this, jstyle->begin())));
138 }
139
140 if (!tf) {
141 this->log(Logger::Level::kError, nullptr,
142 "Could not create typeface for %s|%s.",
143 jfamily->begin(), jstyle->begin());
144 // Last resort.
145 tf = fmgr->legacyMakeTypeface(nullptr, FontStyle(this, jstyle->begin()));
146 if (!tf) {
147 continue;
148 }
149 }
150
151 fFonts.set(SkString(jname->begin(), jname->size()),
152 {
153 SkString(jfamily->begin(), jfamily->size()),
154 SkString(jstyle->begin(), jstyle->size()),
155 ParseDefault((*jfont)["ascent"] , 0.0f),
156 std::move(tf)
157 });
158 }
159 }
160 }
161
162 // Optional array of glyphs, to be associated with one of the declared fonts. E.g.
163 // "chars": [
164 // {
165 // "ch": "t",
166 // "data": {
167 // "shapes": [...]
168 // },
169 // "fFamily": "Roboto",
170 // "size": 50,
171 // "style": "Regular",
172 // "w": 32.67
173 // }
174 // ]
175 if (jchars) {
176 FontInfo* current_font = nullptr;
177
178 for (const skjson::ObjectValue* jchar : *jchars) {
179 if (!jchar) {
180 continue;
181 }
182
183 const skjson::StringValue* jch = (*jchar)["ch"];
184 if (!jch) {
185 continue;
186 }
187
188 const skjson::StringValue* jfamily = (*jchar)["fFamily"];
189 const skjson::StringValue* jstyle = (*jchar)["style"]; // "style", not "fStyle"...
190
191 const auto* ch_ptr = jch->begin();
192 const auto ch_len = jch->size();
193
194 if (!jfamily || !jstyle || (SkUTF::CountUTF8(ch_ptr, ch_len) != 1)) {
195 this->log(Logger::Level::kError, jchar, "Invalid glyph.");
196 continue;
197 }
198
199 const auto uni = SkUTF::NextUTF8(&ch_ptr, ch_ptr + ch_len);
200 SkASSERT(uni != -1);
201
202 const auto* family = jfamily->begin();
203 const auto* style = jstyle->begin();
204
205 // Locate (and cache) the font info. Unlike text nodes, glyphs reference the font by
206 // (family, style) -- not by name :( For now this performs a linear search over *all*
207 // fonts: generally there are few of them, and glyph definitions are font-clustered.
208 // If problematic, we can refactor as a two-level hashmap.
209 if (!current_font || !current_font->matches(family, style)) {
210 current_font = nullptr;
211 fFonts.foreach([&](const SkString& name, FontInfo* finfo) {
212 if (finfo->matches(family, style)) {
213 current_font = finfo;
214 // TODO: would be nice to break early here...
215 }
216 });
217 if (!current_font) {
218 this->log(Logger::Level::kError, nullptr,
219 "Font not found for codepoint (%d, %s, %s).", uni, family, style);
220 continue;
221 }
222 }
223
224 // TODO: parse glyphs
225 }
226 }
227 }
228
findFont(const SkString & font_name) const229 sk_sp<SkTypeface> AnimationBuilder::findFont(const SkString& font_name) const {
230 if (const auto* font = fFonts.find(font_name)) {
231 return font->fTypeface;
232 }
233
234 this->log(Logger::Level::kError, nullptr, "Unknown font: \"%s\".", font_name.c_str());
235 return nullptr;
236 }
237
attachTextLayer(const skjson::ObjectValue & layer,const LayerInfo &,AnimatorScope * ascope) const238 sk_sp<sksg::RenderNode> AnimationBuilder::attachTextLayer(const skjson::ObjectValue& layer,
239 const LayerInfo&,
240 AnimatorScope* ascope) const {
241 // General text node format:
242 // "t": {
243 // "a": [], // animators (TODO)
244 // "d": {
245 // "k": [
246 // {
247 // "s": {
248 // "f": "Roboto-Regular",
249 // "fc": [
250 // 0.42,
251 // 0.15,
252 // 0.15
253 // ],
254 // "j": 1,
255 // "lh": 60,
256 // "ls": 0,
257 // "s": 50,
258 // "t": "text align right",
259 // "tr": 0
260 // },
261 // "t": 0
262 // }
263 // ]
264 // },
265 // "m": {}, // "more options" (TODO)
266 // "p": {} // "path options" (TODO)
267 // },
268 const skjson::ObjectValue* jt = layer["t"];
269 if (!jt) {
270 this->log(Logger::Level::kError, &layer, "Missing text layer \"t\" property.");
271 return nullptr;
272 }
273
274 const skjson::ArrayValue* animated_props = (*jt)["a"];
275 if (animated_props && animated_props->size() > 0) {
276 this->log(Logger::Level::kWarning, nullptr, "Unsupported animated text properties.");
277 }
278
279 const skjson::ObjectValue* jd = (*jt)["d"];
280 if (!jd) {
281 return nullptr;
282 }
283
284 auto text_root = sksg::Group::Make();
285 auto adapter = sk_make_sp<TextAdapter>(text_root);
286
287 this->bindProperty<TextValue>(*jd, ascope, [adapter] (const TextValue& txt) {
288 adapter->setText(txt);
289 });
290
291 return std::move(text_root);
292 }
293
294 } // namespace internal
295 } // namespace skottie
296