1 /*
2 * Copyright 2015 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 "SkCanvas.h"
9 #include "SkGlyph.h"
10 #include "SkMakeUnique.h"
11 #include "SkPath.h"
12 #include "SkRandomScalerContext.h"
13 #include "SkRasterizer.h"
14
15 class SkDescriptor;
16
17 class SkRandomScalerContext : public SkScalerContext {
18 public:
19 SkRandomScalerContext(sk_sp<SkRandomTypeface>, const SkScalerContextEffects&,
20 const SkDescriptor*, bool fFakeIt);
21
22 protected:
23 unsigned generateGlyphCount() override;
24 uint16_t generateCharToGlyph(SkUnichar) override;
25 void generateAdvance(SkGlyph*) override;
26 void generateMetrics(SkGlyph*) override;
27 void generateImage(const SkGlyph&) override;
28 void generatePath(SkGlyphID, SkPath*) override;
29 void generateFontMetrics(SkPaint::FontMetrics*) override;
30
31 private:
getRandomTypeface() const32 SkRandomTypeface* getRandomTypeface() const {
33 return static_cast<SkRandomTypeface*>(this->getTypeface());
34 }
35 std::unique_ptr<SkScalerContext> fProxy;
36 bool fFakeIt;
37 };
38
SkRandomScalerContext(sk_sp<SkRandomTypeface> face,const SkScalerContextEffects & effects,const SkDescriptor * desc,bool fakeIt)39 SkRandomScalerContext::SkRandomScalerContext(sk_sp<SkRandomTypeface> face,
40 const SkScalerContextEffects& effects,
41 const SkDescriptor* desc,
42 bool fakeIt)
43 : SkScalerContext(std::move(face), effects, desc)
44 , fFakeIt(fakeIt) {
45 fProxy = this->getRandomTypeface()->proxy()->createScalerContext(effects, desc);
46 }
47
generateGlyphCount()48 unsigned SkRandomScalerContext::generateGlyphCount() {
49 return fProxy->getGlyphCount();
50 }
51
generateCharToGlyph(SkUnichar uni)52 uint16_t SkRandomScalerContext::generateCharToGlyph(SkUnichar uni) {
53 return fProxy->charToGlyphID(uni);
54 }
55
generateAdvance(SkGlyph * glyph)56 void SkRandomScalerContext::generateAdvance(SkGlyph* glyph) {
57 fProxy->getAdvance(glyph);
58 }
59
generateMetrics(SkGlyph * glyph)60 void SkRandomScalerContext::generateMetrics(SkGlyph* glyph) {
61 // Here we will change the mask format of the glyph
62 // NOTE this is being overridden by the base class
63 SkMask::Format format = SkMask::kARGB32_Format; // init to handle defective compilers
64 switch (glyph->getGlyphID() % 4) {
65 case 0:
66 format = SkMask::kLCD16_Format;
67 break;
68 case 1:
69 format = SkMask::kA8_Format;
70 break;
71 case 2:
72 format = SkMask::kARGB32_Format;
73 break;
74 case 3:
75 format = SkMask::kBW_Format;
76 break;
77 }
78
79 fProxy->getMetrics(glyph);
80
81 glyph->fMaskFormat = format;
82 if (fFakeIt) {
83 return;
84 }
85 if (SkMask::kARGB32_Format == format) {
86 SkPath path;
87 fProxy->getPath(glyph->getPackedID(), &path);
88
89 SkRect storage;
90 const SkPaint& paint = this->getRandomTypeface()->paint();
91 const SkRect& newBounds = paint.doComputeFastBounds(path.getBounds(),
92 &storage,
93 SkPaint::kFill_Style);
94 SkIRect ibounds;
95 newBounds.roundOut(&ibounds);
96 glyph->fLeft = ibounds.fLeft;
97 glyph->fTop = ibounds.fTop;
98 glyph->fWidth = ibounds.width();
99 glyph->fHeight = ibounds.height();
100 } else {
101 SkPath devPath, fillPath;
102 SkMatrix fillToDevMatrix;
103
104 this->internalGetPath(glyph->getPackedID(), &fillPath, &devPath, &fillToDevMatrix);
105
106 // just use devPath
107 const SkIRect ir = devPath.getBounds().roundOut();
108
109 if (ir.isEmpty() || !ir.is16Bit()) {
110 glyph->fLeft = 0;
111 glyph->fTop = 0;
112 glyph->fWidth = 0;
113 glyph->fHeight = 0;
114 return;
115 }
116 glyph->fLeft = ir.fLeft;
117 glyph->fTop = ir.fTop;
118 glyph->fWidth = SkToU16(ir.width());
119 glyph->fHeight = SkToU16(ir.height());
120
121 if (glyph->fWidth > 0) {
122 switch (glyph->fMaskFormat) {
123 case SkMask::kLCD16_Format:
124 glyph->fWidth += 2;
125 glyph->fLeft -= 1;
126 break;
127 default:
128 break;
129 }
130 }
131 }
132 }
133
generateImage(const SkGlyph & glyph)134 void SkRandomScalerContext::generateImage(const SkGlyph& glyph) {
135 SkMask::Format format = (SkMask::Format)glyph.fMaskFormat;
136 switch (glyph.getGlyphID() % 4) {
137 case 0:
138 format = SkMask::kLCD16_Format;
139 break;
140 case 1:
141 format = SkMask::kA8_Format;
142 break;
143 case 2:
144 format = SkMask::kARGB32_Format;
145 break;
146 case 3:
147 format = SkMask::kBW_Format;
148 break;
149 }
150 const_cast<SkGlyph&>(glyph).fMaskFormat = format;
151
152 // if the format is ARGB, we just draw the glyph from path ourselves. Otherwise, we force
153 // our proxy context to generate the image from paths.
154 if (!fFakeIt) {
155 if (SkMask::kARGB32_Format == glyph.fMaskFormat) {
156 SkPath path;
157 fProxy->getPath(glyph.getPackedID(), &path);
158
159 SkBitmap bm;
160 bm.installPixels(SkImageInfo::MakeN32Premul(glyph.fWidth, glyph.fHeight),
161 glyph.fImage, glyph.rowBytes());
162 bm.eraseColor(0);
163
164 SkCanvas canvas(bm);
165 canvas.translate(-SkIntToScalar(glyph.fLeft),
166 -SkIntToScalar(glyph.fTop));
167 canvas.drawPath(path, this->getRandomTypeface()->paint());
168 } else {
169 fProxy->forceGenerateImageFromPath();
170 fProxy->getImage(glyph);
171 fProxy->forceOffGenerateImageFromPath();
172 }
173 } else {
174 sk_bzero(glyph.fImage, glyph.computeImageSize());
175 }
176 }
177
generatePath(SkGlyphID glyph,SkPath * path)178 void SkRandomScalerContext::generatePath(SkGlyphID glyph, SkPath* path) {
179 fProxy->generatePath(glyph, path);
180 }
181
generateFontMetrics(SkPaint::FontMetrics * metrics)182 void SkRandomScalerContext::generateFontMetrics(SkPaint::FontMetrics* metrics) {
183 fProxy->getFontMetrics(metrics);
184 }
185
186 ///////////////////////////////////////////////////////////////////////////////
187
188 #include "SkTypefaceCache.h"
189
SkRandomTypeface(sk_sp<SkTypeface> proxy,const SkPaint & paint,bool fakeIt)190 SkRandomTypeface::SkRandomTypeface(sk_sp<SkTypeface> proxy, const SkPaint& paint, bool fakeIt)
191 : SkTypeface(proxy->fontStyle(), false)
192 , fProxy(std::move(proxy))
193 , fPaint(paint)
194 , fFakeIt(fakeIt) {}
195
onCreateScalerContext(const SkScalerContextEffects & effects,const SkDescriptor * desc) const196 SkScalerContext* SkRandomTypeface::onCreateScalerContext(const SkScalerContextEffects& effects,
197 const SkDescriptor* desc) const {
198 return new SkRandomScalerContext(sk_ref_sp(const_cast<SkRandomTypeface*>(this)),
199 effects, desc, fFakeIt);
200 }
201
onFilterRec(SkScalerContextRec * rec) const202 void SkRandomTypeface::onFilterRec(SkScalerContextRec* rec) const {
203 fProxy->filterRec(rec);
204 rec->setHinting(SkPaint::kNo_Hinting);
205 rec->fMaskFormat = SkMask::kARGB32_Format;
206 }
207
onGetAdvancedTypefaceMetrics(PerGlyphInfo info,const uint32_t * glyphIDs,uint32_t glyphIDsCount) const208 SkAdvancedTypefaceMetrics* SkRandomTypeface::onGetAdvancedTypefaceMetrics(
209 PerGlyphInfo info,
210 const uint32_t* glyphIDs,
211 uint32_t glyphIDsCount) const {
212 return fProxy->getAdvancedTypefaceMetrics(info, glyphIDs, glyphIDsCount);
213 }
214
onOpenStream(int * ttcIndex) const215 SkStreamAsset* SkRandomTypeface::onOpenStream(int* ttcIndex) const {
216 return fProxy->openStream(ttcIndex);
217 }
218
onGetFontDescriptor(SkFontDescriptor * desc,bool * isLocal) const219 void SkRandomTypeface::onGetFontDescriptor(SkFontDescriptor* desc,
220 bool* isLocal) const {
221 fProxy->getFontDescriptor(desc, isLocal);
222 }
223
onCharsToGlyphs(const void * chars,Encoding encoding,uint16_t glyphs[],int glyphCount) const224 int SkRandomTypeface::onCharsToGlyphs(const void* chars, Encoding encoding,
225 uint16_t glyphs[], int glyphCount) const {
226 return fProxy->charsToGlyphs(chars, encoding, glyphs, glyphCount);
227 }
228
onCountGlyphs() const229 int SkRandomTypeface::onCountGlyphs() const {
230 return fProxy->countGlyphs();
231 }
232
onGetUPEM() const233 int SkRandomTypeface::onGetUPEM() const {
234 return fProxy->getUnitsPerEm();
235 }
236
onGetFamilyName(SkString * familyName) const237 void SkRandomTypeface::onGetFamilyName(SkString* familyName) const {
238 fProxy->getFamilyName(familyName);
239 }
240
onCreateFamilyNameIterator() const241 SkTypeface::LocalizedStrings* SkRandomTypeface::onCreateFamilyNameIterator() const {
242 return fProxy->createFamilyNameIterator();
243 }
244
onGetVariationDesignPosition(SkFontArguments::VariationPosition::Coordinate coordinates[],int coordinateCount) const245 int SkRandomTypeface::onGetVariationDesignPosition(
246 SkFontArguments::VariationPosition::Coordinate coordinates[], int coordinateCount) const
247 {
248 return fProxy->onGetVariationDesignPosition(coordinates, coordinateCount);
249 }
250
onGetTableTags(SkFontTableTag tags[]) const251 int SkRandomTypeface::onGetTableTags(SkFontTableTag tags[]) const {
252 return fProxy->getTableTags(tags);
253 }
254
onGetTableData(SkFontTableTag tag,size_t offset,size_t length,void * data) const255 size_t SkRandomTypeface::onGetTableData(SkFontTableTag tag, size_t offset,
256 size_t length, void* data) const {
257 return fProxy->getTableData(tag, offset, length, data);
258 }
259
260