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 "SkRandomScalerContext.h"
9 #include "SkGlyph.h"
10 #include "SkPath.h"
11 #include "SkCanvas.h"
12 #include "SkRasterizer.h"
13
14 class SkRandomScalerContext : public SkScalerContext {
15 public:
16 SkRandomScalerContext(SkRandomTypeface*, const SkDescriptor*, bool fFakeIt);
17 virtual ~SkRandomScalerContext();
18
19 protected:
20 unsigned generateGlyphCount() override;
21 uint16_t generateCharToGlyph(SkUnichar) override;
22 void generateAdvance(SkGlyph*) override;
23 void generateMetrics(SkGlyph*) override;
24 void generateImage(const SkGlyph&) override;
25 void generatePath(const SkGlyph&, SkPath*) override;
26 void generateFontMetrics(SkPaint::FontMetrics*) override;
27
28 private:
29 SkRandomTypeface* fFace;
30 SkScalerContext* fProxy;
31 bool fFakeIt;
32 };
33
34 #define STD_SIZE 1
35
36 #include "SkDescriptor.h"
37
SkRandomScalerContext(SkRandomTypeface * face,const SkDescriptor * desc,bool fakeIt)38 SkRandomScalerContext::SkRandomScalerContext(SkRandomTypeface* face, const SkDescriptor* desc,
39 bool fakeIt)
40 : SkScalerContext(face, desc)
41 , fFace(face)
42 , fFakeIt(fakeIt) {
43 fProxy = face->proxy()->createScalerContext(desc);
44 }
45
~SkRandomScalerContext()46 SkRandomScalerContext::~SkRandomScalerContext() { delete fProxy; }
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;
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, &path);
88
89 SkRect storage;
90 const SkPaint& paint = fFace->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, &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, &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, fFace->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(const SkGlyph & glyph,SkPath * path)178 void SkRandomScalerContext::generatePath(const SkGlyph& glyph, SkPath* path) {
179 fProxy->getPath(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(SkTypeface * proxy,const SkPaint & paint,bool fakeIt)190 SkRandomTypeface::SkRandomTypeface(SkTypeface* proxy, const SkPaint& paint, bool fakeIt)
191 : SkTypeface(proxy->fontStyle(), SkTypefaceCache::NewFontID(), false)
192 , fProxy(SkRef(proxy))
193 , fPaint(paint)
194 , fFakeIt(fakeIt) {}
195
~SkRandomTypeface()196 SkRandomTypeface::~SkRandomTypeface() {
197 fProxy->unref();
198 }
199
onCreateScalerContext(const SkDescriptor * desc) const200 SkScalerContext* SkRandomTypeface::onCreateScalerContext(
201 const SkDescriptor* desc) const {
202 return new SkRandomScalerContext(const_cast<SkRandomTypeface*>(this), desc, fFakeIt);
203 }
204
onFilterRec(SkScalerContextRec * rec) const205 void SkRandomTypeface::onFilterRec(SkScalerContextRec* rec) const {
206 fProxy->filterRec(rec);
207 rec->setHinting(SkPaint::kNo_Hinting);
208 rec->fMaskFormat = SkMask::kARGB32_Format;
209 }
210
onGetAdvancedTypefaceMetrics(PerGlyphInfo info,const uint32_t * glyphIDs,uint32_t glyphIDsCount) const211 SkAdvancedTypefaceMetrics* SkRandomTypeface::onGetAdvancedTypefaceMetrics(
212 PerGlyphInfo info,
213 const uint32_t* glyphIDs,
214 uint32_t glyphIDsCount) const {
215 return fProxy->getAdvancedTypefaceMetrics(info, glyphIDs, glyphIDsCount);
216 }
217
onOpenStream(int * ttcIndex) const218 SkStreamAsset* SkRandomTypeface::onOpenStream(int* ttcIndex) const {
219 return fProxy->openStream(ttcIndex);
220 }
221
onGetFontDescriptor(SkFontDescriptor * desc,bool * isLocal) const222 void SkRandomTypeface::onGetFontDescriptor(SkFontDescriptor* desc,
223 bool* isLocal) const {
224 fProxy->getFontDescriptor(desc, isLocal);
225 }
226
onCharsToGlyphs(const void * chars,Encoding encoding,uint16_t glyphs[],int glyphCount) const227 int SkRandomTypeface::onCharsToGlyphs(const void* chars, Encoding encoding,
228 uint16_t glyphs[], int glyphCount) const {
229 return fProxy->charsToGlyphs(chars, encoding, glyphs, glyphCount);
230 }
231
onCountGlyphs() const232 int SkRandomTypeface::onCountGlyphs() const {
233 return fProxy->countGlyphs();
234 }
235
onGetUPEM() const236 int SkRandomTypeface::onGetUPEM() const {
237 return fProxy->getUnitsPerEm();
238 }
239
onGetFamilyName(SkString * familyName) const240 void SkRandomTypeface::onGetFamilyName(SkString* familyName) const {
241 fProxy->getFamilyName(familyName);
242 }
243
onCreateFamilyNameIterator() const244 SkTypeface::LocalizedStrings* SkRandomTypeface::onCreateFamilyNameIterator() const {
245 return fProxy->createFamilyNameIterator();
246 }
247
onGetTableTags(SkFontTableTag tags[]) const248 int SkRandomTypeface::onGetTableTags(SkFontTableTag tags[]) const {
249 return fProxy->getTableTags(tags);
250 }
251
onGetTableData(SkFontTableTag tag,size_t offset,size_t length,void * data) const252 size_t SkRandomTypeface::onGetTableData(SkFontTableTag tag, size_t offset,
253 size_t length, void* data) const {
254 return fProxy->getTableData(tag, offset, length, data);
255 }
256
257