Home | History | Annotate | Download | only in core 
      1 /*
      2  * Copyright 2011 The Android Open Source Project
      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 "SkAdvancedTypefaceMetrics.h"
      9 #include "SkEndian.h"
     10 #include "SkFontDescriptor.h"
     11 #include "SkFontMgr.h"
     12 #include "SkLazyPtr.h"
     13 #include "SkOTTable_OS_2.h"
     14 #include "SkStream.h"
     15 #include "SkTypeface.h"
     16 
     17 SkTypeface::SkTypeface(const SkFontStyle& style, SkFontID fontID, bool isFixedPitch)
     18     : fUniqueID(fontID), fStyle(style), fIsFixedPitch(isFixedPitch) { }
     19 
     20 SkTypeface::~SkTypeface() { }
     21 
     22 ///////////////////////////////////////////////////////////////////////////////
     23 
     24 class SkEmptyTypeface : public SkTypeface {
     25 public:
     26     static SkEmptyTypeface* Create() {
     27         return SkNEW(SkEmptyTypeface);
     28     }
     29 protected:
     30     SkEmptyTypeface() : SkTypeface(SkFontStyle(), 0, true) { }
     31 
     32     SkStreamAsset* onOpenStream(int* ttcIndex) const override { return NULL; }
     33     SkScalerContext* onCreateScalerContext(const SkDescriptor*) const override {
     34         return NULL;
     35     }
     36     void onFilterRec(SkScalerContextRec*) const override { }
     37     virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
     38                                 PerGlyphInfo,
     39                                 const uint32_t*, uint32_t) const override { return NULL; }
     40     void onGetFontDescriptor(SkFontDescriptor*, bool*) const override { }
     41     virtual int onCharsToGlyphs(const void* chars, Encoding encoding,
     42                                 uint16_t glyphs[], int glyphCount) const override {
     43         if (glyphs && glyphCount > 0) {
     44             sk_bzero(glyphs, glyphCount * sizeof(glyphs[0]));
     45         }
     46         return 0;
     47     }
     48     int onCountGlyphs() const override { return 0; };
     49     int onGetUPEM() const override { return 0; };
     50     class EmptyLocalizedStrings : public SkTypeface::LocalizedStrings {
     51     public:
     52         bool next(SkTypeface::LocalizedString*) override { return false; }
     53     };
     54     void onGetFamilyName(SkString* familyName) const override {
     55         familyName->reset();
     56     }
     57     SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override {
     58         return SkNEW(EmptyLocalizedStrings);
     59     };
     60     int onGetTableTags(SkFontTableTag tags[]) const override { return 0; }
     61     size_t onGetTableData(SkFontTableTag, size_t, size_t, void*) const override {
     62         return 0;
     63     }
     64 };
     65 
     66 namespace {
     67 
     68 SK_DECLARE_STATIC_MUTEX(gCreateDefaultMutex);
     69 
     70 // As a template arguments, these must have external linkage.
     71 SkTypeface* sk_create_default_typeface(int style) {
     72     // It is not safe to call FontConfigTypeface::LegacyCreateTypeface concurrently.
     73     // To be safe, we serialize here with a mutex so only one call to
     74     // CreateTypeface is happening at any given time.
     75     // TODO(bungeman, mtklein): This is sad.  Make our fontconfig code safe?
     76     SkAutoMutexAcquire lock(&gCreateDefaultMutex);
     77 
     78     SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
     79     SkTypeface* t = fm->legacyCreateTypeface(NULL, style);
     80     return t ? t : SkEmptyTypeface::Create();
     81 }
     82 
     83 void sk_unref_typeface(SkTypeface* ptr) { SkSafeUnref(ptr); }
     84 
     85 }  // namespace
     86 
     87 SK_DECLARE_STATIC_LAZY_PTR_ARRAY(SkTypeface, defaults, 4,
     88                                  sk_create_default_typeface, sk_unref_typeface);
     89 
     90 SkTypeface* SkTypeface::GetDefaultTypeface(Style style) {
     91     SkASSERT((int)style < 4);
     92     return defaults[style];
     93 }
     94 
     95 SkTypeface* SkTypeface::RefDefault(Style style) {
     96     return SkRef(GetDefaultTypeface(style));
     97 }
     98 
     99 uint32_t SkTypeface::UniqueID(const SkTypeface* face) {
    100     if (NULL == face) {
    101         face = GetDefaultTypeface();
    102     }
    103     return face->uniqueID();
    104 }
    105 
    106 bool SkTypeface::Equal(const SkTypeface* facea, const SkTypeface* faceb) {
    107     return SkTypeface::UniqueID(facea) == SkTypeface::UniqueID(faceb);
    108 }
    109 
    110 ///////////////////////////////////////////////////////////////////////////////
    111 
    112 SkTypeface* SkTypeface::CreateFromName(const char name[], Style style) {
    113     if (NULL == name) {
    114         return RefDefault(style);
    115     }
    116     SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
    117     return fm->legacyCreateTypeface(name, style);
    118 }
    119 
    120 SkTypeface* SkTypeface::CreateFromTypeface(const SkTypeface* family, Style s) {
    121     if (!family) {
    122         return SkTypeface::RefDefault(s);
    123     }
    124 
    125     if (family->style() == s) {
    126         family->ref();
    127         return const_cast<SkTypeface*>(family);
    128     }
    129 
    130     SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
    131     bool bold = s & SkTypeface::kBold;
    132     bool italic = s & SkTypeface::kItalic;
    133     SkFontStyle newStyle = SkFontStyle(bold ? SkFontStyle::kBold_Weight
    134                                             : SkFontStyle::kNormal_Weight,
    135                                        SkFontStyle::kNormal_Width,
    136                                        italic ? SkFontStyle::kItalic_Slant
    137                                               : SkFontStyle::kUpright_Slant);
    138     return fm->matchFaceStyle(family, newStyle);
    139 }
    140 
    141 SkTypeface* SkTypeface::CreateFromStream(SkStreamAsset* stream, int index) {
    142     SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
    143     return fm->createFromStream(stream, index);
    144 }
    145 
    146 SkTypeface* SkTypeface::CreateFromFile(const char path[], int index) {
    147     SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
    148     return fm->createFromFile(path, index);
    149 }
    150 
    151 ///////////////////////////////////////////////////////////////////////////////
    152 
    153 void SkTypeface::serialize(SkWStream* wstream) const {
    154     bool isLocal = false;
    155     SkFontDescriptor desc(this->style());
    156     this->onGetFontDescriptor(&desc, &isLocal);
    157 
    158     // Embed font data if it's a local font.
    159     if (isLocal && !desc.hasFontData()) {
    160         int ttcIndex;
    161         desc.setFontData(this->onOpenStream(&ttcIndex));
    162         desc.setFontIndex(ttcIndex);
    163     }
    164     desc.serialize(wstream);
    165 }
    166 
    167 void SkTypeface::serializeForcingEmbedding(SkWStream* wstream) const {
    168     bool ignoredIsLocal;
    169     SkFontDescriptor desc(this->style());
    170     this->onGetFontDescriptor(&desc, &ignoredIsLocal);
    171 
    172     // Always embed font data.
    173     if (!desc.hasFontData()) {
    174         int ttcIndex;
    175         desc.setFontData(this->onOpenStream(&ttcIndex));
    176         desc.setFontIndex(ttcIndex);
    177     }
    178     desc.serialize(wstream);
    179 }
    180 
    181 SkTypeface* SkTypeface::Deserialize(SkStream* stream) {
    182     SkFontDescriptor desc(stream);
    183     SkStreamAsset* data = desc.transferFontData();
    184     if (data) {
    185         SkTypeface* typeface = SkTypeface::CreateFromStream(data, desc.getFontIndex());
    186         if (typeface) {
    187             return typeface;
    188         }
    189     }
    190     return SkTypeface::CreateFromName(desc.getFamilyName(), desc.getStyle());
    191 }
    192 
    193 ///////////////////////////////////////////////////////////////////////////////
    194 
    195 int SkTypeface::countTables() const {
    196     return this->onGetTableTags(NULL);
    197 }
    198 
    199 int SkTypeface::getTableTags(SkFontTableTag tags[]) const {
    200     return this->onGetTableTags(tags);
    201 }
    202 
    203 size_t SkTypeface::getTableSize(SkFontTableTag tag) const {
    204     return this->onGetTableData(tag, 0, ~0U, NULL);
    205 }
    206 
    207 size_t SkTypeface::getTableData(SkFontTableTag tag, size_t offset, size_t length,
    208                                 void* data) const {
    209     return this->onGetTableData(tag, offset, length, data);
    210 }
    211 
    212 SkStreamAsset* SkTypeface::openStream(int* ttcIndex) const {
    213     int ttcIndexStorage;
    214     if (NULL == ttcIndex) {
    215         // So our subclasses don't need to check for null param
    216         ttcIndex = &ttcIndexStorage;
    217     }
    218     return this->onOpenStream(ttcIndex);
    219 }
    220 
    221 int SkTypeface::charsToGlyphs(const void* chars, Encoding encoding,
    222                               uint16_t glyphs[], int glyphCount) const {
    223     if (glyphCount <= 0) {
    224         return 0;
    225     }
    226     if (NULL == chars || (unsigned)encoding > kUTF32_Encoding) {
    227         if (glyphs) {
    228             sk_bzero(glyphs, glyphCount * sizeof(glyphs[0]));
    229         }
    230         return 0;
    231     }
    232     return this->onCharsToGlyphs(chars, encoding, glyphs, glyphCount);
    233 }
    234 
    235 int SkTypeface::countGlyphs() const {
    236     return this->onCountGlyphs();
    237 }
    238 
    239 int SkTypeface::getUnitsPerEm() const {
    240     // should we try to cache this in the base-class?
    241     return this->onGetUPEM();
    242 }
    243 
    244 bool SkTypeface::getKerningPairAdjustments(const uint16_t glyphs[], int count,
    245                                            int32_t adjustments[]) const {
    246     SkASSERT(count >= 0);
    247     // check for the only legal way to pass a NULL.. everything is 0
    248     // in which case they just want to know if this face can possibly support
    249     // kerning (true) or never (false).
    250     if (NULL == glyphs || NULL == adjustments) {
    251         SkASSERT(NULL == glyphs);
    252         SkASSERT(0 == count);
    253         SkASSERT(NULL == adjustments);
    254     }
    255     return this->onGetKerningPairAdjustments(glyphs, count, adjustments);
    256 }
    257 
    258 SkTypeface::LocalizedStrings* SkTypeface::createFamilyNameIterator() const {
    259     return this->onCreateFamilyNameIterator();
    260 }
    261 
    262 void SkTypeface::getFamilyName(SkString* name) const {
    263     SkASSERT(name);
    264     this->onGetFamilyName(name);
    265 }
    266 
    267 SkAdvancedTypefaceMetrics* SkTypeface::getAdvancedTypefaceMetrics(
    268                                 PerGlyphInfo info,
    269                                 const uint32_t* glyphIDs,
    270                                 uint32_t glyphIDsCount) const {
    271     SkAdvancedTypefaceMetrics* result =
    272             this->onGetAdvancedTypefaceMetrics(info, glyphIDs, glyphIDsCount);
    273     if (result && result->fType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
    274         struct SkOTTableOS2 os2table;
    275         if (this->getTableData(SkTEndian_SwapBE32(SkOTTableOS2::TAG), 0,
    276                                sizeof(os2table), &os2table) > 0) {
    277             if (os2table.version.v2.fsType.field.Bitmap ||
    278                 (os2table.version.v2.fsType.field.Restricted &&
    279                  !(os2table.version.v2.fsType.field.PreviewPrint ||
    280                    os2table.version.v2.fsType.field.Editable))) {
    281                 result->fFlags = SkTBitOr<SkAdvancedTypefaceMetrics::FontFlags>(
    282                         result->fFlags,
    283                         SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag);
    284             }
    285             if (os2table.version.v2.fsType.field.NoSubsetting) {
    286                 result->fFlags = SkTBitOr<SkAdvancedTypefaceMetrics::FontFlags>(
    287                         result->fFlags,
    288                         SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag);
    289             }
    290         }
    291     }
    292     return result;
    293 }
    294 
    295 bool SkTypeface::onGetKerningPairAdjustments(const uint16_t glyphs[], int count,
    296                                              int32_t adjustments[]) const {
    297     return false;
    298 }
    299 
    300 ///////////////////////////////////////////////////////////////////////////////
    301 
    302 #include "SkDescriptor.h"
    303 #include "SkPaint.h"
    304 
    305 struct SkTypeface::BoundsComputer {
    306     const SkTypeface& fTypeface;
    307 
    308     BoundsComputer(const SkTypeface& tf) : fTypeface(tf) {}
    309 
    310     SkRect* operator()() const {
    311         SkRect* rect = SkNEW(SkRect);
    312         if (!fTypeface.onComputeBounds(rect)) {
    313             rect->setEmpty();
    314         }
    315         return rect;
    316     }
    317 };
    318 
    319 SkRect SkTypeface::getBounds() const {
    320     return *fLazyBounds.get(BoundsComputer(*this));
    321 }
    322 
    323 bool SkTypeface::onComputeBounds(SkRect* bounds) const {
    324     // we use a big size to ensure lots of significant bits from the scalercontext.
    325     // then we scale back down to return our final answer (at 1-pt)
    326     const SkScalar textSize = 2048;
    327     const SkScalar invTextSize = 1 / textSize;
    328 
    329     SkPaint paint;
    330     paint.setTypeface(const_cast<SkTypeface*>(this));
    331     paint.setTextSize(textSize);
    332     paint.setLinearText(true);
    333 
    334     SkScalerContext::Rec rec;
    335     SkScalerContext::MakeRec(paint, NULL, NULL, &rec);
    336 
    337     SkAutoDescriptor ad(sizeof(rec) + SkDescriptor::ComputeOverhead(1));
    338     SkDescriptor*    desc = ad.getDesc();
    339     desc->init();
    340     desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
    341 
    342     SkAutoTDelete<SkScalerContext> ctx(this->createScalerContext(desc, true));
    343     if (ctx.get()) {
    344         SkPaint::FontMetrics fm;
    345         ctx->getFontMetrics(&fm);
    346         bounds->set(fm.fXMin * invTextSize, fm.fTop * invTextSize,
    347                     fm.fXMax * invTextSize, fm.fBottom * invTextSize);
    348         return true;
    349     }
    350     return false;
    351 }
    352 
    353