Home | History | Annotate | Download | only in minikin 
      1 /*
      2  * Copyright (C) 2013 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 // #define VERBOSE_DEBUG
     18 
     19 #define LOG_TAG "Minikin"
     20 #include <cutils/log.h>
     21 
     22 #include "unicode/unistr.h"
     23 #include "unicode/unorm2.h"
     24 
     25 #include "MinikinInternal.h"
     26 #include <minikin/CmapCoverage.h>
     27 #include <minikin/FontCollection.h>
     28 
     29 using std::vector;
     30 
     31 namespace android {
     32 
     33 template <typename T>
     34 static inline T max(T a, T b) {
     35     return a>b ? a : b;
     36 }
     37 
     38 uint32_t FontCollection::sNextId = 0;
     39 
     40 FontCollection::FontCollection(const vector<FontFamily*>& typefaces) :
     41     mMaxChar(0) {
     42     AutoMutex _l(gMinikinLock);
     43     mId = sNextId++;
     44     vector<uint32_t> lastChar;
     45     size_t nTypefaces = typefaces.size();
     46 #ifdef VERBOSE_DEBUG
     47     ALOGD("nTypefaces = %d\n", nTypefaces);
     48 #endif
     49     const FontStyle defaultStyle;
     50     for (size_t i = 0; i < nTypefaces; i++) {
     51         FontFamily* family = typefaces[i];
     52         MinikinFont* typeface = family->getClosestMatch(defaultStyle).font;
     53         if (typeface == NULL) {
     54             continue;
     55         }
     56         family->RefLocked();
     57         FontInstance dummy;
     58         mInstances.push_back(dummy);  // emplace_back would be better
     59         FontInstance* instance = &mInstances.back();
     60         instance->mFamily = family;
     61         instance->mCoverage = new SparseBitSet;
     62 #ifdef VERBOSE_DEBUG
     63         ALOGD("closest match = %p, family size = %d\n", typeface, family->getNumFonts());
     64 #endif
     65         const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p');
     66         size_t cmapSize = 0;
     67         bool ok = typeface->GetTable(cmapTag, NULL, &cmapSize);
     68         UniquePtr<uint8_t[]> cmapData(new uint8_t[cmapSize]);
     69         ok = typeface->GetTable(cmapTag, cmapData.get(), &cmapSize);
     70         CmapCoverage::getCoverage(*instance->mCoverage, cmapData.get(), cmapSize);
     71 #ifdef VERBOSE_DEBUG
     72         ALOGD("font coverage length=%d, first ch=%x\n", instance->mCoverage->length(),
     73                 instance->mCoverage->nextSetBit(0));
     74 #endif
     75         mMaxChar = max(mMaxChar, instance->mCoverage->length());
     76         lastChar.push_back(instance->mCoverage->nextSetBit(0));
     77     }
     78     nTypefaces = mInstances.size();
     79     LOG_ALWAYS_FATAL_IF(nTypefaces == 0,
     80         "Font collection must have at least one valid typeface");
     81     size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage;
     82     size_t offset = 0;
     83     for (size_t i = 0; i < nPages; i++) {
     84         Range dummy;
     85         mRanges.push_back(dummy);
     86         Range* range = &mRanges.back();
     87 #ifdef VERBOSE_DEBUG
     88         ALOGD("i=%d: range start = %d\n", i, offset);
     89 #endif
     90         range->start = offset;
     91         for (size_t j = 0; j < nTypefaces; j++) {
     92             if (lastChar[j] < (i + 1) << kLogCharsPerPage) {
     93                 const FontInstance* instance = &mInstances[j];
     94                 mInstanceVec.push_back(instance);
     95                 offset++;
     96                 uint32_t nextChar = instance->mCoverage->nextSetBit((i + 1) << kLogCharsPerPage);
     97 #ifdef VERBOSE_DEBUG
     98                 ALOGD("nextChar = %d (j = %d)\n", nextChar, j);
     99 #endif
    100                 lastChar[j] = nextChar;
    101             }
    102         }
    103         range->end = offset;
    104     }
    105 }
    106 
    107 FontCollection::~FontCollection() {
    108     for (size_t i = 0; i < mInstances.size(); i++) {
    109         delete mInstances[i].mCoverage;
    110         mInstances[i].mFamily->UnrefLocked();
    111     }
    112 }
    113 
    114 // Implement heuristic for choosing best-match font. Here are the rules:
    115 // 1. If first font in the collection has the character, it wins.
    116 // 2. If a font matches both language and script, it gets a score of 4.
    117 // 3. If a font matches just language, it gets a score of 2.
    118 // 4. Matching the "compact" or "elegant" variant adds one to the score.
    119 // 5. Highest score wins, with ties resolved to the first font.
    120 const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t ch,
    121             FontLanguage lang, int variant) const {
    122     if (ch >= mMaxChar) {
    123         return NULL;
    124     }
    125     const Range& range = mRanges[ch >> kLogCharsPerPage];
    126 #ifdef VERBOSE_DEBUG
    127     ALOGD("querying range %d:%d\n", range.start, range.end);
    128 #endif
    129     const FontInstance* bestInstance = NULL;
    130     int bestScore = -1;
    131     for (size_t i = range.start; i < range.end; i++) {
    132         const FontInstance* instance = mInstanceVec[i];
    133         if (instance->mCoverage->get(ch)) {
    134             FontFamily* family = instance->mFamily;
    135             // First font family in collection always matches
    136             if (mInstances[0].mFamily == family) {
    137                 return instance;
    138             }
    139             int score = lang.match(family->lang()) * 2;
    140             if (variant != 0 && variant == family->variant()) {
    141                 score++;
    142             }
    143             if (score > bestScore) {
    144                 bestScore = score;
    145                 bestInstance = instance;
    146             }
    147         }
    148     }
    149     if (bestInstance == NULL && !mInstanceVec.empty()) {
    150         UErrorCode errorCode = U_ZERO_ERROR;
    151         const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode);
    152         if (U_SUCCESS(errorCode)) {
    153             UChar decomposed[4];
    154             int len = unorm2_getRawDecomposition(normalizer, ch, decomposed, 4, &errorCode);
    155             if (U_SUCCESS(errorCode) && len > 0) {
    156                 int off = 0;
    157                 U16_NEXT_UNSAFE(decomposed, off, ch);
    158                 return getInstanceForChar(ch, lang, variant);
    159             }
    160         }
    161         bestInstance = &mInstances[0];
    162     }
    163     return bestInstance;
    164 }
    165 
    166 const uint32_t NBSP = 0xa0;
    167 const uint32_t ZWJ = 0x200c;
    168 const uint32_t ZWNJ = 0x200d;
    169 const uint32_t KEYCAP = 0x20e3;
    170 
    171 // Characters where we want to continue using existing font run instead of
    172 // recomputing the best match in the fallback list.
    173 static const uint32_t stickyWhitelist[] = { '!', ',', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, KEYCAP };
    174 
    175 static bool isStickyWhitelisted(uint32_t c) {
    176     for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) {
    177         if (stickyWhitelist[i] == c) return true;
    178     }
    179     return false;
    180 }
    181 
    182 void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style,
    183         vector<Run>* result) const {
    184     FontLanguage lang = style.getLanguage();
    185     int variant = style.getVariant();
    186     const FontInstance* lastInstance = NULL;
    187     Run* run = NULL;
    188     int nShorts;
    189     for (size_t i = 0; i < string_size; i += nShorts) {
    190         nShorts = 1;
    191         uint32_t ch = string[i];
    192         // sigh, decode UTF-16 by hand here
    193         if ((ch & 0xfc00) == 0xd800) {
    194             if ((i + 1) < string_size) {
    195                 ch = 0x10000 + ((ch & 0x3ff) << 10) + (string[i + 1] & 0x3ff);
    196                 nShorts = 2;
    197             }
    198         }
    199         // Continue using existing font as long as it has coverage and is whitelisted
    200         if (lastInstance == NULL
    201                 || !(isStickyWhitelisted(ch) && lastInstance->mCoverage->get(ch))) {
    202             const FontInstance* instance = getInstanceForChar(ch, lang, variant);
    203             if (i == 0 || instance != lastInstance) {
    204                 size_t start = i;
    205                 // Workaround for Emoji keycap until we implement per-cluster font
    206                 // selection: if keycap is found in a different font that also
    207                 // supports previous char, attach previous char to the new run.
    208                 // Only handles non-surrogate characters.
    209                 // Bug 7557244.
    210                 if (ch == KEYCAP && i && instance && instance->mCoverage->get(string[i - 1])) {
    211                     run->end--;
    212                     if (run->start == run->end) {
    213                         result->pop_back();
    214                     }
    215                     start--;
    216                 }
    217                 Run dummy;
    218                 result->push_back(dummy);
    219                 run = &result->back();
    220                 if (instance == NULL) {
    221                     run->fakedFont.font = NULL;
    222                 } else {
    223                     run->fakedFont = instance->mFamily->getClosestMatch(style);
    224                 }
    225                 lastInstance = instance;
    226                 run->start = start;
    227             }
    228         }
    229         run->end = i + nShorts;
    230     }
    231 }
    232 
    233 MinikinFont* FontCollection::baseFont(FontStyle style) {
    234     return baseFontFaked(style).font;
    235 }
    236 
    237 FakedFont FontCollection::baseFontFaked(FontStyle style) {
    238     if (mInstances.empty()) {
    239         return FakedFont();
    240     }
    241     return mInstances[0].mFamily->getClosestMatch(style);
    242 }
    243 
    244 uint32_t FontCollection::getId() const {
    245     return mId;
    246 }
    247 
    248 }  // namespace android
    249