/* * Copyright 2009-2015 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ /* migrated from chrome/src/skia/ext/SkFontHost_fontconfig_direct.cpp */ #include "SkBuffer.h" #include "SkDataTable.h" #include "SkFontConfigInterface_direct.h" #include "SkFontStyle.h" #include "SkMutex.h" #include "SkStream.h" #include "SkString.h" #include "SkTArray.h" #include "SkTDArray.h" #include "SkTemplates.h" #include "SkTypeface.h" #include "SkTypes.h" #include #include size_t SkFontConfigInterface::FontIdentity::writeToMemory(void* addr) const { size_t size = sizeof(fID) + sizeof(fTTCIndex); size += sizeof(int32_t) + sizeof(int32_t) + sizeof(uint8_t); // weight, width, italic size += sizeof(int32_t) + fString.size(); // store length+data if (addr) { SkWBuffer buffer(addr, size); buffer.write32(fID); buffer.write32(fTTCIndex); buffer.write32(fString.size()); buffer.write32(fStyle.weight()); buffer.write32(fStyle.width()); buffer.write8(fStyle.slant()); buffer.write(fString.c_str(), fString.size()); buffer.padToAlign4(); SkASSERT(buffer.pos() == size); } return size; } size_t SkFontConfigInterface::FontIdentity::readFromMemory(const void* addr, size_t size) { SkRBuffer buffer(addr, size); (void)buffer.readU32(&fID); (void)buffer.readS32(&fTTCIndex); uint32_t strLen, weight, width; (void)buffer.readU32(&strLen); (void)buffer.readU32(&weight); (void)buffer.readU32(&width); uint8_t u8; (void)buffer.readU8(&u8); SkFontStyle::Slant slant = (SkFontStyle::Slant)u8; fStyle = SkFontStyle(weight, width, slant); fString.resize(strLen); (void)buffer.read(fString.writable_str(), strLen); buffer.skipToAlign4(); return buffer.pos(); // the actual number of bytes read } #ifdef SK_DEBUG static void make_iden(SkFontConfigInterface::FontIdentity* iden) { iden->fID = 10; iden->fTTCIndex = 2; iden->fString.set("Hello world"); iden->fStyle = SkFontStyle(300, 6, SkFontStyle::kItalic_Slant); } static void test_writeToMemory(const SkFontConfigInterface::FontIdentity& iden0, int initValue) { SkFontConfigInterface::FontIdentity iden1; size_t size0 = iden0.writeToMemory(nullptr); SkAutoMalloc storage(size0); memset(storage.get(), initValue, size0); size_t size1 = iden0.writeToMemory(storage.get()); SkASSERT(size0 == size1); SkASSERT(iden0 != iden1); size_t size2 = iden1.readFromMemory(storage.get(), size1); SkASSERT(size2 == size1); SkASSERT(iden0 == iden1); } static void fontconfiginterface_unittest() { SkFontConfigInterface::FontIdentity iden0, iden1; SkASSERT(iden0 == iden1); make_iden(&iden0); SkASSERT(iden0 != iden1); make_iden(&iden1); SkASSERT(iden0 == iden1); test_writeToMemory(iden0, 0); test_writeToMemory(iden0, 0); } #endif /////////////////////////////////////////////////////////////////////////////// // Returns the string from the pattern, or nullptr static const char* get_name(FcPattern* pattern, const char field[], int index = 0) { const char* name; if (FcPatternGetString(pattern, field, index, (FcChar8**)&name) != FcResultMatch) { name = nullptr; } return name; } /////////////////////////////////////////////////////////////////////////////// namespace { // Equivalence classes, used to match the Liberation and other fonts // with their metric-compatible replacements. See the discussion in // GetFontEquivClass(). enum FontEquivClass { OTHER, SANS, SERIF, MONO, SYMBOL, PGOTHIC, GOTHIC, PMINCHO, MINCHO, SIMSUN, NSIMSUN, SIMHEI, PMINGLIU, MINGLIU, PMINGLIUHK, MINGLIUHK, CAMBRIA, CALIBRI, }; // Match the font name against a whilelist of fonts, returning the equivalence // class. FontEquivClass GetFontEquivClass(const char* fontname) { // It would be nice for fontconfig to tell us whether a given suggested // replacement is a "strong" match (that is, an equivalent font) or // a "weak" match (that is, fontconfig's next-best attempt at finding a // substitute). However, I played around with the fontconfig API for // a good few hours and could not make it reveal this information. // // So instead, we hardcode. Initially this function emulated // /etc/fonts/conf.d/30-metric-aliases.conf // from my Ubuntu system, but we're better off being very conservative. // Arimo, Tinos and Cousine are a set of fonts metric-compatible with // Arial, Times New Roman and Courier New with a character repertoire // much larger than Liberation. Note that Cousine is metrically // compatible with Courier New, but the former is sans-serif while // the latter is serif. struct FontEquivMap { FontEquivClass clazz; const char name[40]; }; static const FontEquivMap kFontEquivMap[] = { { SANS, "Arial" }, { SANS, "Arimo" }, { SANS, "Liberation Sans" }, { SERIF, "Times New Roman" }, { SERIF, "Tinos" }, { SERIF, "Liberation Serif" }, { MONO, "Courier New" }, { MONO, "Cousine" }, { MONO, "Liberation Mono" }, { SYMBOL, "Symbol" }, { SYMBOL, "Symbol Neu" }, // ＭＳ Ｐゴシック { PGOTHIC, "MS PGothic" }, { PGOTHIC, "\xef\xbc\xad\xef\xbc\xb3 \xef\xbc\xb0" "\xe3\x82\xb4\xe3\x82\xb7\xe3\x83\x83\xe3\x82\xaf" }, { PGOTHIC, "Noto Sans CJK JP" }, { PGOTHIC, "IPAPGothic" }, { PGOTHIC, "MotoyaG04Gothic" }, // ＭＳ ゴシック { GOTHIC, "MS Gothic" }, { GOTHIC, "\xef\xbc\xad\xef\xbc\xb3 " "\xe3\x82\xb4\xe3\x82\xb7\xe3\x83\x83\xe3\x82\xaf" }, { GOTHIC, "Noto Sans Mono CJK JP" }, { GOTHIC, "IPAGothic" }, { GOTHIC, "MotoyaG04GothicMono" }, // ＭＳ Ｐ明朝 { PMINCHO, "MS PMincho" }, { PMINCHO, "\xef\xbc\xad\xef\xbc\xb3 \xef\xbc\xb0" "\xe6\x98\x8e\xe6\x9c\x9d"}, { PMINCHO, "IPAPMincho" }, { PMINCHO, "MotoyaG04Mincho" }, // ＭＳ 明朝 { MINCHO, "MS Mincho" }, { MINCHO, "\xef\xbc\xad\xef\xbc\xb3 \xe6\x98\x8e\xe6\x9c\x9d" }, { MINCHO, "IPAMincho" }, { MINCHO, "MotoyaG04MinchoMono" }, // 宋体 { SIMSUN, "Simsun" }, { SIMSUN, "\xe5\xae\x8b\xe4\xbd\x93" }, { SIMSUN, "MSung GB18030" }, { SIMSUN, "Song ASC" }, // 新宋体 { NSIMSUN, "NSimsun" }, { NSIMSUN, "\xe6\x96\xb0\xe5\xae\x8b\xe4\xbd\x93" }, { NSIMSUN, "MSung GB18030" }, { NSIMSUN, "N Song ASC" }, // 黑体 { SIMHEI, "Simhei" }, { SIMHEI, "\xe9\xbb\x91\xe4\xbd\x93" }, { SIMHEI, "Noto Sans CJK SC" }, { SIMHEI, "MYingHeiGB18030" }, { SIMHEI, "MYingHeiB5HK" }, // 新細明體 { PMINGLIU, "PMingLiU"}, { PMINGLIU, "\xe6\x96\xb0\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94" }, { PMINGLIU, "MSung B5HK"}, // 細明體 { MINGLIU, "MingLiU"}, { MINGLIU, "\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94" }, { MINGLIU, "MSung B5HK"}, // 新細明體 { PMINGLIUHK, "PMingLiU_HKSCS"}, { PMINGLIUHK, "\xe6\x96\xb0\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94_HKSCS" }, { PMINGLIUHK, "MSung B5HK"}, // 細明體 { MINGLIUHK, "MingLiU_HKSCS"}, { MINGLIUHK, "\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94_HKSCS" }, { MINGLIUHK, "MSung B5HK"}, // Cambria { CAMBRIA, "Cambria" }, { CAMBRIA, "Caladea" }, // Calibri { CALIBRI, "Calibri" }, { CALIBRI, "Carlito" }, }; static const size_t kFontCount = sizeof(kFontEquivMap)/sizeof(kFontEquivMap[0]); // TODO(jungshik): If this loop turns out to be hot, turn // the array to a static (hash)map to speed it up. for (size_t i = 0; i < kFontCount; ++i) { if (strcasecmp(kFontEquivMap[i].name, fontname) == 0) return kFontEquivMap[i].clazz; } return OTHER; } // Return true if |font_a| and |font_b| are visually and at the metrics // level interchangeable. bool IsMetricCompatibleReplacement(const char* font_a, const char* font_b) { FontEquivClass class_a = GetFontEquivClass(font_a); FontEquivClass class_b = GetFontEquivClass(font_b); return class_a != OTHER && class_a == class_b; } // Normally we only return exactly the font asked for. In last-resort // cases, the request either doesn't specify a font or is one of the // basic font names like "Sans", "Serif" or "Monospace". This function // tells you whether a given request is for such a fallback. bool IsFallbackFontAllowed(const SkString& family) { const char* family_cstr = family.c_str(); return family.isEmpty() || strcasecmp(family_cstr, "sans") == 0 || strcasecmp(family_cstr, "serif") == 0 || strcasecmp(family_cstr, "monospace") == 0; } // Retrieves |is_bold|, |is_italic| and |font_family| properties from |font|. SkTypeface::Style GetFontStyle(FcPattern* font) { int resulting_bold; if (FcPatternGetInteger(font, FC_WEIGHT, 0, &resulting_bold)) resulting_bold = FC_WEIGHT_NORMAL; int resulting_italic; if (FcPatternGetInteger(font, FC_SLANT, 0, &resulting_italic)) resulting_italic = FC_SLANT_ROMAN; // If we ask for an italic font, fontconfig might take a roman font and set // the undocumented property FC_MATRIX to a skew matrix. It'll then say // that the font is italic or oblique. So, if we see a matrix, we don't // believe that it's italic. FcValue matrix; const bool have_matrix = FcPatternGet(font, FC_MATRIX, 0, &matrix) == 0; // If we ask for an italic font, fontconfig might take a roman font and set // FC_EMBOLDEN. FcValue embolden; const bool have_embolden = FcPatternGet(font, FC_EMBOLDEN, 0, &embolden) == 0; int styleBits = 0; if (resulting_bold > FC_WEIGHT_MEDIUM && !have_embolden) { styleBits |= SkTypeface::kBold; } if (resulting_italic > FC_SLANT_ROMAN && !have_matrix) { styleBits |= SkTypeface::kItalic; } return (SkTypeface::Style)styleBits; } } // anonymous namespace /////////////////////////////////////////////////////////////////////////////// #define kMaxFontFamilyLength 2048 SkFontConfigInterfaceDirect::SkFontConfigInterfaceDirect() { SkAutoMutexAcquire ac(mutex_); FcInit(); SkDEBUGCODE(fontconfiginterface_unittest();) } SkFontConfigInterfaceDirect::~SkFontConfigInterfaceDirect() { } bool SkFontConfigInterfaceDirect::isAccessible(const char* filename) { if (access(filename, R_OK) != 0) { return false; } return true; } bool SkFontConfigInterfaceDirect::isValidPattern(FcPattern* pattern) { #ifdef SK_FONT_CONFIG_ONLY_ALLOW_SCALABLE_FONTS FcBool is_scalable; if (FcPatternGetBool(pattern, FC_SCALABLE, 0, &is_scalable) != FcResultMatch || !is_scalable) { return false; } #endif // fontconfig can also return fonts which are unreadable const char* c_filename = get_name(pattern, FC_FILE); if (!c_filename) { return false; } return this->isAccessible(c_filename); } // Find matching font from |font_set| for the given font family. FcPattern* SkFontConfigInterfaceDirect::MatchFont(FcFontSet* font_set, const char* post_config_family, const SkString& family) { // Older versions of fontconfig have a bug where they cannot select // only scalable fonts so we have to manually filter the results. FcPattern* match = nullptr; for (int i = 0; i < font_set->nfont; ++i) { FcPattern* current = font_set->fonts[i]; if (this->isValidPattern(current)) { match = current; break; } } if (match && !IsFallbackFontAllowed(family)) { bool acceptable_substitute = false; for (int id = 0; id < 255; ++id) { const char* post_match_family = get_name(match, FC_FAMILY, id); if (!post_match_family) break; acceptable_substitute = (strcasecmp(post_config_family, post_match_family) == 0 || // Workaround for Issue 12530: // requested family: "Bitstream Vera Sans" // post_config_family: "Arial" // post_match_family: "Bitstream Vera Sans" // -> We should treat this case as a good match. strcasecmp(family.c_str(), post_match_family) == 0) || IsMetricCompatibleReplacement(family.c_str(), post_match_family); if (acceptable_substitute) break; } if (!acceptable_substitute) return nullptr; } return match; } bool SkFontConfigInterfaceDirect::matchFamilyName(const char familyName[], SkTypeface::Style style, FontIdentity* outIdentity, SkString* outFamilyName, SkTypeface::Style* outStyle) { SkString familyStr(familyName ? familyName : ""); if (familyStr.size() > kMaxFontFamilyLength) { return false; } SkAutoMutexAcquire ac(mutex_); FcPattern* pattern = FcPatternCreate(); if (familyName) { FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName); } FcPatternAddInteger(pattern, FC_WEIGHT, (style & SkTypeface::kBold) ? FC_WEIGHT_BOLD : FC_WEIGHT_NORMAL); FcPatternAddInteger(pattern, FC_SLANT, (style & SkTypeface::kItalic) ? FC_SLANT_ITALIC : FC_SLANT_ROMAN); FcPatternAddBool(pattern, FC_SCALABLE, FcTrue); FcConfigSubstitute(nullptr, pattern, FcMatchPattern); FcDefaultSubstitute(pattern); // Font matching: // CSS often specifies a fallback list of families: // font-family: a, b, c, serif; // However, fontconfig will always do its best to find *a* font when asked // for something so we need a way to tell if the match which it has found is // "good enough" for us. Otherwise, we can return nullptr which gets piped up // and lets WebKit know to try the next CSS family name. However, fontconfig // configs allow substitutions (mapping "Arial -> Helvetica" etc) and we // wish to support that. // // Thus, if a specific family is requested we set @family_requested. Then we // record two strings: the family name after config processing and the // family name after resolving. If the two are equal, it's a good match. // // So consider the case where a user has mapped Arial to Helvetica in their // config. // requested family: "Arial" // post_config_family: "Helvetica" // post_match_family: "Helvetica" // -> good match // // and for a missing font: // requested family: "Monaco" // post_config_family: "Monaco" // post_match_family: "Times New Roman" // -> BAD match // // However, we special-case fallback fonts; see IsFallbackFontAllowed(). const char* post_config_family = get_name(pattern, FC_FAMILY); if (!post_config_family) { // we can just continue with an empty name, e.g. default font post_config_family = ""; } FcResult result; FcFontSet* font_set = FcFontSort(0, pattern, 0, 0, &result); if (!font_set) { FcPatternDestroy(pattern); return false; } FcPattern* match = this->MatchFont(font_set, post_config_family, familyStr); if (!match) { FcPatternDestroy(pattern); FcFontSetDestroy(font_set); return false; } FcPatternDestroy(pattern); // From here out we just extract our results from 'match' post_config_family = get_name(match, FC_FAMILY); if (!post_config_family) { FcFontSetDestroy(font_set); return false; } const char* c_filename = get_name(match, FC_FILE); if (!c_filename) { FcFontSetDestroy(font_set); return false; } int face_index; if (FcPatternGetInteger(match, FC_INDEX, 0, &face_index) != FcResultMatch) { FcFontSetDestroy(font_set); return false; } FcFontSetDestroy(font_set); if (outIdentity) { outIdentity->fTTCIndex = face_index; outIdentity->fString.set(c_filename); } if (outFamilyName) { outFamilyName->set(post_config_family); } if (outStyle) { *outStyle = GetFontStyle(match); } return true; } SkStreamAsset* SkFontConfigInterfaceDirect::openStream(const FontIdentity& identity) { return SkStream::NewFromFile(identity.fString.c_str()); } /////////////////////////////////////////////////////////////////////////////// static bool find_name(const SkTDArray& list, const char* str) { int count = list.count(); for (int i = 0; i < count; ++i) { if (!strcmp(list[i], str)) { return true; } } return false; } SkDataTable* SkFontConfigInterfaceDirect::getFamilyNames() { SkAutoMutexAcquire ac(mutex_); FcPattern* pat = FcPatternCreate(); SkAutoTCallVProc autoDestroyPat(pat); if (nullptr == pat) { return nullptr; } FcObjectSet* os = FcObjectSetBuild(FC_FAMILY, (char *)0); SkAutoTCallVProc autoDestroyOs(os); if (nullptr == os) { return nullptr; } FcFontSet* fs = FcFontList(nullptr, pat, os); SkAutoTCallVProc autoDestroyFs(fs); if (nullptr == fs) { return nullptr; } SkTDArray names; SkTDArray sizes; for (int i = 0; i < fs->nfont; ++i) { FcPattern* match = fs->fonts[i]; const char* famName = get_name(match, FC_FAMILY); if (famName && !find_name(names, famName)) { *names.append() = famName; *sizes.append() = strlen(famName) + 1; } } return SkDataTable::NewCopyArrays((const void*const*)names.begin(), sizes.begin(), names.count()); } bool SkFontConfigInterfaceDirect::matchFamilySet(const char inFamilyName[], SkString* outFamilyName, SkTArray* ids) { SkAutoMutexAcquire ac(mutex_); #if 0 SkString familyStr(familyName ? familyName : ""); if (familyStr.size() > kMaxFontFamilyLength) { return false; } SkAutoMutexAcquire ac(mutex_); FcPattern* pattern = FcPatternCreate(); if (familyName) { FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName); } FcPatternAddBool(pattern, FC_SCALABLE, FcTrue); FcConfigSubstitute(nullptr, pattern, FcMatchPattern); FcDefaultSubstitute(pattern); // Font matching: // CSS often specifies a fallback list of families: // font-family: a, b, c, serif; // However, fontconfig will always do its best to find *a* font when asked // for something so we need a way to tell if the match which it has found is // "good enough" for us. Otherwise, we can return nullptr which gets piped up // and lets WebKit know to try the next CSS family name. However, fontconfig // configs allow substitutions (mapping "Arial -> Helvetica" etc) and we // wish to support that. // // Thus, if a specific family is requested we set @family_requested. Then we // record two strings: the family name after config processing and the // family name after resolving. If the two are equal, it's a good match. // // So consider the case where a user has mapped Arial to Helvetica in their // config. // requested family: "Arial" // post_config_family: "Helvetica" // post_match_family: "Helvetica" // -> good match // // and for a missing font: // requested family: "Monaco" // post_config_family: "Monaco" // post_match_family: "Times New Roman" // -> BAD match // // However, we special-case fallback fonts; see IsFallbackFontAllowed(). const char* post_config_family = get_name(pattern, FC_FAMILY); FcResult result; FcFontSet* font_set = FcFontSort(0, pattern, 0, 0, &result); if (!font_set) { FcPatternDestroy(pattern); return false; } FcPattern* match = this->MatchFont(font_set, post_config_family, familyStr); if (!match) { FcPatternDestroy(pattern); FcFontSetDestroy(font_set); return false; } FcPatternDestroy(pattern); // From here out we just extract our results from 'match' if (FcPatternGetString(match, FC_FAMILY, 0, &post_config_family) != FcResultMatch) { FcFontSetDestroy(font_set); return false; } FcChar8* c_filename; if (FcPatternGetString(match, FC_FILE, 0, &c_filename) != FcResultMatch) { FcFontSetDestroy(font_set); return false; } int face_index; if (FcPatternGetInteger(match, FC_INDEX, 0, &face_index) != FcResultMatch) { FcFontSetDestroy(font_set); return false; } FcFontSetDestroy(font_set); if (outIdentity) { outIdentity->fTTCIndex = face_index; outIdentity->fString.set((const char*)c_filename); } if (outFamilyName) { outFamilyName->set((const char*)post_config_family); } if (outStyle) { *outStyle = GetFontStyle(match); } return true; //////////////////// int count; FcPattern** match = this->MatchFont(font_set, post_config_family, &count); if (!match) { FcPatternDestroy(pattern); FcFontSetDestroy(font_set); return nullptr; } FcPatternDestroy(pattern); SkTDArray trimmedMatches; for (int i = 0; i < count; ++i) { const char* justName = find_just_name(get_name(match[i], FC_FILE)); if (!is_lower(*justName)) { *trimmedMatches.append() = match[i]; } } SkFontStyleSet_FC* sset = new SkFontStyleSet_FC (trimmedMatches.begin(), trimmedMatches.count()); #endif return false; }