• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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