SkRandomScalerContext.cpp revision fc497343cbcbd526f77da913ae2feca0e1b1b866 
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
15class SkDescriptor;
16
17class SkRandomScalerContext : public SkScalerContext {
18public:
19    SkRandomScalerContext(sk_sp<SkRandomTypeface>, const SkScalerContextEffects&,
20                          const SkDescriptor*, bool fFakeIt);
21
22protected:
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
31private:
32    SkRandomTypeface* getRandomTypeface() const {
33        return static_cast<SkRandomTypeface*>(this->getTypeface());
34    }
35    std::unique_ptr<SkScalerContext> fProxy;
36    bool fFakeIt;
37};
38
39SkRandomScalerContext::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
48unsigned SkRandomScalerContext::generateGlyphCount() {
49    return fProxy->getGlyphCount();
50}
51
52uint16_t SkRandomScalerContext::generateCharToGlyph(SkUnichar uni) {
53    return fProxy->charToGlyphID(uni);
54}
55
56void SkRandomScalerContext::generateAdvance(SkGlyph* glyph) {
57    fProxy->getAdvance(glyph);
58}
59
60void 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
134void 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
178void SkRandomScalerContext::generatePath(SkGlyphID glyph, SkPath* path) {
179    fProxy->generatePath(glyph, path);
180}
181
182void SkRandomScalerContext::generateFontMetrics(SkPaint::FontMetrics* metrics) {
183    fProxy->getFontMetrics(metrics);
184}
185
186///////////////////////////////////////////////////////////////////////////////
187
188#include "SkTypefaceCache.h"
189
190SkRandomTypeface::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
196SkScalerContext* 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
202void SkRandomTypeface::onFilterRec(SkScalerContextRec* rec) const {
203    fProxy->filterRec(rec);
204    rec->setHinting(SkPaint::kNo_Hinting);
205    rec->fMaskFormat = SkMask::kARGB32_Format;
206}
207
208SkAdvancedTypefaceMetrics* SkRandomTypeface::onGetAdvancedTypefaceMetrics(
209                                PerGlyphInfo info,
210                                const uint32_t* glyphIDs,
211                                uint32_t glyphIDsCount) const {
212    return fProxy->getAdvancedTypefaceMetrics(info, glyphIDs, glyphIDsCount);
213}
214
215SkStreamAsset* SkRandomTypeface::onOpenStream(int* ttcIndex) const {
216    return fProxy->openStream(ttcIndex);
217}
218
219void SkRandomTypeface::onGetFontDescriptor(SkFontDescriptor* desc,
220                                      bool* isLocal) const {
221    fProxy->getFontDescriptor(desc, isLocal);
222}
223
224int SkRandomTypeface::onCharsToGlyphs(const void* chars, Encoding encoding,
225                                 uint16_t glyphs[], int glyphCount) const {
226    return fProxy->charsToGlyphs(chars, encoding, glyphs, glyphCount);
227}
228
229int SkRandomTypeface::onCountGlyphs() const {
230    return fProxy->countGlyphs();
231}
232
233int SkRandomTypeface::onGetUPEM() const {
234    return fProxy->getUnitsPerEm();
235}
236
237void SkRandomTypeface::onGetFamilyName(SkString* familyName) const {
238    fProxy->getFamilyName(familyName);
239}
240
241SkTypeface::LocalizedStrings* SkRandomTypeface::onCreateFamilyNameIterator() const {
242    return fProxy->createFamilyNameIterator();
243}
244
245int SkRandomTypeface::onGetVariationDesignPosition(
246        SkFontArguments::VariationPosition::Coordinate coordinates[], int coordinateCount) const
247{
248    return fProxy->onGetVariationDesignPosition(coordinates, coordinateCount);
249}
250
251int SkRandomTypeface::onGetTableTags(SkFontTableTag tags[]) const {
252    return fProxy->getTableTags(tags);
253}
254
255size_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