libs/minikin/FontCollection.cpp - platform/frameworks/minikin - Git at Google

 /*
  * Copyright (C) 2013 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 // #define VERBOSE_DEBUG

 #define LOG_TAG "Minikin"
 #include <cutils/log.h>

 #include "unicode/unistr.h"
 #include "unicode/unorm2.h"

 #include "MinikinInternal.h"
 #include <minikin/FontCollection.h>

 using std::vector;

 namespace android {

 template <typename T>
 static inline T max(T a, T b) {
     return a>b ? a : b;
 }

 uint32_t FontCollection::sNextId = 0;

 FontCollection::FontCollection(const vector<FontFamily*>& typefaces) :
     mMaxChar(0) {
     AutoMutex _l(gMinikinLock);
     mId = sNextId++;
     vector<uint32_t> lastChar;
     size_t nTypefaces = typefaces.size();
 #ifdef VERBOSE_DEBUG
     ALOGD("nTypefaces = %d\n", nTypefaces);
 #endif
     const FontStyle defaultStyle;
     for (size_t i = 0; i < nTypefaces; i++) {
         FontFamily* family = typefaces[i];
         MinikinFont* typeface = family->getClosestMatch(defaultStyle).font;
         if (typeface == NULL) {
             continue;
         }
         family->RefLocked();
         const SparseBitSet* coverage = family->getCoverage();
         if (coverage == nullptr) {
             family->UnrefLocked();
             continue;
         }
         mFamilies.push_back(family);  // emplace_back would be better
         mMaxChar = max(mMaxChar, coverage->length());
         lastChar.push_back(coverage->nextSetBit(0));
     }
     nTypefaces = mFamilies.size();
     LOG_ALWAYS_FATAL_IF(nTypefaces == 0,
         "Font collection must have at least one valid typeface");
     size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage;
     size_t offset = 0;
     for (size_t i = 0; i < nPages; i++) {
         Range dummy;
         mRanges.push_back(dummy);
         Range* range = &mRanges.back();
 #ifdef VERBOSE_DEBUG
         ALOGD("i=%d: range start = %d\n", i, offset);
 #endif
         range->start = offset;
         for (size_t j = 0; j < nTypefaces; j++) {
             if (lastChar[j] < (i + 1) << kLogCharsPerPage) {
                 FontFamily* family = mFamilies[j];
                 mFamilyVec.push_back(family);
                 offset++;
                 uint32_t nextChar = family->getCoverage()->nextSetBit((i + 1) << kLogCharsPerPage);
 #ifdef VERBOSE_DEBUG
                 ALOGD("nextChar = %d (j = %d)\n", nextChar, j);
 #endif
                 lastChar[j] = nextChar;
             }
         }
         range->end = offset;
     }
 }

 FontCollection::~FontCollection() {
     for (size_t i = 0; i < mFamilies.size(); i++) {
         mFamilies[i]->UnrefLocked();
     }
 }

 // Implement heuristic for choosing best-match font. Here are the rules:
 // 1. If first font in the collection has the character, it wins.
 // 2. If a font matches both language and script, it gets a score of 4.
 // 3. If a font matches just language, it gets a score of 2.
 // 4. Matching the "compact" or "elegant" variant adds one to the score.
 // 5. Highest score wins, with ties resolved to the first font.
 FontFamily* FontCollection::getFamilyForChar(uint32_t ch,
             FontLanguage lang, int variant) const {
     if (ch >= mMaxChar) {
         return NULL;
     }
     const Range& range = mRanges[ch >> kLogCharsPerPage];
 #ifdef VERBOSE_DEBUG
     ALOGD("querying range %d:%d\n", range.start, range.end);
 #endif
     FontFamily* bestFamily = NULL;
     int bestScore = -1;
     for (size_t i = range.start; i < range.end; i++) {
         FontFamily* family = mFamilyVec[i];
         if (family->getCoverage()->get(ch)) {
             // First font family in collection always matches
             if (mFamilies[0] == family) {
                 return family;
             }
             int score = lang.match(family->lang()) * 2;
             if (family->variant() == 0 || family->variant() == variant) {
                 score++;
             }
             if (score > bestScore) {
                 bestScore = score;
                 bestFamily = family;
             }
         }
     }
     if (bestFamily == NULL && !mFamilyVec.empty()) {
         UErrorCode errorCode = U_ZERO_ERROR;
         const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode);
         if (U_SUCCESS(errorCode)) {
             UChar decomposed[4];
             int len = unorm2_getRawDecomposition(normalizer, ch, decomposed, 4, &errorCode);
             if (U_SUCCESS(errorCode) && len > 0) {
                 int off = 0;
                 U16_NEXT_UNSAFE(decomposed, off, ch);
                 return getFamilyForChar(ch, lang, variant);
             }
         }
         bestFamily = mFamilies[0];
     }
     return bestFamily;
 }

 const uint32_t NBSP = 0xa0;
 const uint32_t ZWJ = 0x200c;
 const uint32_t ZWNJ = 0x200d;
 const uint32_t KEYCAP = 0x20e3;
 const uint32_t HYPHEN = 0x2010;
 const uint32_t NB_HYPHEN = 0x2011;

 // Characters where we want to continue using existing font run instead of
 // recomputing the best match in the fallback list.
 static const uint32_t stickyWhitelist[] = { '!', ',', '-', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ,
         KEYCAP, HYPHEN, NB_HYPHEN };

 static bool isStickyWhitelisted(uint32_t c) {
     for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) {
         if (stickyWhitelist[i] == c) return true;
     }
     return false;
 }

 static bool isVariationSelector(uint32_t c) {
     return (0xFE00 <= c && c <= 0xFE0F) || (0xE0100 <= c && c <= 0xE01EF);
 }

 void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style,
         vector<Run>* result) const {
     FontLanguage lang = style.getLanguage();
     int variant = style.getVariant();
     FontFamily* lastFamily = NULL;
     Run* run = NULL;
     int nShorts;
     for (size_t i = 0; i < string_size; i += nShorts) {
         nShorts = 1;
         uint32_t ch = string[i];
         // sigh, decode UTF-16 by hand here
         if ((ch & 0xfc00) == 0xd800) {
             if ((i + 1) < string_size) {
                 ch = 0x10000 + ((ch & 0x3ff) << 10) + (string[i + 1] & 0x3ff);
                 nShorts = 2;
             }
         }
         // Continue using existing font as long as it has coverage and is whitelisted;
         // also variation sequences continue existing run.
         if (lastFamily == NULL
                 || !((isStickyWhitelisted(ch) && lastFamily->getCoverage()->get(ch))
                       || isVariationSelector(ch))) {
             FontFamily* family = getFamilyForChar(ch, lang, variant);
             if (i == 0 || family != lastFamily) {
                 size_t start = i;
                 // Workaround for Emoji keycap until we implement per-cluster font
                 // selection: if keycap is found in a different font that also
                 // supports previous char, attach previous char to the new run.
                 // Only handles non-surrogate characters.
                 // Bug 7557244.
                 if (ch == KEYCAP && i && family && family->getCoverage()->get(string[i - 1])) {
                     run->end--;
                     if (run->start == run->end) {
                         result->pop_back();
                     }
                     start--;
                 }
                 Run dummy;
                 result->push_back(dummy);
                 run = &result->back();
                 if (family == NULL) {
                     run->fakedFont.font = NULL;
                 } else {
                     run->fakedFont = family->getClosestMatch(style);
                 }
                 lastFamily = family;
                 run->start = start;
             }
         }
         run->end = i + nShorts;
     }
 }

 MinikinFont* FontCollection::baseFont(FontStyle style) {
     return baseFontFaked(style).font;
 }

 FakedFont FontCollection::baseFontFaked(FontStyle style) {
     if (mFamilies.empty()) {
         return FakedFont();
     }
     return mFamilies[0]->getClosestMatch(style);
 }

 uint32_t FontCollection::getId() const {
     return mId;
 }

 }  // namespace android
	/*
	* Copyright (C) 2013 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	// #define VERBOSE_DEBUG

	#define LOG_TAG "Minikin"
	#include <cutils/log.h>

	#include "unicode/unistr.h"
	#include "unicode/unorm2.h"

	#include "MinikinInternal.h"
	#include <minikin/FontCollection.h>

	using std::vector;

	namespace android {

	template <typename T>
	static inline T max(T a, T b) {
	return a>b ? a : b;
	}

	uint32_t FontCollection::sNextId = 0;

	FontCollection::FontCollection(const vector<FontFamily*>& typefaces) :
	mMaxChar(0) {
	AutoMutex _l(gMinikinLock);
	mId = sNextId++;
	vector<uint32_t> lastChar;
	size_t nTypefaces = typefaces.size();
	#ifdef VERBOSE_DEBUG
	ALOGD("nTypefaces = %d\n", nTypefaces);
	#endif
	const FontStyle defaultStyle;
	for (size_t i = 0; i < nTypefaces; i++) {
	FontFamily* family = typefaces[i];
	MinikinFont* typeface = family->getClosestMatch(defaultStyle).font;
	if (typeface == NULL) {
	continue;
	}
	family->RefLocked();
	const SparseBitSet* coverage = family->getCoverage();
	if (coverage == nullptr) {
	family->UnrefLocked();
	continue;
	}
	mFamilies.push_back(family); // emplace_back would be better
	mMaxChar = max(mMaxChar, coverage->length());
	lastChar.push_back(coverage->nextSetBit(0));
	}
	nTypefaces = mFamilies.size();
	LOG_ALWAYS_FATAL_IF(nTypefaces == 0,
	"Font collection must have at least one valid typeface");
	size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage;
	size_t offset = 0;
	for (size_t i = 0; i < nPages; i++) {
	Range dummy;
	mRanges.push_back(dummy);
	Range* range = &mRanges.back();
	#ifdef VERBOSE_DEBUG
	ALOGD("i=%d: range start = %d\n", i, offset);
	#endif
	range->start = offset;
	for (size_t j = 0; j < nTypefaces; j++) {
	if (lastChar[j] < (i + 1) << kLogCharsPerPage) {
	FontFamily* family = mFamilies[j];
	mFamilyVec.push_back(family);
	offset++;
	uint32_t nextChar = family->getCoverage()->nextSetBit((i + 1) << kLogCharsPerPage);
	#ifdef VERBOSE_DEBUG
	ALOGD("nextChar = %d (j = %d)\n", nextChar, j);
	#endif
	lastChar[j] = nextChar;
	}
	}
	range->end = offset;
	}
	}

	FontCollection::~FontCollection() {
	for (size_t i = 0; i < mFamilies.size(); i++) {
	mFamilies[i]->UnrefLocked();
	}
	}

	// Implement heuristic for choosing best-match font. Here are the rules:
	// 1. If first font in the collection has the character, it wins.
	// 2. If a font matches both language and script, it gets a score of 4.
	// 3. If a font matches just language, it gets a score of 2.
	// 4. Matching the "compact" or "elegant" variant adds one to the score.
	// 5. Highest score wins, with ties resolved to the first font.
	FontFamily* FontCollection::getFamilyForChar(uint32_t ch,
	FontLanguage lang, int variant) const {
	if (ch >= mMaxChar) {
	return NULL;
	}
	const Range& range = mRanges[ch >> kLogCharsPerPage];
	#ifdef VERBOSE_DEBUG
	ALOGD("querying range %d:%d\n", range.start, range.end);
	#endif
	FontFamily* bestFamily = NULL;
	int bestScore = -1;
	for (size_t i = range.start; i < range.end; i++) {
	FontFamily* family = mFamilyVec[i];
	if (family->getCoverage()->get(ch)) {
	// First font family in collection always matches
	if (mFamilies[0] == family) {
	return family;
	}
	int score = lang.match(family->lang()) * 2;
	if (family->variant() == 0 \|\| family->variant() == variant) {
	score++;
	}
	if (score > bestScore) {
	bestScore = score;
	bestFamily = family;
	}
	}
	}
	if (bestFamily == NULL && !mFamilyVec.empty()) {
	UErrorCode errorCode = U_ZERO_ERROR;
	const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode);
	if (U_SUCCESS(errorCode)) {
	UChar decomposed[4];
	int len = unorm2_getRawDecomposition(normalizer, ch, decomposed, 4, &errorCode);
	if (U_SUCCESS(errorCode) && len > 0) {
	int off = 0;
	U16_NEXT_UNSAFE(decomposed, off, ch);
	return getFamilyForChar(ch, lang, variant);
	}
	}
	bestFamily = mFamilies[0];
	}
	return bestFamily;
	}

	const uint32_t NBSP = 0xa0;
	const uint32_t ZWJ = 0x200c;
	const uint32_t ZWNJ = 0x200d;
	const uint32_t KEYCAP = 0x20e3;
	const uint32_t HYPHEN = 0x2010;
	const uint32_t NB_HYPHEN = 0x2011;

	// Characters where we want to continue using existing font run instead of
	// recomputing the best match in the fallback list.
	static const uint32_t stickyWhitelist[] = { '!', ',', '-', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ,
	KEYCAP, HYPHEN, NB_HYPHEN };

	static bool isStickyWhitelisted(uint32_t c) {
	for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) {
	if (stickyWhitelist[i] == c) return true;
	}
	return false;
	}

	static bool isVariationSelector(uint32_t c) {
	return (0xFE00 <= c && c <= 0xFE0F) \|\| (0xE0100 <= c && c <= 0xE01EF);
	}

	void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style,
	vector<Run>* result) const {
	FontLanguage lang = style.getLanguage();
	int variant = style.getVariant();
	FontFamily* lastFamily = NULL;
	Run* run = NULL;
	int nShorts;
	for (size_t i = 0; i < string_size; i += nShorts) {
	nShorts = 1;
	uint32_t ch = string[i];
	// sigh, decode UTF-16 by hand here
	if ((ch & 0xfc00) == 0xd800) {
	if ((i + 1) < string_size) {
	ch = 0x10000 + ((ch & 0x3ff) << 10) + (string[i + 1] & 0x3ff);
	nShorts = 2;
	}
	}
	// Continue using existing font as long as it has coverage and is whitelisted;
	// also variation sequences continue existing run.
	if (lastFamily == NULL
	\|\| !((isStickyWhitelisted(ch) && lastFamily->getCoverage()->get(ch))
	\|\| isVariationSelector(ch))) {
	FontFamily* family = getFamilyForChar(ch, lang, variant);
	if (i == 0 \|\| family != lastFamily) {
	size_t start = i;
	// Workaround for Emoji keycap until we implement per-cluster font
	// selection: if keycap is found in a different font that also
	// supports previous char, attach previous char to the new run.
	// Only handles non-surrogate characters.
	// Bug 7557244.
	if (ch == KEYCAP && i && family && family->getCoverage()->get(string[i - 1])) {
	run->end--;
	if (run->start == run->end) {
	result->pop_back();
	}
	start--;
	}
	Run dummy;
	result->push_back(dummy);
	run = &result->back();
	if (family == NULL) {
	run->fakedFont.font = NULL;
	} else {
	run->fakedFont = family->getClosestMatch(style);
	}
	lastFamily = family;
	run->start = start;
	}
	}
	run->end = i + nShorts;
	}
	}

	MinikinFont* FontCollection::baseFont(FontStyle style) {
	return baseFontFaked(style).font;
	}

	FakedFont FontCollection::baseFontFaked(FontStyle style) {
	if (mFamilies.empty()) {
	return FakedFont();
	}
	return mFamilies[0]->getClosestMatch(style);
	}

	uint32_t FontCollection::getId() const {
	return mId;
	}

	} // namespace android