SkRandomScalerContext.cpp revision 9d5f66d9c21eda7d3e2ed47654180c0c4b6e38b1
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