Merge Android 12
Bug: 202323961
Merged-In: Ibca7e25968decd95cdc4c54b12239976d6762e49
Change-Id: I94734acf08f2b62e695d4771dcaa0afabec7a33b
diff --git a/include/minikin/BoundsCache.h b/include/minikin/BoundsCache.h
new file mode 100644
index 0000000..64f2b49
--- /dev/null
+++ b/include/minikin/BoundsCache.h
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2020 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.
+ */
+
+#ifndef MINIKIN_BOUNDS_CACHE_H
+#define MINIKIN_BOUNDS_CACHE_H
+
+#include "minikin/LayoutCache.h"
+
+#include <mutex>
+
+#include <utils/LruCache.h>
+
+#include "minikin/BoundsCache.h"
+#include "minikin/FontCollection.h"
+#include "minikin/Hasher.h"
+#include "minikin/MinikinPaint.h"
+
+namespace minikin {
+
+// Cache entry
+struct BoundsValue {
+ MinikinRect rect;
+ float advance;
+};
+
+// Used for callback for LayoutCache.
+struct ValueExtractor {
+ void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& paint);
+ std::unique_ptr<BoundsValue> value;
+};
+
+class BoundsCache : private android::OnEntryRemoved<LayoutCacheKey, BoundsValue*> {
+public:
+ void clear() {
+ std::lock_guard<std::mutex> lock(mMutex);
+ mCache.clear();
+ }
+
+ // Do not use BoundsCache inside the callback function, otherwise dead-lock may happen.
+ template <typename F>
+ void getOrCreate(const U16StringPiece& text, const Range& range, const MinikinPaint& paint,
+ bool dir, StartHyphenEdit startHyphen, EndHyphenEdit endHyphen, F& f) {
+ LayoutCacheKey key(text, range, paint, dir, startHyphen, endHyphen);
+ if (paint.skipCache() || range.getLength() >= LENGTH_LIMIT_CACHE) {
+ LayoutPiece piece = LayoutPiece(text, range, dir, paint, startHyphen, endHyphen);
+ f(getBounds(piece, paint), piece.advance());
+ return;
+ }
+ {
+ std::lock_guard<std::mutex> lock(mMutex);
+ BoundsValue* value = mCache.get(key);
+ if (value != nullptr) {
+ f(value->rect, value->advance);
+ return;
+ }
+ }
+ // Doing text layout takes long time, so releases the mutex during doing layout.
+ // Don't care even if we do the same layout in other thread.
+ key.copyText();
+ ValueExtractor ve;
+ LayoutCache::getInstance().getOrCreate(text, range, paint, dir, startHyphen, endHyphen, ve);
+ f(ve.value->rect, ve.value->advance);
+ {
+ std::lock_guard<std::mutex> lock(mMutex);
+ mCache.put(key, ve.value.release());
+ }
+ }
+
+ static BoundsCache& getInstance() {
+ static BoundsCache cache(kMaxEntries);
+ return cache;
+ }
+
+ // Compute new bounding box for the layout piece.
+ static MinikinRect getBounds(const LayoutPiece& layoutPiece, const MinikinPaint& paint);
+
+protected:
+ BoundsCache(uint32_t maxEntries) : mCache(maxEntries) {
+ mCache.setOnEntryRemovedListener(this);
+ }
+
+private:
+ // callback for OnEntryRemoved
+ void operator()(LayoutCacheKey& key, BoundsValue*& value) {
+ key.freeText();
+ delete value;
+ }
+
+ std::mutex mMutex;
+ android::LruCache<LayoutCacheKey, BoundsValue*> mCache GUARDED_BY(mMutex) GUARDED_BY(mMutex);
+ // LRU cache capacity. Should be fine to be less than LayoutCache#kMaxEntries since bbox
+ // calculation happens less than layout calculation.
+ static const size_t kMaxEntries = 500;
+};
+
+} // namespace minikin
+#endif // MINIKIN_BOUNDS_CACHE_H
diff --git a/include/minikin/Buffer.h b/include/minikin/Buffer.h
new file mode 100644
index 0000000..87ba3fd
--- /dev/null
+++ b/include/minikin/Buffer.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2020 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.
+ */
+
+#ifndef MINIKIN_BUFFER_H
+#define MINIKIN_BUFFER_H
+
+#include <cstring>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+namespace minikin {
+
+// This is a helper class to read data from a memory buffer.
+// This class does not copy memory, and may return pointers to parts of the memory buffer.
+// Thus the memory buffer should outlive objects created using this class.
+class BufferReader {
+public:
+ BufferReader(const void* buffer) : BufferReader(buffer, 0) {}
+ BufferReader(const void* buffer, uint32_t pos)
+ : mData(reinterpret_cast<const uint8_t*>(buffer)), mPos(pos) {}
+
+ template <typename T>
+ static uint32_t align(uint32_t pos) {
+ // This should be true for all types, unless custom alignment attributes are set.
+ static_assert(sizeof(T) % alignof(T) == 0, "sizeof(T) must be a multiple of alignof(T)");
+ // We align to sizeof(T) instead of alignof(T), because the buffer may be shared between
+ // 32-bit processes and 64-bit processes. alignof(T) may change between the two.
+ // We assume that T is a type whose size is fixed (e.g. uint32_t).
+ return (pos + sizeof(T) - 1) / sizeof(T) * sizeof(T);
+ }
+
+ template <typename T>
+ const T& read() {
+ static_assert(std::is_pod<T>::value, "T must be a POD");
+ mPos = BufferReader::align<T>(mPos);
+ const T* data = reinterpret_cast<const T*>(mData + mPos);
+ mPos += sizeof(T);
+ return *data;
+ }
+
+ template <typename T>
+ void skip() {
+ static_assert(std::is_pod<T>::value, "T must be a POD");
+ mPos = BufferReader::align<T>(mPos);
+ mPos += sizeof(T);
+ }
+
+ // Return a pointer to an array and its number of elements.
+ template <typename T>
+ std::pair<const T*, uint32_t> readArray() {
+ static_assert(std::is_pod<T>::value, "T must be a POD");
+ uint32_t size = read<uint32_t>();
+ mPos = BufferReader::align<T>(mPos);
+ const T* data = reinterpret_cast<const T*>(mData + mPos);
+ mPos += size * sizeof(T);
+ return std::make_pair(data, size);
+ }
+
+ template <typename T>
+ void skipArray() {
+ static_assert(std::is_pod<T>::value, "T must be a POD");
+ uint32_t size = read<uint32_t>();
+ mPos = BufferReader::align<T>(mPos);
+ mPos += size * sizeof(T);
+ }
+
+ std::string_view readString() {
+ auto [data, size] = readArray<char>();
+ return std::string_view(data, size);
+ }
+
+ void skipString() { skipArray<char>(); }
+
+ const void* data() const { return mData; }
+ size_t pos() const { return mPos; }
+
+private:
+ const uint8_t* mData;
+ size_t mPos;
+};
+
+// This is a helper class to write data to a memory buffer.
+class BufferWriter {
+public:
+ // Create a buffer writer. Passing nullptr creates a fake writer,
+ // which can be used to measure the buffer size needed.
+ BufferWriter(void* buffer) : mData(reinterpret_cast<uint8_t*>(buffer)), mPos(0) {}
+
+ BufferWriter(BufferWriter&&) = default;
+ BufferWriter& operator=(BufferWriter&&) = default;
+
+ // Write a single data of type T.
+ // Please always specify T explicitly using <>. std::common_type_t<T> resolves to T, but
+ // disables template argument deduction.
+ // TODO: use std::type_identity_t when C++20 is available.
+ template <typename T>
+ void write(const std::common_type_t<T>& data) {
+ static_assert(std::is_pod<T>::value, "T must be a POD");
+ mPos = BufferReader::align<T>(mPos);
+ if (mData != nullptr) {
+ memcpy(mData + mPos, &data, sizeof(T));
+ }
+ mPos += sizeof(T);
+ }
+
+ // Write an array of type T.
+ // Please always specify T explicitly using <>. std::common_type_t<T> resolves to T, but
+ // disables template argument deduction.
+ // TODO: use std::type_identity_t when C++20 is available.
+ template <typename T>
+ void writeArray(const std::common_type_t<T>* data, uint32_t size) {
+ static_assert(std::is_pod<T>::value, "T must be a POD");
+ write<uint32_t>(size);
+ mPos = BufferReader::align<T>(mPos);
+ if (mData != nullptr) {
+ memcpy(mData + mPos, data, size * sizeof(T));
+ }
+ mPos += size * sizeof(T);
+ }
+
+ void writeString(std::string_view string) { writeArray<char>(string.data(), string.size()); }
+
+ // Return the number of bytes written.
+ size_t size() const { return mPos; }
+
+private:
+ uint8_t* mData;
+ size_t mPos;
+
+ // Forbid copy and assign.
+ BufferWriter(const BufferWriter&) = delete;
+ void operator=(const BufferWriter&) = delete;
+};
+
+} // namespace minikin
+
+#endif // MINIKIN_BUFFER_H
diff --git a/include/minikin/Font.h b/include/minikin/Font.h
index eeb074e..67feecf 100644
--- a/include/minikin/Font.h
+++ b/include/minikin/Font.h
@@ -18,11 +18,14 @@
#define MINIKIN_FONT_H
#include <memory>
+#include <mutex>
#include <unordered_set>
+#include "minikin/Buffer.h"
#include "minikin/FontStyle.h"
#include "minikin/FontVariation.h"
#include "minikin/HbUtils.h"
+#include "minikin/LocaleList.h"
#include "minikin/Macros.h"
#include "minikin/MinikinFont.h"
@@ -55,7 +58,10 @@
inline bool operator!=(const FakedFont& o) const { return !(*this == o); }
// ownership is the enclosing FontCollection
- const Font* font;
+ // FakedFont will be stored in the LayoutCache. It is not a good idea too keep font instance
+ // even if the enclosing FontCollection, i.e. Typeface is GC-ed. The layout cache is only
+ // purged when it is overflown, thus intentionally keep only reference.
+ const std::shared_ptr<Font>& font;
FontFakery fakery;
};
@@ -88,44 +94,96 @@
return *this;
}
- Font build();
+ Builder& setLocaleListId(uint32_t id) {
+ mLocaleListId = id;
+ return *this;
+ }
+
+ std::shared_ptr<Font> build();
private:
std::shared_ptr<MinikinFont> mTypeface;
uint16_t mWeight = static_cast<uint16_t>(FontStyle::Weight::NORMAL);
FontStyle::Slant mSlant = FontStyle::Slant::UPRIGHT;
+ uint32_t mLocaleListId = kEmptyLocaleListId;
bool mIsWeightSet = false;
bool mIsSlantSet = false;
};
- Font(Font&& o) = default;
- Font& operator=(Font&& o) = default;
+ // Type for functions to load MinikinFont lazily.
+ using TypefaceLoader = std::shared_ptr<MinikinFont>(BufferReader reader);
+ // Type for functions to read MinikinFont metadata and return
+ // TypefaceLoader.
+ using TypefaceReader = TypefaceLoader*(BufferReader* reader);
+ // Type for functions to write MinikinFont metadata.
+ using TypefaceWriter = void(BufferWriter* writer, const MinikinFont* typeface);
- Font& operator=(const Font& o) {
- mTypeface = o.mTypeface;
- mStyle = o.mStyle;
- mBaseFont = HbFontUniquePtr(hb_font_reference(o.mBaseFont.get()));
- return *this;
+ template <TypefaceReader typefaceReader>
+ static std::shared_ptr<Font> readFrom(BufferReader* reader, uint32_t localeListId) {
+ FontStyle style = FontStyle(reader);
+ BufferReader typefaceMetadataReader = *reader;
+ TypefaceLoader* typefaceLoader = typefaceReader(reader);
+ return std::shared_ptr<Font>(
+ new Font(style, typefaceMetadataReader, typefaceLoader, localeListId));
}
- Font(const Font& o) { *this = o; }
- inline const std::shared_ptr<MinikinFont>& typeface() const { return mTypeface; }
+ template <TypefaceWriter typefaceWriter>
+ void writeTo(BufferWriter* writer) const {
+ mStyle.writeTo(writer);
+ typefaceWriter(writer, typeface().get());
+ }
+
+ // This locale list is just for API compatibility. This is not used in font selection or family
+ // fallback.
+ uint32_t getLocaleListId() const { return mLocaleListId; }
+ const std::shared_ptr<MinikinFont>& typeface() const;
inline FontStyle style() const { return mStyle; }
- inline const HbFontUniquePtr& baseFont() const { return mBaseFont; }
+ const HbFontUniquePtr& baseFont() const;
+ BufferReader typefaceMetadataReader() const { return mTypefaceMetadataReader; }
std::unordered_set<AxisTag> getSupportedAxes() const;
private:
// Use Builder instead.
- Font(std::shared_ptr<MinikinFont>&& typeface, FontStyle style, HbFontUniquePtr&& baseFont)
- : mTypeface(std::move(typeface)), mStyle(style), mBaseFont(std::move(baseFont)) {}
+ Font(std::shared_ptr<MinikinFont>&& typeface, FontStyle style, HbFontUniquePtr&& baseFont,
+ uint32_t localeListId)
+ : mTypeface(std::move(typeface)),
+ mStyle(style),
+ mBaseFont(std::move(baseFont)),
+ mTypefaceLoader(nullptr),
+ mTypefaceMetadataReader(nullptr),
+ mLocaleListId(localeListId) {}
+ Font(FontStyle style, BufferReader typefaceMetadataReader, TypefaceLoader* typefaceLoader,
+ uint32_t localeListId)
+ : mStyle(style),
+ mTypefaceLoader(typefaceLoader),
+ mTypefaceMetadataReader(typefaceMetadataReader),
+ mLocaleListId(localeListId) {}
+
+ void initTypefaceLocked() const EXCLUSIVE_LOCKS_REQUIRED(mTypefaceMutex);
static HbFontUniquePtr prepareFont(const std::shared_ptr<MinikinFont>& typeface);
static FontStyle analyzeStyle(const HbFontUniquePtr& font);
- std::shared_ptr<MinikinFont> mTypeface;
+ // Lazy-initialized if created by readFrom().
+ mutable std::shared_ptr<MinikinFont> mTypeface GUARDED_BY(mTypefaceMutex);
FontStyle mStyle;
- HbFontUniquePtr mBaseFont;
+ // Lazy-initialized if created by readFrom().
+ mutable HbFontUniquePtr mBaseFont GUARDED_BY(mTypefaceMutex);
+
+ mutable std::mutex mTypefaceMutex;
+ // Non-null if created by readFrom().
+ TypefaceLoader* mTypefaceLoader;
+ // Non-null if created by readFrom().
+ BufferReader mTypefaceMetadataReader;
+
+ uint32_t mLocaleListId;
+
+ // Stop copying and moving
+ Font(Font&& o) = delete;
+ Font& operator=(Font&& o) = delete;
+ Font(const Font& o) = delete;
+ Font& operator=(const Font& o) = delete;
};
} // namespace minikin
diff --git a/include/minikin/FontCollection.h b/include/minikin/FontCollection.h
index f136384..98df571 100644
--- a/include/minikin/FontCollection.h
+++ b/include/minikin/FontCollection.h
@@ -18,9 +18,14 @@
#define MINIKIN_FONT_COLLECTION_H
#include <memory>
+#include <unordered_map>
#include <unordered_set>
#include <vector>
+#include <gtest/gtest_prod.h>
+
+#include "minikin/Buffer.h"
+#include "minikin/Font.h"
#include "minikin/FontFamily.h"
#include "minikin/MinikinFont.h"
#include "minikin/U16StringPiece.h"
@@ -35,12 +40,134 @@
explicit FontCollection(const std::vector<std::shared_ptr<FontFamily>>& typefaces);
explicit FontCollection(std::shared_ptr<FontFamily>&& typeface);
+ template <Font::TypefaceReader typefaceReader>
+ static std::vector<std::shared_ptr<FontCollection>> readVector(BufferReader* reader) {
+ uint32_t allFontFamiliesCount = reader->read<uint32_t>();
+ std::vector<std::shared_ptr<FontFamily>> allFontFamilies;
+ allFontFamilies.reserve(allFontFamiliesCount);
+ for (uint32_t i = 0; i < allFontFamiliesCount; i++) {
+ allFontFamilies.push_back(FontFamily::readFrom<typefaceReader>(reader));
+ }
+ uint32_t fontCollectionsCount = reader->read<uint32_t>();
+ std::vector<std::shared_ptr<FontCollection>> fontCollections;
+ fontCollections.reserve(fontCollectionsCount);
+ for (uint32_t i = 0; i < fontCollectionsCount; i++) {
+ fontCollections.emplace_back(new FontCollection(reader, allFontFamilies));
+ }
+ return fontCollections;
+ }
+
+ template <Font::TypefaceWriter typefaceWriter>
+ static void writeVector(BufferWriter* writer,
+ const std::vector<std::shared_ptr<FontCollection>>& fontCollections) {
+ std::vector<std::shared_ptr<FontFamily>> allFontFamilies;
+ // Note: operator== for shared_ptr compares raw pointer values.
+ std::unordered_map<std::shared_ptr<FontFamily>, uint32_t> fontFamilyToIndexMap;
+ collectAllFontFamilies(fontCollections, &allFontFamilies, &fontFamilyToIndexMap);
+
+ writer->write<uint32_t>(allFontFamilies.size());
+ for (const auto& fontFamily : allFontFamilies) {
+ fontFamily->writeTo<typefaceWriter>(writer);
+ }
+ writer->write<uint32_t>(fontCollections.size());
+ for (const auto& fontCollection : fontCollections) {
+ fontCollection->writeTo(writer, fontFamilyToIndexMap);
+ }
+ }
+
+ // Helper class for representing font family match result in packed bits.
+ struct FamilyMatchResult {
+ public:
+ struct Builder {
+ public:
+ Builder() : mSize(0), mBits(0) {}
+
+ Builder& add(uint8_t x) {
+ if (mSize >= 7) [[unlikely]] {
+ return *this;
+ }
+ mBits = mBits | (static_cast<uint64_t>(x) << (8 * mSize));
+ mSize++;
+ return *this;
+ }
+
+ Builder& reset() {
+ mSize = 0;
+ mBits = 0;
+ return *this;
+ }
+
+ uint8_t size() const { return mSize; }
+
+ bool empty() const { return size() == 0; }
+
+ FamilyMatchResult build() {
+ return FamilyMatchResult(mBits | (static_cast<uint64_t>(mSize) << 56));
+ }
+
+ private:
+ uint8_t mSize;
+ uint64_t mBits;
+ };
+
+ // Helper class for iterating FamilyMatchResult
+ class iterator {
+ public:
+ inline bool operator==(const iterator& o) const {
+ return mOffset == o.mOffset && mResult == o.mResult;
+ }
+
+ inline bool operator!=(const iterator& o) const { return !(*this == o); }
+ inline uint8_t operator*() const { return mResult[mOffset]; }
+ inline iterator& operator++() {
+ mOffset++;
+ return *this;
+ }
+
+ private:
+ friend struct FamilyMatchResult;
+ iterator(const FamilyMatchResult& result, uint32_t offset)
+ : mResult(result), mOffset(offset) {}
+ const FamilyMatchResult& mResult;
+ uint32_t mOffset;
+ };
+
+ // Create empty FamilyMatchResult.
+ FamilyMatchResult() : mBits(0) {}
+
+ inline uint8_t size() const { return static_cast<uint8_t>(mBits >> 56); }
+
+ inline uint8_t operator[](uint32_t pos) const {
+ return static_cast<uint8_t>(mBits >> (pos * 8));
+ }
+
+ inline bool empty() const { return size() == 0; }
+
+ inline bool operator==(const FamilyMatchResult& o) const { return mBits == o.mBits; }
+
+ // Returns the common family indices between l and r.
+ static FamilyMatchResult intersect(FamilyMatchResult l, FamilyMatchResult r);
+
+ // Iterator
+ inline iterator begin() const { return iterator(*this, 0); }
+ inline iterator end() const { return iterator(*this, size()); }
+
+ FamilyMatchResult(const FamilyMatchResult& o) = default;
+ FamilyMatchResult& operator=(const FamilyMatchResult& o) = default;
+
+ private:
+ explicit FamilyMatchResult(uint64_t bits) : mBits(bits) {}
+ uint64_t mBits;
+ };
+
struct Run {
- FakedFont fakedFont;
+ FamilyMatchResult familyMatch;
int start;
int end;
};
+ FakedFont getBestFont(U16StringPiece textBuf, const Run& run, FontStyle style);
+
// Perform the itemization until given max runs.
std::vector<Run> itemize(U16StringPiece text, FontStyle style, uint32_t localeListId,
FamilyVariant familyVariant, uint32_t runMax) const;
@@ -68,7 +195,23 @@
uint32_t getId() const;
+ const std::vector<std::shared_ptr<FontFamily>>& getFamilies() const { return mFamilies; }
+
private:
+ FRIEND_TEST(FontCollectionTest, bufferTest);
+
+ FontCollection(BufferReader* reader,
+ const std::vector<std::shared_ptr<FontFamily>>& allFontFamilies);
+ // Write fields of the instance, using fontFamilyToIndexMap for finding
+ // indices for FontFamily.
+ void writeTo(BufferWriter* writer,
+ const std::unordered_map<std::shared_ptr<FontFamily>, uint32_t>&
+ fontFamilyToIndexMap) const;
+ static void collectAllFontFamilies(
+ const std::vector<std::shared_ptr<FontCollection>>& fontCollections,
+ std::vector<std::shared_ptr<FontFamily>>* outAllFontFamilies,
+ std::unordered_map<std::shared_ptr<FontFamily>, uint32_t>* outFontFamilyToIndexMap);
+
static const int kLogCharsPerPage = 8;
static const int kPageMask = (1 << kLogCharsPerPage) - 1;
@@ -85,9 +228,8 @@
// Initialize the FontCollection.
void init(const std::vector<std::shared_ptr<FontFamily>>& typefaces);
- const std::shared_ptr<FontFamily>& getFamilyForChar(uint32_t ch, uint32_t vs,
- uint32_t localeListId,
- FamilyVariant variant) const;
+ FamilyMatchResult getFamilyForChar(uint32_t ch, uint32_t vs, uint32_t localeListId,
+ FamilyVariant variant) const;
uint32_t calcFamilyScore(uint32_t ch, uint32_t vs, FamilyVariant variant, uint32_t localeListId,
const std::shared_ptr<FontFamily>& fontFamily) const;
@@ -116,14 +258,21 @@
// mFamilyVec[mRange[0xXXYY].end] instead of whole mFamilies.
// This vector contains indices into mFamilies.
// This vector can't be empty.
- std::vector<Range> mRanges;
- std::vector<uint8_t> mFamilyVec;
+ uint32_t mRangesCount;
+ const Range* mRanges;
+ uint32_t mFamilyVecCount;
+ const uint8_t* mFamilyVec;
// This vector has pointers to the font family instances which have cmap 14 subtables.
std::vector<std::shared_ptr<FontFamily>> mVSFamilyVec;
// Set of supported axes in this collection.
std::unordered_set<AxisTag> mSupportedAxes;
+
+ // Owns allocated memory if this class is created from font families, otherwise these are
+ // nullptr.
+ std::unique_ptr<Range[]> mOwnedRanges;
+ std::vector<uint8_t> mOwnedFamilyVec;
};
} // namespace minikin
diff --git a/include/minikin/FontFamily.h b/include/minikin/FontFamily.h
index 4aafaa0..6169193 100644
--- a/include/minikin/FontFamily.h
+++ b/include/minikin/FontFamily.h
@@ -33,10 +33,32 @@
class FontFamily {
public:
- explicit FontFamily(std::vector<Font>&& fonts);
- FontFamily(FamilyVariant variant, std::vector<Font>&& fonts);
- FontFamily(uint32_t localeListId, FamilyVariant variant, std::vector<Font>&& fonts,
- bool isCustomFallback);
+ explicit FontFamily(std::vector<std::shared_ptr<Font>>&& fonts);
+ FontFamily(FamilyVariant variant, std::vector<std::shared_ptr<Font>>&& fonts);
+ FontFamily(uint32_t localeListId, FamilyVariant variant,
+ std::vector<std::shared_ptr<Font>>&& fonts, bool isCustomFallback);
+
+ template <Font::TypefaceReader typefaceReader>
+ static std::shared_ptr<FontFamily> readFrom(BufferReader* reader) {
+ uint32_t localeListId = readLocaleListInternal(reader);
+ uint32_t fontsCount = reader->read<uint32_t>();
+ std::vector<std::shared_ptr<Font>> fonts;
+ fonts.reserve(fontsCount);
+ for (uint32_t i = 0; i < fontsCount; i++) {
+ fonts.emplace_back(Font::readFrom<typefaceReader>(reader, localeListId));
+ }
+ return readFromInternal(reader, std::move(fonts), localeListId);
+ }
+
+ template <Font::TypefaceWriter typefaceWriter>
+ void writeTo(BufferWriter* writer) const {
+ writeLocaleListInternal(writer);
+ writer->write<uint32_t>(mFonts.size());
+ for (const std::shared_ptr<Font>& font : mFonts) {
+ font->writeTo<typefaceWriter>(writer);
+ }
+ writeToInternal(writer);
+ }
FakedFont getClosestMatch(FontStyle style) const;
@@ -45,8 +67,9 @@
// API's for enumerating the fonts in a family. These don't guarantee any particular order
size_t getNumFonts() const { return mFonts.size(); }
- const Font* getFont(size_t index) const { return &mFonts[index]; }
- FontStyle getStyle(size_t index) const { return mFonts[index].style(); }
+ const Font* getFont(size_t index) const { return mFonts[index].get(); }
+ const std::shared_ptr<Font>& getFontRef(size_t index) const { return mFonts[index]; }
+ FontStyle getStyle(size_t index) const { return mFonts[index]->style(); }
bool isColorEmojiFamily() const { return mIsColorEmoji; }
const std::unordered_set<AxisTag>& supportedAxes() const { return mSupportedAxes; }
bool isCustomFallback() const { return mIsCustomFallback; }
@@ -67,11 +90,24 @@
const std::vector<FontVariation>& variations) const;
private:
+ FontFamily(uint32_t localeListId, FamilyVariant variant,
+ std::vector<std::shared_ptr<Font>>&& fonts,
+ std::unordered_set<AxisTag>&& supportedAxes, bool isColorEmoji,
+ bool isCustomFallback, SparseBitSet&& coverage,
+ std::vector<std::unique_ptr<SparseBitSet>>&& cmapFmt14Coverage);
+
+ static uint32_t readLocaleListInternal(BufferReader* reader);
+ static std::shared_ptr<FontFamily> readFromInternal(BufferReader* reader,
+ std::vector<std::shared_ptr<Font>>&& fonts,
+ uint32_t localeListId);
+ void writeLocaleListInternal(BufferWriter* writer) const;
+ void writeToInternal(BufferWriter* writer) const;
+
void computeCoverage();
uint32_t mLocaleListId;
FamilyVariant mVariant;
- std::vector<Font> mFonts;
+ std::vector<std::shared_ptr<Font>> mFonts;
std::unordered_set<AxisTag> mSupportedAxes;
bool mIsColorEmoji;
bool mIsCustomFallback;
diff --git a/include/minikin/FontFileParser.h b/include/minikin/FontFileParser.h
new file mode 100644
index 0000000..34880a3
--- /dev/null
+++ b/include/minikin/FontFileParser.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+#ifndef MINIKIN_FONT_FILE_PARSER_H
+#define MINIKIN_FONT_FILE_PARSER_H
+
+#include "minikin/HbUtils.h"
+
+#include <optional>
+#include <string>
+
+namespace minikin {
+
+// FontFileParser provides various parser logic for OpenType font file.
+class FontFileParser {
+public:
+ // This class does not take an ownership of buffer. Caller must free it.
+ FontFileParser(const void* buffer, size_t size, uint32_t index);
+ explicit FontFileParser(const HbFaceUniquePtr& face);
+ explicit FontFileParser(const HbFontUniquePtr& font);
+
+ virtual ~FontFileParser();
+
+ std::optional<uint32_t> getFontRevision() const;
+ std::optional<std::string> getPostScriptName() const;
+ std::optional<bool> isPostScriptType1Font() const;
+
+protected: // protected for testing purposes.
+ static bool analyzeFontRevision(const uint8_t* head_data, size_t head_size, uint32_t* out);
+ static bool checkPSName(const std::string& psName);
+
+private:
+ HbFaceUniquePtr mFace;
+
+ static HbFaceUniquePtr makeHbFace(const void* buffer, size_t size, uint32_t index);
+};
+
+} // namespace minikin
+
+#endif // MINIKIN_FONT_FILE_PARSER_H
diff --git a/include/minikin/FontStyle.h b/include/minikin/FontStyle.h
index 73cf427..51e4ad8 100644
--- a/include/minikin/FontStyle.h
+++ b/include/minikin/FontStyle.h
@@ -17,6 +17,8 @@
#ifndef MINIKIN_FONT_STYLE_H
#define MINIKIN_FONT_STYLE_H
+#include <minikin/Buffer.h>
+
namespace minikin {
// FontStyle represents style information.
@@ -46,6 +48,15 @@
constexpr FontStyle(Weight weight, Slant slant)
: FontStyle(static_cast<uint16_t>(weight), slant) {}
constexpr FontStyle(uint16_t weight, Slant slant) : mWeight(weight), mSlant(slant) {}
+ explicit FontStyle(BufferReader* reader) {
+ mWeight = reader->read<uint16_t>();
+ mSlant = static_cast<Slant>(reader->read<uint8_t>());
+ }
+
+ void writeTo(BufferWriter* writer) const {
+ writer->write<uint16_t>(mWeight);
+ writer->write<uint8_t>(static_cast<uint8_t>(mSlant));
+ }
constexpr uint16_t weight() const { return mWeight; }
constexpr Slant slant() const { return mSlant; }
diff --git a/include/minikin/FontVariation.h b/include/minikin/FontVariation.h
index 0c38d6a..e0567c1 100644
--- a/include/minikin/FontVariation.h
+++ b/include/minikin/FontVariation.h
@@ -24,6 +24,7 @@
typedef uint32_t AxisTag;
struct FontVariation {
+ FontVariation() = default;
FontVariation(AxisTag axisTag, float value) : axisTag(axisTag), value(value) {}
AxisTag axisTag;
float value;
diff --git a/include/minikin/Hasher.h b/include/minikin/Hasher.h
index 8a79b61..4a76b29 100644
--- a/include/minikin/Hasher.h
+++ b/include/minikin/Hasher.h
@@ -37,6 +37,26 @@
return *this;
}
+ inline Hasher& update(int32_t data) {
+ update(static_cast<uint32_t>(data));
+ return *this;
+ }
+
+ inline Hasher& update(uint64_t data) {
+ update(static_cast<uint32_t>(data));
+ update(static_cast<uint32_t>(data >> 32));
+ return *this;
+ }
+
+ inline Hasher& update(float data) {
+ union {
+ float f;
+ uint32_t i;
+ } bits;
+ bits.f = data;
+ return update(bits.i);
+ }
+
inline Hasher& updateShorts(const uint16_t* data, uint32_t length) {
update(length);
uint32_t i;
diff --git a/include/minikin/Layout.h b/include/minikin/Layout.h
index 19f3109..388a7a7 100644
--- a/include/minikin/Layout.h
+++ b/include/minikin/Layout.h
@@ -84,7 +84,8 @@
// public accessors
size_t nGlyphs() const { return mGlyphs.size(); }
- const MinikinFont* getFont(int i) const { return mGlyphs[i].font.font->typeface().get(); }
+ const Font* getFont(int i) const { return mGlyphs[i].font.font.get(); }
+ const std::shared_ptr<Font>& getFontRef(int i) const { return mGlyphs[i].font.font; }
FontFakery getFakery(int i) const { return mGlyphs[i].font.fakery; }
unsigned int getGlyphId(int i) const { return mGlyphs[i].glyph_id; }
float getX(int i) const { return mGlyphs[i].x; }
@@ -92,8 +93,6 @@
float getAdvance() const { return mAdvance; }
float getCharAdvance(size_t i) const { return mAdvances[i]; }
const std::vector<float>& getAdvances() const { return mAdvances; }
- void getBounds(MinikinRect* rect) const { rect->set(mBounds); }
- const MinikinRect& getBounds() const { return mBounds; }
// Purge all caches, useful in low memory conditions
static void purgeCaches();
@@ -135,7 +134,6 @@
std::vector<float> mAdvances;
float mAdvance;
- MinikinRect mBounds;
};
} // namespace minikin
diff --git a/include/minikin/LayoutCache.h b/include/minikin/LayoutCache.h
index ee51f11..a1cc34a 100644
--- a/include/minikin/LayoutCache.h
+++ b/include/minikin/LayoutCache.h
@@ -83,9 +83,9 @@
private:
const uint16_t* mChars;
- size_t mNchars;
- size_t mStart;
- size_t mCount;
+ uint32_t mNchars;
+ uint32_t mStart;
+ uint32_t mCount;
uint32_t mId; // for the font collection
FontStyle mStyle;
float mSize;
diff --git a/include/minikin/LayoutCore.h b/include/minikin/LayoutCore.h
index 852b985..cade517 100644
--- a/include/minikin/LayoutCore.h
+++ b/include/minikin/LayoutCore.h
@@ -49,11 +49,10 @@
// Low level accessors.
const std::vector<uint8_t>& fontIndices() const { return mFontIndices; }
- const std::vector<uint32_t> glyphIds() const { return mGlyphIds; }
- const std::vector<Point> points() const { return mPoints; }
- const std::vector<float> advances() const { return mAdvances; }
+ const std::vector<uint32_t>& glyphIds() const { return mGlyphIds; }
+ const std::vector<Point>& points() const { return mPoints; }
+ const std::vector<float>& advances() const { return mAdvances; }
float advance() const { return mAdvance; }
- const MinikinRect& bounds() const { return mBounds; }
const MinikinExtent& extent() const { return mExtent; }
const std::vector<FakedFont>& fonts() const { return mFonts; }
@@ -79,7 +78,6 @@
std::vector<float> mAdvances; // per code units
float mAdvance;
- MinikinRect mBounds;
MinikinExtent mExtent;
std::vector<FakedFont> mFonts;
diff --git a/include/minikin/LineBreaker.h b/include/minikin/LineBreaker.h
index 3410339..5d3e752 100644
--- a/include/minikin/LineBreaker.h
+++ b/include/minikin/LineBreaker.h
@@ -62,6 +62,9 @@
return mStops[i];
}
}
+ if (mTabWidth == 0) {
+ return 0;
+ }
return floor(widthSoFar / mTabWidth + 1) * mTabWidth;
}
diff --git a/include/minikin/LocaleList.h b/include/minikin/LocaleList.h
index bfc26c7..d173a46 100644
--- a/include/minikin/LocaleList.h
+++ b/include/minikin/LocaleList.h
@@ -21,11 +21,17 @@
namespace minikin {
+// A special ID for the empty locale list.
+// This value must be 0 since the empty locale list is inserted into mLocaleLists by default.
+const static uint32_t kEmptyLocaleListId = 0;
+
// Looks up a locale list from an internal cache and returns its ID.
// If the passed locale list is not in the cache, registers it and returns newly assigned ID.
// TODO: Introduce LocaleId type.
uint32_t registerLocaleList(const std::string& locales);
+std::string getLocaleString(uint32_t id);
+
} // namespace minikin
#endif // MINIKIN_LOCALE_H
diff --git a/include/minikin/Measurement.h b/include/minikin/Measurement.h
index c8b97d1..d0aaa51 100644
--- a/include/minikin/Measurement.h
+++ b/include/minikin/Measurement.h
@@ -20,6 +20,8 @@
#include <cstddef>
#include <cstdint>
+#include <minikin/Layout.h>
+
namespace minikin {
float getRunAdvance(const float* advances, const uint16_t* buf, size_t start, size_t count,
@@ -28,6 +30,10 @@
size_t getOffsetForAdvance(const float* advances, const uint16_t* buf, size_t start, size_t count,
float advance);
+void getBounds(const U16StringPiece& str, const Range& range, Bidi bidiFlags,
+ const MinikinPaint& paint, StartHyphenEdit startHyphen, EndHyphenEdit endHyphen,
+ MinikinRect* out);
+
} // namespace minikin
#endif // MINIKIN_MEASUREMENT_H
diff --git a/include/minikin/MinikinFont.h b/include/minikin/MinikinFont.h
index a5ba074..4d3ba9c 100644
--- a/include/minikin/MinikinFont.h
+++ b/include/minikin/MinikinFont.h
@@ -34,7 +34,7 @@
// multiple actual implementations of fonts.
class MinikinFont {
public:
- explicit MinikinFont(int32_t uniqueId) : mUniqueId(uniqueId) {}
+ MinikinFont() {}
virtual ~MinikinFont() {}
@@ -54,6 +54,9 @@
virtual void GetFontExtent(MinikinExtent* extent, const MinikinPaint& paint,
const FontFakery& fakery) const = 0;
+ // Returns the font path or an empty string.
+ virtual const std::string& GetFontPath() const = 0;
+
// Override if font can provide access to raw data
virtual const void* GetFontData() const { return nullptr; }
@@ -64,6 +67,8 @@
// Returns index within OpenType collection
virtual int GetFontIndex() const { return 0; }
+ virtual int GetSourceId() const { return 0; }
+
virtual const std::vector<minikin::FontVariation>& GetAxes() const = 0;
virtual std::shared_ptr<MinikinFont> createFontWithVariation(
@@ -74,11 +79,6 @@
static uint32_t MakeTag(char c1, char c2, char c3, char c4) {
return ((uint32_t)c1 << 24) | ((uint32_t)c2 << 16) | ((uint32_t)c3 << 8) | (uint32_t)c4;
}
-
- int32_t GetUniqueId() const { return mUniqueId; }
-
-private:
- const int32_t mUniqueId;
};
} // namespace minikin
diff --git a/include/minikin/MinikinRect.h b/include/minikin/MinikinRect.h
index 6a3d88b..38c2180 100644
--- a/include/minikin/MinikinRect.h
+++ b/include/minikin/MinikinRect.h
@@ -28,6 +28,7 @@
bool operator==(const MinikinRect& o) const {
return mLeft == o.mLeft && mTop == o.mTop && mRight == o.mRight && mBottom == o.mBottom;
}
+ bool operator!=(const MinikinRect& o) const { return !(*this == o); }
float mLeft;
float mTop;
float mRight;
diff --git a/include/minikin/SparseBitSet.h b/include/minikin/SparseBitSet.h
index 9ccef12..3034243 100644
--- a/include/minikin/SparseBitSet.h
+++ b/include/minikin/SparseBitSet.h
@@ -17,6 +17,7 @@
#ifndef MINIKIN_SPARSE_BIT_SET_H
#define MINIKIN_SPARSE_BIT_SET_H
+#include <minikin/Buffer.h>
#include <sys/types.h>
#include <cstdint>
#include <memory>
@@ -42,9 +43,13 @@
initFromRanges(ranges, nRanges);
}
+ explicit SparseBitSet(BufferReader* reader) : SparseBitSet() { initFromBuffer(reader); }
+
SparseBitSet(SparseBitSet&&) = default;
SparseBitSet& operator=(SparseBitSet&&) = default;
+ void writeTo(BufferWriter* writer) const;
+
// Determine whether the value is included in the set
bool get(uint32_t ch) const {
if (ch >= mMaxVal) return false;
@@ -64,6 +69,7 @@
private:
void initFromRanges(const uint32_t* ranges, size_t nRanges);
+ void initFromBuffer(BufferReader* reader);
static const uint32_t kMaximumCapacity = 0xFFFFFF;
static const int kLogValuesPerPage = 8;
@@ -81,11 +87,16 @@
static int CountLeadingZeros(element x);
uint32_t mMaxVal;
-
- std::unique_ptr<uint16_t[]> mIndices;
- std::unique_ptr<element[]> mBitmaps;
+ uint32_t mIndicesCount;
+ const uint16_t* mIndices;
+ uint32_t mBitmapsCount;
+ const element* mBitmaps;
uint16_t mZeroPageIndex;
+ // Owns allocated memory if this class is created from ranges, otherwise these are nullptr.
+ std::unique_ptr<uint16_t[]> mOwnedIndices;
+ std::unique_ptr<element[]> mOwnedBitmaps;
+
// Forbid copy and assign.
SparseBitSet(const SparseBitSet&) = delete;
void operator=(const SparseBitSet&) = delete;
diff --git a/include/minikin/SystemFonts.h b/include/minikin/SystemFonts.h
index 4108215..cf4ab75 100644
--- a/include/minikin/SystemFonts.h
+++ b/include/minikin/SystemFonts.h
@@ -19,6 +19,7 @@
#include <map>
#include <memory>
+#include <mutex>
#include <string>
#include "minikin/FontCollection.h"
@@ -33,39 +34,78 @@
return getInstance().findFontCollectionInternal(familyName);
}
- // Do not call this function outside Zygote process.
static void registerFallback(const std::string& familyName,
const std::shared_ptr<FontCollection>& fc) {
return getInstance().registerFallbackInternal(familyName, fc);
}
- // Do not call this function outside Zygote process.
static void registerDefault(const std::shared_ptr<FontCollection>& fc) {
return getInstance().registerDefaultInternal(fc);
}
+ using FontMapDeleter = std::function<void()>;
+
+ static void addFontMap(std::shared_ptr<FontCollection>&& collections) {
+ return getInstance().addFontMapInternal(std::move(collections));
+ }
+
+ // This obtains a mutex inside, so do not call this method inside callback.
+ static void getFontMap(
+ std::function<void(const std::vector<std::shared_ptr<FontCollection>>&)> func) {
+ return getInstance().getFontMapInternal(func);
+ }
+
+ static void getFontSet(std::function<void(const std::vector<std::shared_ptr<Font>>&)> func) {
+ return getInstance().getFontSetInternal(func);
+ }
+
protected:
// Visible for testing purposes.
SystemFonts() {}
virtual ~SystemFonts() {}
- std::shared_ptr<FontCollection> findFontCollectionInternal(const std::string& familyName) const;
+ std::shared_ptr<FontCollection> findFontCollectionInternal(const std::string& familyName);
void registerFallbackInternal(const std::string& familyName,
const std::shared_ptr<FontCollection>& fc) {
- mSystemFallbacks.insert(std::make_pair(familyName, fc));
+ std::lock_guard<std::mutex> lock(mMutex);
+ mSystemFallbacks[familyName] = fc;
}
void registerDefaultInternal(const std::shared_ptr<FontCollection>& fc) {
+ std::lock_guard<std::mutex> lock(mMutex);
mDefaultFallback = fc;
}
+ void addFontMapInternal(std::shared_ptr<FontCollection>&& collections) {
+ std::lock_guard<std::mutex> lock(mMutex);
+ mCollections.emplace_back(std::move(collections));
+ }
+
+ void getFontMapInternal(
+ std::function<void(const std::vector<std::shared_ptr<FontCollection>>&)> func) {
+ std::lock_guard<std::mutex> lock(mMutex);
+ func(mCollections);
+ }
+
+ void getFontSetInternal(std::function<void(const std::vector<std::shared_ptr<Font>>&)> func) {
+ std::lock_guard<std::mutex> lock(mMutex);
+ if (!mFonts) {
+ buildFontSetLocked();
+ }
+ func(mFonts.value());
+ }
+
private:
static SystemFonts& getInstance();
- // There is no mutex guard here since registerFallback is designed to be
- // called only in Zygote.
- std::map<std::string, std::shared_ptr<FontCollection>> mSystemFallbacks;
- std::shared_ptr<FontCollection> mDefaultFallback;
+ void buildFontSetLocked() EXCLUSIVE_LOCKS_REQUIRED(mMutex);
+
+ std::map<std::string, std::shared_ptr<FontCollection>> mSystemFallbacks GUARDED_BY(mMutex);
+ std::shared_ptr<FontCollection> mDefaultFallback GUARDED_BY(mMutex);
+ std::vector<std::shared_ptr<FontCollection>> mCollections GUARDED_BY(mMutex);
+ std::optional<std::vector<std::shared_ptr<Font>>> mFonts GUARDED_BY(mMutex);
+
+ std::mutex mMutex;
};
} // namespace minikin
diff --git a/libs/minikin/Android.bp b/libs/minikin/Android.bp
index 931c8d0..8356ea4 100644
--- a/libs/minikin/Android.bp
+++ b/libs/minikin/Android.bp
@@ -28,10 +28,13 @@
host_supported: true,
srcs: [
"BidiUtils.cpp",
+ "BoundsCache.cpp",
"CmapCoverage.cpp",
"Emoji.cpp",
+ "Font.cpp",
"FontCollection.cpp",
"FontFamily.cpp",
+ "FontFileParser.cpp",
"FontUtils.cpp",
"GraphemeBreak.cpp",
"GreedyLineBreaker.cpp",
diff --git a/libs/minikin/BoundsCache.cpp b/libs/minikin/BoundsCache.cpp
new file mode 100644
index 0000000..1edc853
--- /dev/null
+++ b/libs/minikin/BoundsCache.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2020 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.
+ */
+
+#include "minikin/BoundsCache.h"
+
+namespace minikin {
+
+void ValueExtractor::operator()(const LayoutPiece& layoutPiece, const MinikinPaint& paint) {
+ value.reset(new BoundsValue);
+ value->rect = BoundsCache::getBounds(layoutPiece, paint);
+ value->advance = layoutPiece.advance();
+}
+
+// static
+MinikinRect BoundsCache::getBounds(const LayoutPiece& layoutPiece, const MinikinPaint& paint) {
+ MinikinRect pieceBounds;
+ MinikinRect tmpRect;
+ for (uint32_t i = 0; i < layoutPiece.glyphCount(); ++i) {
+ const FakedFont& font = layoutPiece.fontAt(i);
+ const Point& point = layoutPiece.pointAt(i);
+
+ MinikinFont* minikinFont = font.font->typeface().get();
+ minikinFont->GetBounds(&tmpRect, layoutPiece.glyphIdAt(i), paint, font.fakery);
+ tmpRect.offset(point.x, point.y);
+ pieceBounds.join(tmpRect);
+ }
+ return pieceBounds;
+}
+
+} // namespace minikin
diff --git a/libs/minikin/Font.cpp b/libs/minikin/Font.cpp
new file mode 100644
index 0000000..c2e74b7
--- /dev/null
+++ b/libs/minikin/Font.cpp
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2021 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 LOG_TAG "Minikin"
+
+#include "minikin/Font.h"
+
+#include <vector>
+
+#include <hb-ot.h>
+#include <hb.h>
+#include <log/log.h>
+
+#include "minikin/HbUtils.h"
+#include "minikin/MinikinFont.h"
+
+#include "FontUtils.h"
+#include "MinikinInternal.h"
+
+namespace minikin {
+
+std::shared_ptr<Font> Font::Builder::build() {
+ if (mIsWeightSet && mIsSlantSet) {
+ // No need to read OS/2 header of the font file.
+ return std::shared_ptr<Font>(new Font(std::move(mTypeface), FontStyle(mWeight, mSlant),
+ prepareFont(mTypeface), mLocaleListId));
+ }
+
+ HbFontUniquePtr font = prepareFont(mTypeface);
+ FontStyle styleFromFont = analyzeStyle(font);
+ if (!mIsWeightSet) {
+ mWeight = styleFromFont.weight();
+ }
+ if (!mIsSlantSet) {
+ mSlant = styleFromFont.slant();
+ }
+ return std::shared_ptr<Font>(new Font(std::move(mTypeface), FontStyle(mWeight, mSlant),
+ std::move(font), mLocaleListId));
+}
+
+const std::shared_ptr<MinikinFont>& Font::typeface() const {
+ std::lock_guard lock(mTypefaceMutex);
+ if (mTypeface) return mTypeface;
+ initTypefaceLocked();
+ return mTypeface;
+}
+
+const HbFontUniquePtr& Font::baseFont() const {
+ std::lock_guard lock(mTypefaceMutex);
+ if (mBaseFont) return mBaseFont;
+ initTypefaceLocked();
+ mBaseFont = prepareFont(mTypeface);
+ return mBaseFont;
+}
+
+void Font::initTypefaceLocked() const {
+ if (mTypeface) return;
+ MINIKIN_ASSERT(mTypefaceLoader, "mTypefaceLoader should not be empty when mTypeface is null");
+ mTypeface = mTypefaceLoader(mTypefaceMetadataReader);
+}
+
+// static
+HbFontUniquePtr Font::prepareFont(const std::shared_ptr<MinikinFont>& typeface) {
+ const char* buf = reinterpret_cast<const char*>(typeface->GetFontData());
+ size_t size = typeface->GetFontSize();
+ uint32_t ttcIndex = typeface->GetFontIndex();
+
+ HbBlobUniquePtr blob(hb_blob_create(buf, size, HB_MEMORY_MODE_READONLY, nullptr, nullptr));
+ HbFaceUniquePtr face(hb_face_create(blob.get(), ttcIndex));
+ HbFontUniquePtr parent(hb_font_create(face.get()));
+ hb_ot_font_set_funcs(parent.get());
+
+ uint32_t upem = hb_face_get_upem(face.get());
+ hb_font_set_scale(parent.get(), upem, upem);
+
+ HbFontUniquePtr font(hb_font_create_sub_font(parent.get()));
+ std::vector<hb_variation_t> variations;
+ variations.reserve(typeface->GetAxes().size());
+ for (const FontVariation& variation : typeface->GetAxes()) {
+ variations.push_back({variation.axisTag, variation.value});
+ }
+ hb_font_set_variations(font.get(), variations.data(), variations.size());
+ return font;
+}
+
+// static
+FontStyle Font::analyzeStyle(const HbFontUniquePtr& font) {
+ HbBlob os2Table(font, MinikinFont::MakeTag('O', 'S', '/', '2'));
+ if (!os2Table) {
+ return FontStyle();
+ }
+
+ int weight;
+ bool italic;
+ if (!::minikin::analyzeStyle(os2Table.get(), os2Table.size(), &weight, &italic)) {
+ return FontStyle();
+ }
+ // TODO: Update weight/italic based on fvar value.
+ return FontStyle(static_cast<uint16_t>(weight), static_cast<FontStyle::Slant>(italic));
+}
+
+std::unordered_set<AxisTag> Font::getSupportedAxes() const {
+ HbBlob fvarTable(baseFont(), MinikinFont::MakeTag('f', 'v', 'a', 'r'));
+ if (!fvarTable) {
+ return std::unordered_set<AxisTag>();
+ }
+ std::unordered_set<AxisTag> supportedAxes;
+ analyzeAxes(fvarTable.get(), fvarTable.size(), &supportedAxes);
+ return supportedAxes;
+}
+
+} // namespace minikin
diff --git a/libs/minikin/FontCollection.cpp b/libs/minikin/FontCollection.cpp
index 6cbabea..9e4dd3b 100644
--- a/libs/minikin/FontCollection.cpp
+++ b/libs/minikin/FontCollection.cpp
@@ -24,6 +24,7 @@
#include <unicode/unorm2.h>
#include "minikin/Emoji.h"
+#include "minikin/FontFileParser.h"
#include "Locale.h"
#include "LocaleListCache.h"
@@ -43,6 +44,23 @@
static std::atomic<uint32_t> gNextCollectionId = {0};
+namespace {
+
+uint32_t getGlyphCount(U16StringPiece text, uint32_t start, uint32_t end,
+ const HbFontUniquePtr& font) {
+ HbBufferUniquePtr buffer(hb_buffer_create());
+ hb_buffer_set_direction(buffer.get(), HB_DIRECTION_LTR);
+ hb_buffer_add_utf16(buffer.get(), text.data() + start, end - start, 0, end - start);
+ hb_buffer_guess_segment_properties(buffer.get());
+
+ unsigned int numGlyphs = -1;
+ hb_shape(font.get(), buffer.get(), nullptr, 0);
+ hb_buffer_get_glyph_infos(buffer.get(), &numGlyphs);
+ return numGlyphs;
+}
+
+} // namespace
+
FontCollection::FontCollection(std::shared_ptr<FontFamily>&& typeface) : mMaxChar(0) {
std::vector<std::shared_ptr<FontFamily>> typefaces;
typefaces.push_back(typeface);
@@ -83,24 +101,91 @@
// A font can have a glyph for a base code point and variation selector pair but no glyph for
// the base code point without variation selector. The family won't be listed in the range in
// this case.
+ mOwnedRanges = std::make_unique<Range[]>(nPages);
+ mRanges = mOwnedRanges.get();
+ mRangesCount = nPages;
for (size_t i = 0; i < nPages; i++) {
- Range dummy;
- mRanges.push_back(dummy);
- Range* range = &mRanges.back();
- range->start = mFamilyVec.size();
+ Range* range = &mOwnedRanges[i];
+ range->start = mOwnedFamilyVec.size();
for (size_t j = 0; j < nTypefaces; j++) {
if (lastChar[j] < (i + 1) << kLogCharsPerPage) {
const std::shared_ptr<FontFamily>& family = mFamilies[j];
- mFamilyVec.push_back(static_cast<uint8_t>(j));
+ mOwnedFamilyVec.push_back(static_cast<uint8_t>(j));
uint32_t nextChar = family->getCoverage().nextSetBit((i + 1) << kLogCharsPerPage);
lastChar[j] = nextChar;
}
}
- range->end = mFamilyVec.size();
+ range->end = mOwnedFamilyVec.size();
}
// See the comment in Range for more details.
- LOG_ALWAYS_FATAL_IF(mFamilyVec.size() >= 0xFFFF,
+ LOG_ALWAYS_FATAL_IF(mOwnedFamilyVec.size() >= 0xFFFF,
"Exceeded the maximum indexable cmap coverage.");
+ mFamilyVec = mOwnedFamilyVec.data();
+ mFamilyVecCount = mOwnedFamilyVec.size();
+}
+
+FontCollection::FontCollection(BufferReader* reader,
+ const std::vector<std::shared_ptr<FontFamily>>& families) {
+ mId = gNextCollectionId++;
+ mMaxChar = reader->read<uint32_t>();
+ uint32_t familiesCount = reader->read<uint32_t>();
+ mFamilies.reserve(familiesCount);
+ for (uint32_t i = 0; i < familiesCount; i++) {
+ uint32_t index = reader->read<uint32_t>();
+ if (index >= families.size()) {
+ ALOGE("Invalid FontFamily index: %zu", (size_t)index);
+ } else {
+ mFamilies.push_back(families[index]);
+ if (families[index]->hasVSTable()) {
+ mVSFamilyVec.push_back(families[index]);
+ }
+ }
+ }
+ // Range is two packed uint16_t
+ static_assert(sizeof(Range) == 4);
+ std::tie(mRanges, mRangesCount) = reader->readArray<Range>();
+ std::tie(mFamilyVec, mFamilyVecCount) = reader->readArray<uint8_t>();
+ const auto& [axesPtr, axesCount] = reader->readArray<AxisTag>();
+ mSupportedAxes.insert(axesPtr, axesPtr + axesCount);
+}
+
+void FontCollection::writeTo(BufferWriter* writer,
+ const std::unordered_map<std::shared_ptr<FontFamily>, uint32_t>&
+ fontFamilyToIndexMap) const {
+ writer->write<uint32_t>(mMaxChar);
+ writer->write<uint32_t>(mFamilies.size());
+ for (const std::shared_ptr<FontFamily>& fontFamily : mFamilies) {
+ auto it = fontFamilyToIndexMap.find(fontFamily);
+ if (it == fontFamilyToIndexMap.end()) {
+ ALOGE("fontFamily not found in fontFamilyToIndexMap");
+ writer->write<uint32_t>(-1);
+ } else {
+ writer->write<uint32_t>(it->second);
+ }
+ }
+ writer->writeArray<Range>(mRanges, mRangesCount);
+ writer->writeArray<uint8_t>(mFamilyVec, mFamilyVecCount);
+ // No need to serialize mVSFamilyVec as it can be reconstructed easily from mFamilies.
+ std::vector<AxisTag> axes(mSupportedAxes.begin(), mSupportedAxes.end());
+ // Sort axes to be deterministic.
+ std::sort(axes.begin(), axes.end());
+ writer->writeArray<AxisTag>(axes.data(), axes.size());
+}
+
+// static
+void FontCollection::collectAllFontFamilies(
+ const std::vector<std::shared_ptr<FontCollection>>& fontCollections,
+ std::vector<std::shared_ptr<FontFamily>>* outAllFontFamilies,
+ std::unordered_map<std::shared_ptr<FontFamily>, uint32_t>* outFontFamilyToIndexMap) {
+ for (const auto& fontCollection : fontCollections) {
+ for (const std::shared_ptr<FontFamily>& fontFamily : fontCollection->mFamilies) {
+ bool inserted =
+ outFontFamilyToIndexMap->emplace(fontFamily, outAllFontFamilies->size()).second;
+ if (inserted) {
+ outAllFontFamilies->push_back(fontFamily);
+ }
+ }
+ }
}
// Special scores for the font fallback.
@@ -249,11 +334,11 @@
// 2. Calculate a score for the font family. See comments in calcFamilyScore for the detail.
// 3. Highest score wins, with ties resolved to the first font.
// This method never returns nullptr.
-const std::shared_ptr<FontFamily>& FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs,
- uint32_t localeListId,
- FamilyVariant variant) const {
+FontCollection::FamilyMatchResult FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs,
+ uint32_t localeListId,
+ FamilyVariant variant) const {
if (ch >= mMaxChar) {
- return mFamilies[0];
+ return FamilyMatchResult::Builder().add(0).build();
}
Range range = mRanges[ch >> kLogCharsPerPage];
@@ -262,23 +347,27 @@
range = {0, static_cast<uint16_t>(mFamilies.size())};
}
- int bestFamilyIndex = -1;
uint32_t bestScore = kUnsupportedFontScore;
+ FamilyMatchResult::Builder builder;
+
for (size_t i = range.start; i < range.end; i++) {
- const std::shared_ptr<FontFamily>& family =
- vs == 0 ? mFamilies[mFamilyVec[i]] : mFamilies[i];
+ const uint8_t familyIndex = vs == 0 ? mFamilyVec[i] : i;
+ const std::shared_ptr<FontFamily>& family = mFamilies[familyIndex];
const uint32_t score = calcFamilyScore(ch, vs, variant, localeListId, family);
if (score == kFirstFontScore) {
// If the first font family supports the given character or variation sequence, always
// use it.
- return family;
+ return builder.add(familyIndex).build();
}
- if (score > bestScore) {
- bestScore = score;
- bestFamilyIndex = i;
+ if (score != kUnsupportedFontScore && score >= bestScore) {
+ if (score > bestScore) {
+ builder.reset();
+ bestScore = score;
+ }
+ builder.add(familyIndex);
}
}
- if (bestFamilyIndex == -1) {
+ if (builder.empty()) {
UErrorCode errorCode = U_ZERO_ERROR;
const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode);
if (U_SUCCESS(errorCode)) {
@@ -290,9 +379,9 @@
return getFamilyForChar(ch, vs, localeListId, variant);
}
}
- return mFamilies[0];
+ return FamilyMatchResult::Builder().add(0).build();
}
- return vs == 0 ? mFamilies[mFamilyVec[bestFamilyIndex]] : mFamilies[bestFamilyIndex];
+ return builder.build();
}
// Characters where we want to continue using existing font run for (or stick to the next run if
@@ -312,7 +401,7 @@
// 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[] = {
+static const uint32_t stickyAllowlist[] = {
'!', ',', '-', '.', ':', ';', '?',
0x00A0, // NBSP
0x2010, // HYPHEN
@@ -323,9 +412,9 @@
0x2695, // STAFF_OF_AESCULAPIUS
};
-static bool isStickyWhitelisted(uint32_t c) {
- for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) {
- if (stickyWhitelist[i] == c) return true;
+static bool isStickyAllowlisted(uint32_t c) {
+ for (size_t i = 0; i < sizeof(stickyAllowlist) / sizeof(stickyAllowlist[0]); i++) {
+ if (stickyAllowlist[i] == c) return true;
}
return false;
}
@@ -368,22 +457,45 @@
constexpr uint32_t REPLACEMENT_CHARACTER = 0xFFFD;
-std::vector<FontCollection::Run> FontCollection::itemize(U16StringPiece text, FontStyle style,
+FontCollection::FamilyMatchResult FontCollection::FamilyMatchResult::intersect(
+ FontCollection::FamilyMatchResult l, FontCollection::FamilyMatchResult r) {
+ if (l == r) {
+ return l;
+ }
+
+ uint32_t li = 0;
+ uint32_t ri = 0;
+ FamilyMatchResult::Builder b;
+ while (li < l.size() && ri < r.size()) {
+ if (l[li] < r[ri]) {
+ li++;
+ } else if (l[li] > r[ri]) {
+ ri++;
+ } else { // l[li] == r[ri]
+ b.add(l[li]);
+ li++;
+ ri++;
+ }
+ }
+ return b.build();
+}
+
+std::vector<FontCollection::Run> FontCollection::itemize(U16StringPiece text, FontStyle,
uint32_t localeListId,
FamilyVariant familyVariant,
uint32_t runMax) const {
const uint16_t* string = text.data();
const uint32_t string_size = text.size();
- std::vector<Run> result;
- const FontFamily* lastFamily = nullptr;
- Run* run = nullptr;
+ FamilyMatchResult lastFamilyIndices = FamilyMatchResult();
if (string_size == 0) {
- return result;
+ return std::vector<Run>();
}
const uint32_t kEndOfString = 0xFFFFFFFF;
+ std::vector<Run> result;
+ Run* run = nullptr;
uint32_t nextCh = 0;
uint32_t prevCh = 0;
@@ -411,15 +523,44 @@
if (doesNotNeedFontSupport(ch)) {
// Always continue if the character is a format character not needed to be in the font.
shouldContinueRun = true;
- } else if (lastFamily != nullptr && (isStickyWhitelisted(ch) || isCombining(ch))) {
+ } else if (!lastFamilyIndices.empty() && (isStickyAllowlisted(ch) || isCombining(ch))) {
// Continue using existing font as long as it has coverage and is whitelisted.
- shouldContinueRun = lastFamily->getCoverage().get(ch);
+
+ const std::shared_ptr<FontFamily>& lastFamily = mFamilies[lastFamilyIndices[0]];
+ if (lastFamily->isColorEmojiFamily()) {
+ // If the last family is color emoji font, find the longest family.
+ shouldContinueRun = false;
+ for (uint8_t ix : lastFamilyIndices) {
+ shouldContinueRun |= mFamilies[ix]->getCoverage().get(ch);
+ }
+ } else {
+ shouldContinueRun = lastFamily->getCoverage().get(ch);
+ }
}
if (!shouldContinueRun) {
- const std::shared_ptr<FontFamily>& family = getFamilyForChar(
+ FamilyMatchResult familyIndices = getFamilyForChar(
ch, isVariationSelector(nextCh) ? nextCh : 0, localeListId, familyVariant);
- if (utf16Pos == 0 || family.get() != lastFamily) {
+ bool breakRun;
+ if (utf16Pos == 0 || lastFamilyIndices.empty()) {
+ breakRun = true;
+ } else {
+ const std::shared_ptr<FontFamily>& lastFamily = mFamilies[lastFamilyIndices[0]];
+ if (lastFamily->isColorEmojiFamily()) {
+ FamilyMatchResult intersection =
+ FamilyMatchResult::intersect(familyIndices, lastFamilyIndices);
+ if (intersection.empty()) {
+ breakRun = true; // None of last family can draw the given char.
+ } else {
+ lastFamilyIndices = intersection;
+ breakRun = false;
+ }
+ } else {
+ breakRun = familyIndices[0] != lastFamilyIndices[0];
+ }
+ }
+
+ if (breakRun) {
size_t start = utf16Pos;
// Workaround for combining marks and emoji modifiers until we implement
// per-cluster font selection: if a combining mark or an emoji modifier is found in
@@ -427,27 +568,31 @@
// character to the new run. U+20E3 COMBINING ENCLOSING KEYCAP, used in emoji, is
// handled properly by this since it's a combining mark too.
if (utf16Pos != 0 &&
- (isCombining(ch) || (isEmojiModifier(ch) && isEmojiBase(prevCh))) &&
- family != nullptr && family->getCoverage().get(prevCh)) {
- const size_t prevChLength = U16_LENGTH(prevCh);
- if (run != nullptr) {
- run->end -= prevChLength;
- if (run->start == run->end) {
- result.pop_back();
+ (isCombining(ch) || (isEmojiModifier(ch) && isEmojiBase(prevCh)))) {
+ for (uint8_t ix : familyIndices) {
+ if (mFamilies[ix]->getCoverage().get(prevCh)) {
+ const size_t prevChLength = U16_LENGTH(prevCh);
+ if (run != nullptr) {
+ run->end -= prevChLength;
+ if (run->start == run->end) {
+ result.pop_back();
+ }
+ }
+ start -= prevChLength;
+ break;
}
}
- start -= prevChLength;
}
- if (lastFamily == nullptr) {
+ if (lastFamilyIndices.empty()) {
// This is the first family ever assigned. We are either seeing the very first
// character (which means start would already be zero), or we have only seen
// characters that don't need any font support (which means we need to adjust
// start to be 0 to include those characters).
start = 0;
}
- result.push_back({family->getClosestMatch(style), static_cast<int>(start), 0});
+ result.push_back({familyIndices, static_cast<int>(start), 0});
run = &result.back();
- lastFamily = family.get();
+ lastFamilyIndices = run->familyMatch;
}
}
prevCh = ch;
@@ -465,19 +610,42 @@
}
} while (nextCh != kEndOfString);
- if (lastFamily == nullptr) {
+ if (lastFamilyIndices.empty()) {
// No character needed any font support, so it doesn't really matter which font they end up
// getting displayed in. We put the whole string in one run, using the first font.
- result.push_back({mFamilies[0]->getClosestMatch(style), 0, static_cast<int>(string_size)});
+ result.push_back(
+ {FamilyMatchResult::Builder().add(0).build(), 0, static_cast<int>(string_size)});
}
if (result.size() > runMax) {
// The itemization has terminated since it reaches the runMax. Remove last unfinalized runs.
- result.resize(runMax);
+ return std::vector<Run>(result.begin(), result.begin() + runMax);
}
+
return result;
}
+FakedFont FontCollection::getBestFont(U16StringPiece text, const Run& run, FontStyle style) {
+ uint8_t bestIndex = 0;
+ uint32_t bestGlyphCount = 0xFFFFFFFF;
+
+ const std::shared_ptr<FontFamily>& family = mFamilies[run.familyMatch[0]];
+ if (family->isColorEmojiFamily() && run.familyMatch.size() > 1) {
+ for (size_t i = 0; i < run.familyMatch.size(); ++i) {
+ const std::shared_ptr<FontFamily>& family = mFamilies[run.familyMatch[i]];
+ const HbFontUniquePtr& font = family->getFont(0)->baseFont();
+ uint32_t glyphCount = getGlyphCount(text, run.start, run.end, font);
+ if (glyphCount < bestGlyphCount) {
+ bestIndex = run.familyMatch[i];
+ bestGlyphCount = glyphCount;
+ }
+ }
+ } else {
+ bestIndex = run.familyMatch[0];
+ }
+ return mFamilies[bestIndex]->getClosestMatch(style);
+}
+
FakedFont FontCollection::baseFontFaked(FontStyle style) {
return mFamilies[0]->getClosestMatch(style);
}
diff --git a/libs/minikin/FontFamily.cpp b/libs/minikin/FontFamily.cpp
index 85a5142..f1fd00a 100644
--- a/libs/minikin/FontFamily.cpp
+++ b/libs/minikin/FontFamily.cpp
@@ -18,11 +18,9 @@
#include "minikin/FontFamily.h"
-#include <cstdint>
+#include <algorithm>
#include <vector>
-#include <hb-ot.h>
-#include <hb.h>
#include <log/log.h>
#include "minikin/CmapCoverage.h"
@@ -37,82 +35,14 @@
namespace minikin {
-Font Font::Builder::build() {
- if (mIsWeightSet && mIsSlantSet) {
- // No need to read OS/2 header of the font file.
- return Font(std::move(mTypeface), FontStyle(mWeight, mSlant), prepareFont(mTypeface));
- }
-
- HbFontUniquePtr font = prepareFont(mTypeface);
- FontStyle styleFromFont = analyzeStyle(font);
- if (!mIsWeightSet) {
- mWeight = styleFromFont.weight();
- }
- if (!mIsSlantSet) {
- mSlant = styleFromFont.slant();
- }
- return Font(std::move(mTypeface), FontStyle(mWeight, mSlant), std::move(font));
-}
-
-// static
-HbFontUniquePtr Font::prepareFont(const std::shared_ptr<MinikinFont>& typeface) {
- const char* buf = reinterpret_cast<const char*>(typeface->GetFontData());
- size_t size = typeface->GetFontSize();
- uint32_t ttcIndex = typeface->GetFontIndex();
-
- HbBlobUniquePtr blob(hb_blob_create(buf, size, HB_MEMORY_MODE_READONLY, nullptr, nullptr));
- HbFaceUniquePtr face(hb_face_create(blob.get(), ttcIndex));
- HbFontUniquePtr parent(hb_font_create(face.get()));
- hb_ot_font_set_funcs(parent.get());
-
- uint32_t upem = hb_face_get_upem(face.get());
- hb_font_set_scale(parent.get(), upem, upem);
-
- HbFontUniquePtr font(hb_font_create_sub_font(parent.get()));
- std::vector<hb_variation_t> variations;
- variations.reserve(typeface->GetAxes().size());
- for (const FontVariation& variation : typeface->GetAxes()) {
- variations.push_back({variation.axisTag, variation.value});
- }
- hb_font_set_variations(font.get(), variations.data(), variations.size());
- return font;
-}
-
-// static
-FontStyle Font::analyzeStyle(const HbFontUniquePtr& font) {
- HbBlob os2Table(font, MinikinFont::MakeTag('O', 'S', '/', '2'));
- if (!os2Table) {
- return FontStyle();
- }
-
- int weight;
- bool italic;
- if (!::minikin::analyzeStyle(os2Table.get(), os2Table.size(), &weight, &italic)) {
- return FontStyle();
- }
- // TODO: Update weight/italic based on fvar value.
- return FontStyle(static_cast<uint16_t>(weight), static_cast<FontStyle::Slant>(italic));
-}
-
-std::unordered_set<AxisTag> Font::getSupportedAxes() const {
- HbBlob fvarTable(mBaseFont, MinikinFont::MakeTag('f', 'v', 'a', 'r'));
- if (!fvarTable) {
- return std::unordered_set<AxisTag>();
- }
- std::unordered_set<AxisTag> supportedAxes;
- analyzeAxes(fvarTable.get(), fvarTable.size(), &supportedAxes);
- return supportedAxes;
-}
-
-FontFamily::FontFamily(std::vector<Font>&& fonts)
+FontFamily::FontFamily(std::vector<std::shared_ptr<Font>>&& fonts)
: FontFamily(FamilyVariant::DEFAULT, std::move(fonts)) {}
-FontFamily::FontFamily(FamilyVariant variant, std::vector<Font>&& fonts)
- : FontFamily(LocaleListCache::kEmptyListId, variant, std::move(fonts),
- false /* isCustomFallback */) {}
+FontFamily::FontFamily(FamilyVariant variant, std::vector<std::shared_ptr<Font>>&& fonts)
+ : FontFamily(kEmptyLocaleListId, variant, std::move(fonts), false /* isCustomFallback */) {}
-FontFamily::FontFamily(uint32_t localeListId, FamilyVariant variant, std::vector<Font>&& fonts,
- bool isCustomFallback)
+FontFamily::FontFamily(uint32_t localeListId, FamilyVariant variant,
+ std::vector<std::shared_ptr<Font>>&& fonts, bool isCustomFallback)
: mLocaleListId(localeListId),
mVariant(variant),
mFonts(std::move(fonts)),
@@ -123,6 +53,83 @@
computeCoverage();
}
+FontFamily::FontFamily(uint32_t localeListId, FamilyVariant variant,
+ std::vector<std::shared_ptr<Font>>&& fonts,
+ std::unordered_set<AxisTag>&& supportedAxes, bool isColorEmoji,
+ bool isCustomFallback, SparseBitSet&& coverage,
+ std::vector<std::unique_ptr<SparseBitSet>>&& cmapFmt14Coverage)
+ : mLocaleListId(localeListId),
+ mVariant(variant),
+ mFonts(std::move(fonts)),
+ mSupportedAxes(std::move(supportedAxes)),
+ mIsColorEmoji(isColorEmoji),
+ mIsCustomFallback(isCustomFallback),
+ mCoverage(std::move(coverage)),
+ mCmapFmt14Coverage(std::move(cmapFmt14Coverage)) {}
+
+// Read fields other than mFonts, mLocaleList.
+// static
+std::shared_ptr<FontFamily> FontFamily::readFromInternal(BufferReader* reader,
+ std::vector<std::shared_ptr<Font>>&& fonts,
+ uint32_t localeListId) {
+ // FamilyVariant is uint8_t
+ static_assert(sizeof(FamilyVariant) == 1);
+ FamilyVariant variant = reader->read<FamilyVariant>();
+ // AxisTag is uint32_t
+ static_assert(sizeof(AxisTag) == 4);
+ const auto& [axesPtr, axesCount] = reader->readArray<AxisTag>();
+ std::unordered_set<AxisTag> supportedAxes(axesPtr, axesPtr + axesCount);
+ bool isColorEmoji = static_cast<bool>(reader->read<uint8_t>());
+ bool isCustomFallback = static_cast<bool>(reader->read<uint8_t>());
+ SparseBitSet coverage(reader);
+ // Read mCmapFmt14Coverage. As it can have null entries, it is stored in the buffer as a sparse
+ // array (size, non-null entry count, array of (index, entry)).
+ uint32_t cmapFmt14CoverageSize = reader->read<uint32_t>();
+ std::vector<std::unique_ptr<SparseBitSet>> cmapFmt14Coverage(cmapFmt14CoverageSize);
+ uint32_t cmapFmt14CoverageEntryCount = reader->read<uint32_t>();
+ for (uint32_t i = 0; i < cmapFmt14CoverageEntryCount; i++) {
+ uint32_t index = reader->read<uint32_t>();
+ cmapFmt14Coverage[index] = std::make_unique<SparseBitSet>(reader);
+ }
+ return std::shared_ptr<FontFamily>(new FontFamily(
+ localeListId, variant, std::move(fonts), std::move(supportedAxes), isColorEmoji,
+ isCustomFallback, std::move(coverage), std::move(cmapFmt14Coverage)));
+}
+
+// static
+uint32_t FontFamily::readLocaleListInternal(BufferReader* reader) {
+ return LocaleListCache::readFrom(reader);
+}
+
+// Write fields other than mFonts.
+void FontFamily::writeToInternal(BufferWriter* writer) const {
+ writer->write<FamilyVariant>(mVariant);
+ std::vector<AxisTag> axes(mSupportedAxes.begin(), mSupportedAxes.end());
+ // Sort axes to be deterministic.
+ std::sort(axes.begin(), axes.end());
+ writer->writeArray<AxisTag>(axes.data(), axes.size());
+ writer->write<uint8_t>(mIsColorEmoji);
+ writer->write<uint8_t>(mIsCustomFallback);
+ mCoverage.writeTo(writer);
+ // Write mCmapFmt14Coverage as a sparse array (size, non-null entry count,
+ // array of (index, entry))
+ writer->write<uint32_t>(mCmapFmt14Coverage.size());
+ uint32_t cmapFmt14CoverageEntryCount = 0;
+ for (const std::unique_ptr<SparseBitSet>& coverage : mCmapFmt14Coverage) {
+ if (coverage != nullptr) cmapFmt14CoverageEntryCount++;
+ }
+ writer->write<uint32_t>(cmapFmt14CoverageEntryCount);
+ for (size_t i = 0; i < mCmapFmt14Coverage.size(); i++) {
+ if (mCmapFmt14Coverage[i] != nullptr) {
+ writer->write<uint32_t>(i);
+ mCmapFmt14Coverage[i]->writeTo(writer);
+ }
+ }
+}
+
+void FontFamily::writeLocaleListInternal(BufferWriter* writer) const {
+ LocaleListCache::writeTo(writer, mLocaleListId);
+}
// Compute a matching metric between two styles - 0 is an exact match
static int computeMatch(FontStyle style1, FontStyle style2) {
if (style1 == style2) return 0;
@@ -144,21 +151,23 @@
}
FakedFont FontFamily::getClosestMatch(FontStyle style) const {
- const Font* bestFont = &mFonts[0];
+ int bestIndex = 0;
+ Font* bestFont = mFonts[bestIndex].get();
int bestMatch = computeMatch(bestFont->style(), style);
for (size_t i = 1; i < mFonts.size(); i++) {
- const Font& font = mFonts[i];
- int match = computeMatch(font.style(), style);
+ Font* font = mFonts[i].get();
+ int match = computeMatch(font->style(), style);
if (i == 0 || match < bestMatch) {
- bestFont = &font;
+ bestFont = font;
+ bestIndex = i;
bestMatch = match;
}
}
- return FakedFont{bestFont, computeFakery(style, bestFont->style())};
+ return FakedFont{mFonts[bestIndex], computeFakery(style, bestFont->style())};
}
void FontFamily::computeCoverage() {
- const Font* font = getClosestMatch(FontStyle()).font;
+ const std::shared_ptr<Font>& font = getClosestMatch(FontStyle()).font;
HbBlob cmapTable(font->baseFont(), MinikinFont::MakeTag('c', 'm', 'a', 'p'));
if (cmapTable.get() == nullptr) {
ALOGE("Could not get cmap table size!\n");
@@ -168,7 +177,7 @@
mCoverage = CmapCoverage::getCoverage(cmapTable.get(), cmapTable.size(), &mCmapFmt14Coverage);
for (size_t i = 0; i < mFonts.size(); ++i) {
- std::unordered_set<AxisTag> supportedAxes = mFonts[i].getSupportedAxes();
+ std::unordered_set<AxisTag> supportedAxes = mFonts[i]->getSupportedAxes();
mSupportedAxes.insert(supportedAxes.begin(), supportedAxes.end());
}
}
@@ -216,10 +225,10 @@
return nullptr;
}
- std::vector<Font> fonts;
- for (const Font& font : mFonts) {
+ std::vector<std::shared_ptr<Font>> fonts;
+ for (const auto& font : mFonts) {
bool supportedVariations = false;
- std::unordered_set<AxisTag> supportedAxes = font.getSupportedAxes();
+ std::unordered_set<AxisTag> supportedAxes = font->getSupportedAxes();
if (!supportedAxes.empty()) {
for (const FontVariation& variation : variations) {
if (supportedAxes.find(variation.axisTag) != supportedAxes.end()) {
@@ -230,12 +239,13 @@
}
std::shared_ptr<MinikinFont> minikinFont;
if (supportedVariations) {
- minikinFont = font.typeface()->createFontWithVariation(variations);
+ minikinFont = font->typeface()->createFontWithVariation(variations);
}
if (minikinFont == nullptr) {
- minikinFont = font.typeface();
+ fonts.push_back(font);
+ } else {
+ fonts.push_back(Font::Builder(minikinFont).setStyle(font->style()).build());
}
- fonts.push_back(Font::Builder(minikinFont).setStyle(font.style()).build());
}
return std::shared_ptr<FontFamily>(
diff --git a/libs/minikin/FontFileParser.cpp b/libs/minikin/FontFileParser.cpp
new file mode 100644
index 0000000..1bcb711
--- /dev/null
+++ b/libs/minikin/FontFileParser.cpp
@@ -0,0 +1,219 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+#include "minikin/FontFileParser.h"
+
+#define LOG_TAG "Minikin"
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <hb-ot.h>
+#include <hb.h>
+
+#include "MinikinInternal.h"
+#include "minikin/MinikinFont.h"
+
+namespace minikin {
+
+namespace {
+
+class SafeFontBufferReader {
+public:
+ SafeFontBufferReader(const void* buffer, size_t size)
+ : mBuffer(reinterpret_cast<const uint8_t*>(buffer)),
+ mSize(size),
+ mPos(0),
+ mError(false) {}
+
+ template <typename T>
+ T readBE() {
+ if (mError) return T();
+
+ if ((mSize - mPos) < sizeof(T)) {
+ mError = true;
+ return T();
+ }
+ const T* data = reinterpret_cast<const T*>(mBuffer + mPos);
+ mPos += sizeof(T);
+ return *data;
+ }
+
+ uint16_t readU16() {
+ if (mError) return 0;
+
+ if ((mSize - mPos) < 2) {
+ mError = true;
+ return 0;
+ }
+ uint16_t out = ((uint32_t)mBuffer[mPos]) << 8 | ((uint32_t)mBuffer[mPos + 1]);
+ mPos += 2;
+ return out;
+ };
+
+ uint32_t readU32() {
+ if (mError) return 0;
+
+ if ((mSize - mPos) < 4) {
+ mError = true;
+ return 0;
+ }
+
+ uint32_t out = ((uint32_t)mBuffer[mPos]) << 24 | ((uint32_t)mBuffer[mPos + 1]) << 16 |
+ ((uint32_t)mBuffer[mPos + 2]) << 8 | ((uint32_t)mBuffer[mPos + 3]);
+ mPos += 4;
+ return out;
+ };
+
+ void seek(size_t pos) {
+ if (mError) return;
+
+ if (pos > mSize) {
+ mError = true;
+ } else {
+ mPos = pos;
+ }
+ }
+
+ size_t remaining() const {
+ if (mError) return 0;
+ return mSize - mPos;
+ }
+
+ bool error() const { return mError; }
+
+private:
+ const uint8_t* mBuffer;
+ size_t mSize;
+ size_t mPos;
+ bool mError;
+};
+
+bool isPostScriptNameAllowedChar(char c) {
+ // OpenType spec says only ASCII codes 33 to 126, ecept for the '[', ']', '(', ')', '{', '}',
+ // '<', '>', '/', '%'.
+ if (!(33 <= c && c <= 126)) {
+ return false;
+ }
+ if (c == '[' || c == ']' || c == '(' || c == ')' || c == '{' || c == '}' || c == '<' ||
+ c == '>' || c == '/' || c == '%') {
+ return false;
+ }
+
+ return true;
+}
+
+} // namespace
+
+// static
+bool FontFileParser::analyzeFontRevision(const uint8_t* head_data, size_t head_size,
+ uint32_t* out) {
+ SafeFontBufferReader reader(head_data, head_size);
+
+ if (reader.remaining() < 8) {
+ return false; // At least head table has 8 bytes, for version and fontRevision
+ }
+
+ uint32_t majorVersion = reader.readU16();
+ if (reader.error()) return false;
+ uint32_t minorVersion = reader.readU16();
+ if (reader.error()) return false;
+
+ // Invalid head table header.
+ if (majorVersion != 1 && minorVersion != 0) return false;
+
+ *out = reader.readU32();
+ if (reader.error()) return false;
+ return true;
+}
+
+// static
+bool FontFileParser::checkPSName(const std::string& psName) {
+ if (psName.size() > 63) return false;
+
+ for (auto c : psName) {
+ if (!isPostScriptNameAllowedChar(c)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+FontFileParser::FontFileParser(const void* buffer, size_t size, uint32_t index)
+ : mFace(makeHbFace(buffer, size, index)) {}
+
+FontFileParser::FontFileParser(const HbFaceUniquePtr& face)
+ : mFace(hb_face_reference(face.get())) {}
+
+FontFileParser::FontFileParser(const HbFontUniquePtr& font)
+ : mFace(hb_face_reference(hb_font_get_face(font.get()))) {}
+
+FontFileParser::~FontFileParser() {}
+
+// static
+HbFaceUniquePtr FontFileParser::makeHbFace(const void* buffer, size_t size, uint32_t index) {
+ HbBlobUniquePtr blob(hb_blob_create(reinterpret_cast<const char*>(buffer), size,
+ HB_MEMORY_MODE_READONLY, nullptr, nullptr));
+ return HbFaceUniquePtr(hb_face_create(blob.get(), index));
+}
+
+std::optional<uint32_t> FontFileParser::getFontRevision() const {
+ if (!mFace) return std::optional<uint32_t>();
+
+ HbBlob headTable(mFace, MinikinFont::MakeTag('h', 'e', 'a', 'd'));
+ if (!headTable) return std::optional<uint32_t>();
+
+ uint32_t out = 0;
+ if (!analyzeFontRevision(headTable.get(), headTable.size(), &out)) {
+ return std::optional<uint32_t>();
+ }
+
+ return out;
+}
+
+std::optional<std::string> FontFileParser::getPostScriptName() const {
+ if (!mFace) return std::optional<std::string>();
+
+ unsigned int size = 64; // PostScript name is up to 63 characters.
+ char buf[64] = {};
+
+ uint32_t result = hb_ot_name_get_utf8(mFace.get(), HB_OT_NAME_ID_POSTSCRIPT_NAME,
+ HB_LANGUAGE_INVALID, &size, buf);
+
+ if (result == 0) { // not found.
+ return std::optional<std::string>();
+ }
+
+ std::string out(buf, size);
+
+ if (!checkPSName(out)) { // Contains invalid characters.
+ return std::optional<std::string>();
+ }
+
+ return out;
+}
+
+std::optional<bool> FontFileParser::isPostScriptType1Font() const {
+ if (!mFace) return std::optional<bool>();
+
+ HbBlob cffTable(mFace, MinikinFont::MakeTag('C', 'F', 'F', ' '));
+ HbBlob cff2Table(mFace, MinikinFont::MakeTag('C', 'F', 'F', '2'));
+ return cffTable || cff2Table;
+}
+
+} // namespace minikin
diff --git a/libs/minikin/GreedyLineBreaker.cpp b/libs/minikin/GreedyLineBreaker.cpp
index f6952a9..9bcb22d 100644
--- a/libs/minikin/GreedyLineBreaker.cpp
+++ b/libs/minikin/GreedyLineBreaker.cpp
@@ -255,7 +255,7 @@
// TODO: Respect trailing line end spaces.
bool GreedyLineBreaker::doLineBreakWithGraphemeBounds(const Range& range) {
- double width = mMeasuredText.widths[range.getStart()];
+ float width = mMeasuredText.widths[range.getStart()];
// Starting from + 1 since at least one character needs to be assigned to a line.
for (uint32_t i = range.getStart() + 1; i < range.getEnd(); ++i) {
diff --git a/libs/minikin/Layout.cpp b/libs/minikin/Layout.cpp
index b902648..e7d41c8 100644
--- a/libs/minikin/Layout.cpp
+++ b/libs/minikin/Layout.cpp
@@ -158,9 +158,6 @@
mAdvances[start] += extraAdvance;
}
}
- MinikinRect srcBounds(src.bounds());
- srcBounds.offset(mAdvance, 0);
- mBounds.join(srcBounds);
mAdvance += src.advance() + extraAdvance;
}
diff --git a/libs/minikin/LayoutCore.cpp b/libs/minikin/LayoutCore.cpp
index 6087646..f1d0de8 100644
--- a/libs/minikin/LayoutCore.cpp
+++ b/libs/minikin/LayoutCore.cpp
@@ -355,8 +355,9 @@
mPoints.reserve(count);
HbBufferUniquePtr buffer(hb_buffer_create());
- std::vector<FontCollection::Run> items = paint.font->itemize(
- textBuf.substr(range), paint.fontStyle, paint.localeListId, paint.familyVariant);
+ U16StringPiece substr = textBuf.substr(range);
+ std::vector<FontCollection::Run> items =
+ paint.font->itemize(substr, paint.fontStyle, paint.localeListId, paint.familyVariant);
std::vector<hb_feature_t> features;
// Disable default-on non-required ligature features if letter-spacing
@@ -384,14 +385,14 @@
isRtl ? run_ix >= 0 : run_ix < static_cast<int>(items.size());
isRtl ? --run_ix : ++run_ix) {
FontCollection::Run& run = items[run_ix];
- const FakedFont& fakedFont = run.fakedFont;
- auto it = fontMap.find(fakedFont.font);
+ FakedFont fakedFont = paint.font->getBestFont(substr, run, paint.fontStyle);
+ auto it = fontMap.find(fakedFont.font.get());
uint8_t font_ix;
if (it == fontMap.end()) {
// First time to see this font.
font_ix = mFonts.size();
mFonts.push_back(fakedFont);
- fontMap.insert(std::make_pair(fakedFont.font, font_ix));
+ fontMap.insert(std::make_pair(fakedFont.font.get(), font_ix));
// We override some functions which are not thread safe.
HbFontUniquePtr font(hb_font_create_sub_font(fakedFont.font->baseFont().get()));
@@ -421,8 +422,6 @@
hb_font_set_ppem(hbFont.get(), size * scaleX, size);
hb_font_set_scale(hbFont.get(), HBFloatToFixed(size * scaleX), HBFloatToFixed(size));
- const bool is_color_bitmap_font = isColorBitmapFont(hbFont);
-
// TODO: if there are multiple scripts within a font in an RTL run,
// we need to reorder those runs. This is unlikely with our current
// font stack, but should be done for correctness.
@@ -502,23 +501,6 @@
mGlyphIds.push_back(glyph_ix);
mPoints.emplace_back(x + xoff, y + yoff);
float xAdvance = HBFixedToFloat(positions[i].x_advance);
- MinikinRect glyphBounds;
- hb_glyph_extents_t extents = {};
- if (is_color_bitmap_font &&
- hb_font_get_glyph_extents(hbFont.get(), glyph_ix, &extents)) {
- // Note that it is technically possible for a TrueType font to have outline and
- // embedded bitmap at the same time. We ignore modified bbox of hinted outline
- // glyphs in that case.
- glyphBounds.mLeft = roundf(HBFixedToFloat(extents.x_bearing));
- glyphBounds.mTop = roundf(HBFixedToFloat(-extents.y_bearing));
- glyphBounds.mRight = roundf(HBFixedToFloat(extents.x_bearing + extents.width));
- glyphBounds.mBottom =
- roundf(HBFixedToFloat(-extents.y_bearing - extents.height));
- } else {
- fakedFont.font->typeface()->GetBounds(&glyphBounds, glyph_ix, paint,
- fakedFont.fakery);
- }
- glyphBounds.offset(xoff, yoff);
if (clusterBaseIndex < count) {
mAdvances[clusterBaseIndex] += xAdvance;
@@ -526,8 +508,6 @@
ALOGE("cluster %zu (start %zu) out of bounds of count %zu", clusterBaseIndex,
start, count);
}
- glyphBounds.offset(x, y);
- mBounds.join(glyphBounds);
x += xAdvance;
}
if (numGlyphs) {
diff --git a/libs/minikin/LineBreakerUtil.h b/libs/minikin/LineBreakerUtil.h
index eb058cc..8b383a4 100644
--- a/libs/minikin/LineBreakerUtil.h
+++ b/libs/minikin/LineBreakerUtil.h
@@ -36,7 +36,7 @@
// paragraphs, accuracy could degrade using only 32-bit float. Note however that float is used
// extensively on the Java side for this. This is a typedef so that we can easily change it based
// on performance/accuracy tradeoff.
-typedef double ParaWidth;
+typedef float ParaWidth;
// Hyphenates a string potentially containing non-breaking spaces.
std::vector<HyphenationType> hyphenate(const U16StringPiece& string, const Hyphenator& hypenator);
diff --git a/libs/minikin/Locale.cpp b/libs/minikin/Locale.cpp
index c1ec389..553f61a 100644
--- a/libs/minikin/Locale.cpp
+++ b/libs/minikin/Locale.cpp
@@ -34,6 +34,18 @@
return LocaleListCache::getId(locales);
}
+std::string getLocaleString(uint32_t localeId) {
+ const LocaleList& localeList = LocaleListCache::getById(localeId);
+ std::string out;
+ for (size_t i = 0; i < localeList.size(); ++i) {
+ if (i != 0) {
+ out += ",";
+ }
+ out += localeList[i].getString();
+ }
+ return out;
+}
+
// Check if a language code supports extension such as emoji and line break etc. according to its
// subtag
static bool isSubtag(const char* buf, size_t bufLen, const char* subtag, size_t subtagLen) {
diff --git a/libs/minikin/Locale.h b/libs/minikin/Locale.h
index 8052d6c..7557301 100644
--- a/libs/minikin/Locale.h
+++ b/libs/minikin/Locale.h
@@ -95,7 +95,17 @@
// Parse from string
Locale(const StringPiece& buf);
- bool operator==(const Locale other) const {
+ // Parse from identifier. See getIdentifier() for the identifier format.
+ explicit Locale(uint64_t identifier)
+ : mScript(extractBits(identifier, 29, 20)),
+ mLanguage(extractBits(identifier, 49, 15)),
+ mRegion(extractBits(identifier, 14, 15)),
+ mSubScriptBits(scriptToSubScriptBits(mScript)),
+ mVariant(static_cast<Variant>(extractBits(identifier, 0, 2))),
+ mEmojiStyle(static_cast<EmojiStyle>(extractBits(identifier, 12, 2))),
+ mLBStyle(static_cast<LineBreakStyle>(extractBits(identifier, 10, 2))) {}
+
+ bool operator==(const Locale& other) const {
return !isUnsupported() && isEqualScript(other) && mLanguage == other.mLanguage &&
mRegion == other.mRegion && mVariant == other.mVariant &&
mLBStyle == other.mLBStyle && mEmojiStyle == other.mEmojiStyle;
@@ -134,13 +144,13 @@
// Identifier pattern:
// |-------|-------|-------|-------|-------|-------|-------|-------|
- // lllllllllllllll Language Code
- // ssssssssssssssssssss Script Code
- // rrrrrrrrrrrrrrr Region Code
- // ee Emoji Style
- // bb Line Break Style
- // XXXXXXXX Free
- // vv German Variant
+ // lllllllllllllll Language Code (15 bits)
+ // ssssssssssssssssssss Script Code (20 bits)
+ // rrrrrrrrrrrrrrr Region Code (15 bits)
+ // ee Emoji Style (2 bits)
+ // bb Line Break Style (2 bits)
+ // XXXXXXXX Free (8 bits)
+ // vv German Variant (2 bits)
uint64_t getIdentifier() const {
return ((uint64_t)mLanguage << 49) | ((uint64_t)mScript << 29) | ((uint64_t)mRegion << 14) |
((uint64_t)mEmojiStyle << 12) | ((uint64_t)mLBStyle << 10) | (uint64_t)mVariant;
@@ -181,6 +191,10 @@
void resolveUnicodeExtension(const char* buf, size_t length);
+ inline static uint64_t extractBits(uint64_t value, uint8_t shift, uint8_t nBits) {
+ return (value >> shift) & ((1 << nBits) - 1);
+ }
+
static uint8_t scriptToSubScriptBits(uint32_t rawScript);
static LineBreakStyle resolveLineBreakStyle(const char* buf, size_t length);
diff --git a/libs/minikin/LocaleListCache.cpp b/libs/minikin/LocaleListCache.cpp
index eaf55ef..38800f7 100644
--- a/libs/minikin/LocaleListCache.cpp
+++ b/libs/minikin/LocaleListCache.cpp
@@ -21,6 +21,8 @@
#include <unordered_set>
#include <log/log.h>
+#include <minikin/Hasher.h>
+#include <minikin/LocaleList.h>
#include <unicode/uloc.h>
#include <unicode/umachine.h>
@@ -29,8 +31,6 @@
namespace minikin {
-const uint32_t LocaleListCache::kEmptyListId;
-
// Returns the text length of output.
static size_t toLanguageTag(char* output, size_t outSize, const StringPiece& locale) {
output[0] = '\0';
@@ -107,15 +107,39 @@
return result;
}
+size_t LocaleListCache::LocaleVectorHash::operator()(const std::vector<Locale>& locales) const {
+ Hasher hasher;
+ for (const auto& locale : locales) {
+ uint64_t id = locale.getIdentifier();
+ hasher.update(static_cast<uint32_t>((id >> 32) & 0xFFFFFFFF));
+ hasher.update(static_cast<uint32_t>(id & 0xFFFFFFFF));
+ }
+ return hasher.hash();
+}
+
LocaleListCache::LocaleListCache() {
- // Insert an empty locale list for mapping default locale list to kEmptyListId.
+ // Insert an empty locale list for mapping default locale list to kEmptyLocaleListId.
// The default locale list has only one Locale and it is the unsupported locale.
mLocaleLists.emplace_back();
- mLocaleListLookupTable.insert(std::make_pair("", kEmptyListId));
+ mLocaleListLookupTable.emplace(std::vector<Locale>(), kEmptyLocaleListId);
+ mLocaleListStringCache.emplace("", kEmptyLocaleListId);
}
uint32_t LocaleListCache::getIdInternal(const std::string& locales) {
std::lock_guard<std::mutex> lock(mMutex);
+ const auto& it = mLocaleListStringCache.find(locales);
+ if (it != mLocaleListStringCache.end()) {
+ return it->second;
+ }
+ uint32_t id = getIdInternal(parseLocaleList(locales));
+ mLocaleListStringCache.emplace(locales, id);
+ return id;
+}
+
+uint32_t LocaleListCache::getIdInternal(std::vector<Locale>&& locales) {
+ if (locales.empty()) {
+ return kEmptyLocaleListId;
+ }
const auto& it = mLocaleListLookupTable.find(locales);
if (it != mLocaleListLookupTable.end()) {
return it->second;
@@ -123,15 +147,31 @@
// Given locale list is not in cache. Insert it and return newly assigned ID.
const uint32_t nextId = mLocaleLists.size();
- LocaleList fontLocales(parseLocaleList(locales));
- if (fontLocales.empty()) {
- return kEmptyListId;
- }
+ mLocaleListLookupTable.emplace(locales, nextId);
+ LocaleList fontLocales(std::move(locales));
mLocaleLists.push_back(std::move(fontLocales));
- mLocaleListLookupTable.insert(std::make_pair(locales, nextId));
return nextId;
}
+uint32_t LocaleListCache::readFromInternal(BufferReader* reader) {
+ uint32_t size = reader->read<uint32_t>();
+ std::vector<Locale> locales;
+ locales.reserve(size);
+ for (uint32_t i = 0; i < size; i++) {
+ locales.emplace_back(reader->read<uint64_t>());
+ }
+ std::lock_guard<std::mutex> lock(mMutex);
+ return getIdInternal(std::move(locales));
+}
+
+void LocaleListCache::writeToInternal(BufferWriter* writer, uint32_t id) {
+ const LocaleList& localeList = getByIdInternal(id);
+ writer->write<uint32_t>(localeList.size());
+ for (size_t i = 0; i < localeList.size(); i++) {
+ writer->write<uint64_t>(localeList[i].getIdentifier());
+ }
+}
+
const LocaleList& LocaleListCache::getByIdInternal(uint32_t id) {
std::lock_guard<std::mutex> lock(mMutex);
MINIKIN_ASSERT(id < mLocaleLists.size(), "Lookup by unknown locale list ID.");
diff --git a/libs/minikin/LocaleListCache.h b/libs/minikin/LocaleListCache.h
index 61e3f81..a83b1c8 100644
--- a/libs/minikin/LocaleListCache.h
+++ b/libs/minikin/LocaleListCache.h
@@ -20,6 +20,7 @@
#include <mutex>
#include <unordered_map>
+#include "minikin/Buffer.h"
#include "minikin/Macros.h"
#include "Locale.h"
@@ -28,30 +29,39 @@
class LocaleListCache {
public:
- // A special ID for the empty locale list.
- // This value must be 0 since the empty locale list is inserted into mLocaleLists by
- // default.
- const static uint32_t kEmptyListId = 0;
-
// A special ID for the invalid locale list.
const static uint32_t kInvalidListId = (uint32_t)(-1);
// Returns the locale list ID for the given string representation of LocaleList.
- // Caller should acquire a lock before calling the method.
static inline uint32_t getId(const std::string& locales) {
return getInstance().getIdInternal(locales);
}
- // Caller should acquire a lock before calling the method.
+ // Returns the locale list ID for the LocaleList serialized in the buffer.
+ static inline uint32_t readFrom(BufferReader* reader) {
+ return getInstance().readFromInternal(reader);
+ }
+
+ static inline void writeTo(BufferWriter* writer, uint32_t id) {
+ return getInstance().writeToInternal(writer, id);
+ }
+
static inline const LocaleList& getById(uint32_t id) {
return getInstance().getByIdInternal(id);
}
private:
+ struct LocaleVectorHash {
+ size_t operator()(const std::vector<Locale>& locales) const;
+ };
+
LocaleListCache(); // Singleton
~LocaleListCache() {}
uint32_t getIdInternal(const std::string& locales);
+ uint32_t getIdInternal(std::vector<Locale>&& locales) EXCLUSIVE_LOCKS_REQUIRED(mMutex);
+ uint32_t readFromInternal(BufferReader* reader);
+ void writeToInternal(BufferWriter* writer, uint32_t id);
const LocaleList& getByIdInternal(uint32_t id);
// Caller should acquire a lock before calling the method.
@@ -62,8 +72,18 @@
std::vector<LocaleList> mLocaleLists GUARDED_BY(mMutex);
- // A map from the string representation of the font locale list to the ID.
- std::unordered_map<std::string, uint32_t> mLocaleListLookupTable GUARDED_BY(mMutex);
+ // A map from the list of locale identifier to the ID.
+ //
+ // Locale's operator==() doesn't have reflexivity for unsupported locales,
+ // but it won't cause problems because we never store unsupported locales in
+ // LocaleListCache. See parseLocaleList() in LocaleListCache.cpp.
+ std::unordered_map<std::vector<Locale>, uint32_t, LocaleVectorHash> mLocaleListLookupTable
+ GUARDED_BY(mMutex);
+
+ // A cache map from the string representation of the font locale list to the ID.
+ // This is a mere cache over mLocaleListLookupTable. Some LocaleList objects may be in
+ // mLocaleListLookupTable even if they are not in mLocaleListStringCache.
+ std::unordered_map<std::string, uint32_t> mLocaleListStringCache GUARDED_BY(mMutex);
std::mutex mMutex;
};
diff --git a/libs/minikin/MeasuredText.cpp b/libs/minikin/MeasuredText.cpp
index af0d0ee..1bf3942 100644
--- a/libs/minikin/MeasuredText.cpp
+++ b/libs/minikin/MeasuredText.cpp
@@ -213,10 +213,20 @@
public:
BoundsCompositor() : mAdvance(0) {}
- void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& /* paint */) {
- MinikinRect tmpBounds = layoutPiece.bounds();
- tmpBounds.offset(mAdvance, 0);
- mBounds.join(tmpBounds);
+ void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& paint) {
+ MinikinRect pieceBounds;
+ MinikinRect tmpRect;
+ for (uint32_t i = 0; i < layoutPiece.glyphCount(); ++i) {
+ const FakedFont& font = layoutPiece.fontAt(i);
+ const Point& point = layoutPiece.pointAt(i);
+
+ MinikinFont* minikinFont = font.font->typeface().get();
+ minikinFont->GetBounds(&tmpRect, layoutPiece.glyphIdAt(i), paint, font.fakery);
+ tmpRect.offset(point.x, point.y);
+ pieceBounds.join(tmpRect);
+ }
+ pieceBounds.offset(mAdvance, 0);
+ mBounds.join(pieceBounds);
mAdvance += layoutPiece.advance();
}
diff --git a/libs/minikin/Measurement.cpp b/libs/minikin/Measurement.cpp
index 5d110c4..66886da 100644
--- a/libs/minikin/Measurement.cpp
+++ b/libs/minikin/Measurement.cpp
@@ -19,6 +19,9 @@
#include <cfloat>
#include <cmath>
+#include "BidiUtils.h"
+#include "LayoutSplitter.h"
+#include "minikin/BoundsCache.h"
#include "minikin/GraphemeBreak.h"
namespace minikin {
@@ -118,4 +121,40 @@
return best;
}
+struct BoundsComposer {
+ BoundsComposer() : mAdvance(0) {}
+
+ void operator()(const MinikinRect& rect, float advance) {
+ MinikinRect tmp = rect;
+ tmp.offset(mAdvance, 0);
+ mBounds.join(tmp);
+ mAdvance += advance;
+ }
+
+ float mAdvance;
+ MinikinRect mBounds;
+};
+
+void getBounds(const U16StringPiece& str, const Range& range, Bidi bidiFlag,
+ const MinikinPaint& paint, StartHyphenEdit startHyphen, EndHyphenEdit endHyphen,
+ MinikinRect* out) {
+ BoundsComposer bc;
+ for (const BidiText::RunInfo info : BidiText(str, range, bidiFlag)) {
+ for (const auto [context, piece] : LayoutSplitter(str, info.range, info.isRtl)) {
+ const StartHyphenEdit pieceStartHyphen =
+ (piece.getStart() == range.getStart()) ? startHyphen : StartHyphenEdit::NO_EDIT;
+ const EndHyphenEdit pieceEndHyphen =
+ (piece.getEnd() == range.getEnd()) ? endHyphen : EndHyphenEdit::NO_EDIT;
+ BoundsCache::getInstance().getOrCreate(str.substr(context), piece - context.getStart(),
+ paint, info.isRtl, pieceStartHyphen,
+ pieceEndHyphen, bc);
+ // Increment word spacing for spacer
+ if (piece.getLength() == 1 && isWordSpace(str[piece.getStart()])) {
+ bc.mAdvance += paint.wordSpacing;
+ }
+ }
+ }
+ *out = bc.mBounds;
+}
+
} // namespace minikin
diff --git a/libs/minikin/SparseBitSet.cpp b/libs/minikin/SparseBitSet.cpp
index 66d6c02..41151f1 100644
--- a/libs/minikin/SparseBitSet.cpp
+++ b/libs/minikin/SparseBitSet.cpp
@@ -55,9 +55,14 @@
return;
}
mMaxVal = maxVal;
- mIndices.reset(new uint16_t[(mMaxVal + kPageMask) >> kLogValuesPerPage]);
+ mIndicesCount = (mMaxVal + kPageMask) >> kLogValuesPerPage;
+ // Avoid zero-filling mOwnedIndices.
+ mOwnedIndices.reset(new uint16_t[mIndicesCount]);
+ mIndices = mOwnedIndices.get();
uint32_t nPages = calcNumPages(ranges, nRanges);
- mBitmaps.reset(new element[nPages << (kLogValuesPerPage - kLogBitsPerEl)]());
+ mBitmapsCount = nPages << (kLogValuesPerPage - kLogBitsPerEl);
+ mOwnedBitmaps = std::make_unique<element[]>(mBitmapsCount);
+ mBitmaps = mOwnedBitmaps.get();
mZeroPageIndex = noZeroPage;
uint32_t nonzeroPageEnd = 0;
uint32_t currentPage = 0;
@@ -73,32 +78,52 @@
mZeroPageIndex = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl);
}
for (uint32_t j = nonzeroPageEnd; j < startPage; j++) {
- mIndices[j] = mZeroPageIndex;
+ mOwnedIndices[j] = mZeroPageIndex;
}
}
- mIndices[startPage] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl);
+ mOwnedIndices[startPage] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl);
}
size_t index = ((currentPage - 1) << (kLogValuesPerPage - kLogBitsPerEl)) +
((start & kPageMask) >> kLogBitsPerEl);
size_t nElements = (end - (start & ~kElMask) + kElMask) >> kLogBitsPerEl;
if (nElements == 1) {
- mBitmaps[index] |=
+ mOwnedBitmaps[index] |=
(kElAllOnes >> (start & kElMask)) & (kElAllOnes << ((~end + 1) & kElMask));
} else {
- mBitmaps[index] |= kElAllOnes >> (start & kElMask);
+ mOwnedBitmaps[index] |= kElAllOnes >> (start & kElMask);
for (size_t j = 1; j < nElements - 1; j++) {
- mBitmaps[index + j] = kElAllOnes;
+ mOwnedBitmaps[index + j] = kElAllOnes;
}
- mBitmaps[index + nElements - 1] |= kElAllOnes << ((~end + 1) & kElMask);
+ mOwnedBitmaps[index + nElements - 1] |= kElAllOnes << ((~end + 1) & kElMask);
}
for (size_t j = startPage + 1; j < endPage + 1; j++) {
- mIndices[j] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl);
+ mOwnedIndices[j] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl);
}
nonzeroPageEnd = endPage + 1;
}
}
+void SparseBitSet::initFromBuffer(BufferReader* reader) {
+ mMaxVal = reader->read<uint32_t>();
+ // mIndices and mBitmaps are not initialized when mMaxVal == 0
+ if (mMaxVal == 0) return;
+ std::tie(mIndices, mIndicesCount) = reader->readArray<uint16_t>();
+ // element is uint32_t
+ static_assert(sizeof(element) == 4);
+ std::tie(mBitmaps, mBitmapsCount) = reader->readArray<element>();
+ mZeroPageIndex = reader->read<uint16_t>();
+}
+
+void SparseBitSet::writeTo(BufferWriter* writer) const {
+ writer->write<uint32_t>(mMaxVal);
+ // mIndices and mBitmaps are not initialized when mMaxVal == 0
+ if (mMaxVal == 0) return;
+ writer->writeArray<uint16_t>(mIndices, mIndicesCount);
+ writer->writeArray<element>(mBitmaps, mBitmapsCount);
+ writer->write<uint16_t>(mZeroPageIndex);
+}
+
int SparseBitSet::CountLeadingZeros(element x) {
// Note: GCC / clang builtin
return sizeof(element) <= sizeof(int) ? __builtin_clz(x) : __builtin_clzl(x);
diff --git a/libs/minikin/SystemFonts.cpp b/libs/minikin/SystemFonts.cpp
index 287fc61..9c8fa66 100644
--- a/libs/minikin/SystemFonts.cpp
+++ b/libs/minikin/SystemFonts.cpp
@@ -26,7 +26,8 @@
}
std::shared_ptr<FontCollection> SystemFonts::findFontCollectionInternal(
- const std::string& familyName) const {
+ const std::string& familyName) {
+ std::lock_guard<std::mutex> lock(mMutex);
auto it = mSystemFallbacks.find(familyName);
if (it != mSystemFallbacks.end()) {
return it->second;
@@ -35,4 +36,22 @@
return mDefaultFallback;
}
+void SystemFonts::buildFontSetLocked() {
+ std::unordered_set<FontFamily*> uniqueFamilies;
+
+ for (const auto& collection : mCollections) {
+ for (const auto& family : collection->getFamilies()) {
+ uniqueFamilies.insert(family.get());
+ }
+ }
+
+ std::vector<std::shared_ptr<Font>> result;
+ for (const auto family : uniqueFamilies) {
+ for (size_t i = 0; i < family->getNumFonts(); ++i) {
+ result.push_back(family->getFontRef(i));
+ }
+ }
+ mFonts = std::move(result);
+}
+
} // namespace minikin
diff --git a/tests/Android.bp b/tests/Android.bp
index 9acb028..3088ca4 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -7,6 +7,7 @@
srcs: [
"data/Arabic.ttf",
"data/Ascii.ttf",
+ "data/Bbox.ttf",
"data/Bold.ttf",
"data/BoldItalic.ttf",
"data/Cherokee.ttf",
@@ -14,6 +15,7 @@
"data/ColorTextMixedEmojiFont.ttf",
"data/CustomExtent.ttf",
"data/Emoji.ttf",
+ "data/EmojiBase.ttf",
"data/Hiragana.ttf",
"data/Italic.ttf",
"data/Ja.ttf",
@@ -23,6 +25,7 @@
"data/MultiAxis.ttf",
"data/NoCmapFormat14.ttf",
"data/NoGlyphFont.ttf",
+ "data/OverrideEmoji.ttf",
"data/Regular.ttf",
"data/TextEmojiFont.ttf",
"data/UnicodeBMPOnly.ttf",
@@ -32,6 +35,7 @@
"data/ZhHans.ttf",
"data/ZhHant.ttf",
"data/emoji.xml",
+ "data/emoji_itemization.xml",
"data/itemize.xml",
],
}
diff --git a/tests/data/Ascii.ttf b/tests/data/Ascii.ttf
index be6d5fe..2e6835b 100644
--- a/tests/data/Ascii.ttf
+++ b/tests/data/Ascii.ttf
Binary files differ
diff --git a/tests/data/Ascii.ttx b/tests/data/Ascii.ttx
index 74eba96..c0a2ef6 100644
--- a/tests/data/Ascii.ttx
+++ b/tests/data/Ascii.ttx
@@ -18,6 +18,7 @@
<GlyphOrder>
<GlyphID id="0" name=".notdef"/>
<GlyphID id="1" name="1em"/>
+ <GlyphID id="2" name="2em"/>
</GlyphOrder>
<head>
@@ -117,6 +118,7 @@
<hmtx>
<mtx name=".notdef" width="50" lsb="0"/>
<mtx name="1em" width="100" lsb="0"/>
+ <mtx name="2em" width="200" lsb="0"/>
</hmtx>
<cmap>
@@ -217,6 +219,12 @@
<map code="0x007C" name="1em" /> <!-- '|' -->
<map code="0x007D" name="1em" /> <!-- '}' -->
<map code="0x007E" name="1em" /> <!-- '~' -->
+ <map code="0x02B1" name="2em" /> <!-- 'α' -->
+ <map code="0x02B2" name="2em" /> <!-- 'β' -->
+ <map code="0x02B3" name="2em" /> <!-- 'γ' -->
+ <map code="0x02B4" name="2em" /> <!-- 'δ' -->
+ <map code="0x02B5" name="2em" /> <!-- 'ε' -->
+ <map code="0x02B6" name="2em" /> <!-- 'ζ' -->
</cmap_format_12>
</cmap>
@@ -235,6 +243,15 @@
</contour>
<instructions><assembly></assembly></instructions>
</TTGlyph>
+ <TTGlyph name="2em" xMin="0" yMin="0" xMax="200" yMax="200">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="200" y="0" on="1" />
+ <pt x="200" y="200" on="1" />
+ <pt x="0" y="200" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
</glyf>
<name>
diff --git a/tests/data/Bbox.ttf b/tests/data/Bbox.ttf
new file mode 100644
index 0000000..c89c59c
--- /dev/null
+++ b/tests/data/Bbox.ttf
Binary files differ
diff --git a/tests/data/Bbox.ttx b/tests/data/Bbox.ttx
new file mode 100644
index 0000000..e7d34bd
--- /dev/null
+++ b/tests/data/Bbox.ttx
@@ -0,0 +1,265 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (C) 2020 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.
+-->
+<ttFont sfntVersion="\x00\x01\x00\x00" ttLibVersion="3.0">
+
+ <GlyphOrder>
+ <GlyphID id="0" name=".notdef"/>
+ <GlyphID id="1" name="1emx1em"/>
+ <GlyphID id="2" name="2emx2em"/>
+ <GlyphID id="3" name="3emx3em"/>
+ <GlyphID id="4" name="2emx2em_lsb_1em"/>
+ <GlyphID id="5" name="1emx1em_y1em_origin"/>
+ </GlyphOrder>
+
+ <head>
+ <tableVersion value="1.0"/>
+ <fontRevision value="1.0"/>
+ <checkSumAdjustment value="0x640cdb2f"/>
+ <magicNumber value="0x5f0f3cf5"/>
+ <flags value="00000000 00000011"/>
+ <unitsPerEm value="1000"/>
+ <created value="Fri Mar 17 07:26:00 2017"/>
+ <macStyle value="00000000 00000000"/>
+ <lowestRecPPEM value="7"/>
+ <fontDirectionHint value="2"/>
+ <glyphDataFormat value="0"/>
+ </head>
+
+ <hhea>
+ <tableVersion value="1.0"/>
+ <ascent value="1000"/>
+ <descent value="-200"/>
+ <lineGap value="0"/>
+ <caretSlopeRise value="1"/>
+ <caretSlopeRun value="0"/>
+ <caretOffset value="0"/>
+ <reserved0 value="0"/>
+ <reserved1 value="0"/>
+ <reserved2 value="0"/>
+ <reserved3 value="0"/>
+ <metricDataFormat value="0"/>
+ </hhea>
+
+ <maxp>
+ <tableVersion value="0x10000"/>
+ <maxZones value="0"/>
+ <maxTwilightPoints value="0"/>
+ <maxStorage value="0"/>
+ <maxFunctionDefs value="0"/>
+ <maxInstructionDefs value="0"/>
+ <maxStackElements value="0"/>
+ <maxSizeOfInstructions value="0"/>
+ <maxComponentElements value="0"/>
+ </maxp>
+
+ <OS_2>
+ <!-- The fields 'usFirstCharIndex' and 'usLastCharIndex'
+ will be recalculated by the compiler -->
+ <version value="3"/>
+ <xAvgCharWidth value="594"/>
+ <usWeightClass value="400"/>
+ <usWidthClass value="5"/>
+ <fsType value="00000000 00001000"/>
+ <ySubscriptXSize value="650"/>
+ <ySubscriptYSize value="600"/>
+ <ySubscriptXOffset value="0"/>
+ <ySubscriptYOffset value="75"/>
+ <ySuperscriptXSize value="650"/>
+ <ySuperscriptYSize value="600"/>
+ <ySuperscriptXOffset value="0"/>
+ <ySuperscriptYOffset value="350"/>
+ <yStrikeoutSize value="50"/>
+ <yStrikeoutPosition value="300"/>
+ <sFamilyClass value="0"/>
+ <panose>
+ <bFamilyType value="0"/>
+ <bSerifStyle value="0"/>
+ <bWeight value="5"/>
+ <bProportion value="0"/>
+ <bContrast value="0"/>
+ <bStrokeVariation value="0"/>
+ <bArmStyle value="0"/>
+ <bLetterForm value="0"/>
+ <bMidline value="0"/>
+ <bXHeight value="0"/>
+ </panose>
+ <ulUnicodeRange1 value="00000000 00000000 00000000 00000001"/>
+ <ulUnicodeRange2 value="00000000 00000000 00000000 00000000"/>
+ <ulUnicodeRange3 value="00000000 00000000 00000000 00000000"/>
+ <ulUnicodeRange4 value="00000000 00000000 00000000 00000000"/>
+ <achVendID value="UKWN"/>
+ <fsSelection value="00000000 01000000"/>
+ <usFirstCharIndex value="32"/>
+ <usLastCharIndex value="122"/>
+ <sTypoAscender value="800"/>
+ <sTypoDescender value="-200"/>
+ <sTypoLineGap value="200"/>
+ <usWinAscent value="1000"/>
+ <usWinDescent value="200"/>
+ <ulCodePageRange1 value="00000000 00000000 00000000 00000001"/>
+ <ulCodePageRange2 value="00000000 00000000 00000000 00000000"/>
+ <sxHeight value="500"/>
+ <sCapHeight value="700"/>
+ <usDefaultChar value="0"/>
+ <usBreakChar value="32"/>
+ <usMaxContext value="0"/>
+ </OS_2>
+
+ <hmtx>
+ <mtx name=".notdef" width="500" lsb="93"/>
+ <mtx name="1emx1em" width="1000" lsb="0"/>
+ <mtx name="2emx2em" width="2000" lsb="0"/>
+ <mtx name="3emx3em" width="3000" lsb="0"/>
+ <mtx name="2emx2em_lsb_1em" width="2000" lsb="1000"/>
+ <mtx name="1emx1em_y1em_origin" width="1000" lsb="0"/>
+ </hmtx>
+
+ <cmap>
+ <tableVersion version="0"/>
+ <cmap_format_12 format="12" reserved="0" length="3" nGroups="6" platformID="3" platEncID="1" language="0">
+ <map code="0x0028" name="1emx1em" />
+ <map code="0x0061" name="1emx1em" />
+ <map code="0x0062" name="2emx2em" />
+ <map code="0x0063" name="3emx3em" />
+ <map code="0x0064" name="2emx2em_lsb_1em" />
+ <map code="0x0065" name="1emx1em_y1em_origin" />
+ </cmap_format_12>
+ </cmap>
+
+ <loca>
+ <!-- The 'loca' table will be calculated by the compiler -->
+ </loca>
+
+ <glyf>
+ <TTGlyph name=".notdef" xMin="0" yMin="0" xMax="0" yMax="0" />
+ <TTGlyph name="1emx1em" xMin="0" yMin="0" xMax="1000" yMax="1000">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="500" y="1000" on="1" />
+ <pt x="1000" y="0" on="1" />
+ </contour>
+ <instructions />
+ </TTGlyph>
+ <TTGlyph name="2emx2em" xMin="0" yMin="0" xMax="2000" yMax="2000">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="1000" y="2000" on="1" />
+ <pt x="2000" y="0" on="1" />
+ </contour>
+ <instructions />
+ </TTGlyph>
+ <TTGlyph name="3emx3em" xMin="0" yMin="0" xMax="3000" yMax="3000">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="1500" y="3000" on="1" />
+ <pt x="3000" y="0" on="1" />
+ </contour>
+ <instructions />
+ </TTGlyph>
+ <TTGlyph name="2emx2em_lsb_1em" xMin="0" yMin="0" xMax="2000" yMax="2000">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="1000" y="2000" on="1" />
+ <pt x="2000" y="0" on="1" />
+ </contour>
+ <instructions />
+ </TTGlyph>
+ <TTGlyph name="1emx1em_y1em_origin" xMin="0" yMin="1000" xMax="1000" yMax="2000">
+ <contour>
+ <pt x="0" y="1000" on="1" />
+ <pt x="500" y="2000" on="1" />
+ <pt x="1000" y="1000" on="1" />
+ </contour>
+ <instructions />
+ </TTGlyph>
+ </glyf>
+
+ <GSUB>
+ <Version value="0x00010000"/>
+ <ScriptList>
+ <ScriptRecord index="0">
+ <ScriptTag value="latn"/>
+ <Script>
+ <DefaultLangSys>
+ <ReqFeatureIndex value="65535"/>
+ <FeatureIndex index="0" value="0"/>
+ </DefaultLangSys>
+ </Script>
+ </ScriptRecord>
+ </ScriptList>
+ <FeatureList>
+ <FeatureRecord index="0">
+ <FeatureTag value="rtlm"/>
+ <Feature>
+ <LookupListIndex index="0" value="0"/>
+ </Feature>
+ </FeatureRecord>
+ </FeatureList>
+ <LookupList>
+ <Lookup index="0">
+ <LookupType value="1"/>
+ <LookupFlag value="0"/>
+ <SingleSubst index="0" Format="2">
+ <Substitution in="1emx1em" out="3emx3em" />
+ </SingleSubst>
+ </Lookup>
+ </LookupList>
+
+ </GSUB>
+
+ <name>
+ <namerecord nameID="0" platformID="3" platEncID="1" langID="0x409">
+ Copyright (C) 2017 The Android Open Source Project
+ </namerecord>
+ <namerecord nameID="1" platformID="3" platEncID="1" langID="0x409">
+ Sample Font
+ </namerecord>
+ <namerecord nameID="2" platformID="3" platEncID="1" langID="0x409">
+ Regular
+ </namerecord>
+ <namerecord nameID="4" platformID="3" platEncID="1" langID="0x409">
+ Sample Font
+ </namerecord>
+ <namerecord nameID="6" platformID="3" platEncID="1" langID="0x409">
+ SampleFont-Regular
+ </namerecord>
+ <namerecord nameID="13" platformID="3" platEncID="1" langID="0x409">
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ 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.
+ </namerecord>
+ <namerecord nameID="14" platformID="3" platEncID="1" langID="0x409">
+ http://www.apache.org/licenses/LICENSE-2.0
+ </namerecord>
+ </name>
+
+ <post>
+ <formatType value="3.0"/>
+ <italicAngle value="0.0"/>
+ <underlinePosition value="-75"/>
+ <underlineThickness value="50"/>
+ <isFixedPitch value="0"/>
+ <minMemType42 value="0"/>
+ <maxMemType42 value="0"/>
+ <minMemType1 value="0"/>
+ <maxMemType1 value="0"/>
+ </post>
+
+</ttFont>
diff --git a/tests/data/EmojiBase.ttf b/tests/data/EmojiBase.ttf
new file mode 100644
index 0000000..659226d
--- /dev/null
+++ b/tests/data/EmojiBase.ttf
Binary files differ
diff --git a/tests/data/EmojiBase.ttx b/tests/data/EmojiBase.ttx
new file mode 100644
index 0000000..e6e3da8
--- /dev/null
+++ b/tests/data/EmojiBase.ttx
@@ -0,0 +1,537 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (C) 2021 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.
+-->
+<ttFont sfntVersion="\x00\x01\x00\x00" ttLibVersion="3.9">
+
+ <GlyphOrder>
+ <!-- The 'id' attribute is only for humans; it is ignored when parsed. -->
+ <GlyphID id="0" name=".notdef"/>
+
+ <!-- Compbining characters for Emoji -->
+ <GlyphID id="1" name="U+200D"/>
+ <GlyphID id="2" name="U+1F3FB"/>
+ <GlyphID id="3" name="U+1F3FC"/>
+
+ <!-- Random Emoji -->
+ <GlyphID id="4" name="U+1F9B0"/>
+ <GlyphID id="5" name="U+1F9B1"/>
+ <GlyphID id="6" name="U+1F9B2"/>
+ <GlyphID id="7" name="U+1F9B3"/>
+ <GlyphID id="8" name="U+1F9B4"/>
+ <GlyphID id="9" name="U+1F9B5"/>
+ <GlyphID id="10" name="U+1F9B6"/>
+ <GlyphID id="11" name="U+1F9B7"/>
+ <GlyphID id="12" name="U+1F9B8"/>
+ <GlyphID id="13" name="U+1F9B9"/>
+
+ <!-- Unassigned Code Points -->
+ <GlyphID id="14" name="U+E0000"/>
+ <GlyphID id="15" name="U+E0001"/>
+
+ <!-- Ligature Form. Not in cmap -->
+ <GlyphID id="16" name="LigaForm1"/>
+ <GlyphID id="17" name="LigaForm2"/>
+ <GlyphID id="18" name="LigaForm3"/>
+ <GlyphID id="19" name="LigaForm4"/>
+ <GlyphID id="20" name="LigaForm5"/>
+ <GlyphID id="21" name="LigaForm6"/>
+ <GlyphID id="22" name="LigaForm7"/>
+
+ <!-- Regional Indicators -->
+ <GlyphID id="23" name="U+1F1E6"/>
+ <GlyphID id="24" name="U+1F1E7"/>
+
+ </GlyphOrder>
+
+ <head>
+ <!-- Most of this table will be recalculated by the compiler -->
+ <tableVersion value="1.0"/>
+ <fontRevision value="1.0"/>
+ <checkSumAdjustment value="0x640cdb2f"/>
+ <magicNumber value="0x5f0f3cf5"/>
+ <flags value="00000000 00000011"/>
+ <unitsPerEm value="1000"/>
+ <created value="Wed Sep 9 08:01:17 2015"/>
+ <modified value="Wed Sep 9 08:48:07 2015"/>
+ <xMin value="0"/>
+ <yMin value="0"/>
+ <xMax value="0"/>
+ <yMax value="0"/>
+ <macStyle value="00000000 00000000"/>
+ <lowestRecPPEM value="7"/>
+ <fontDirectionHint value="2"/>
+ <indexToLocFormat value="0"/>
+ <glyphDataFormat value="0"/>
+ </head>
+
+ <hhea>
+ <tableVersion value="0x00010000"/>
+ <ascent value="1000"/>
+ <descent value="-200"/>
+ <lineGap value="0"/>
+ <advanceWidthMax value="500"/>
+ <minLeftSideBearing value="0"/>
+ <minRightSideBearing value="0"/>
+ <xMaxExtent value="0"/>
+ <caretSlopeRise value="1"/>
+ <caretSlopeRun value="0"/>
+ <caretOffset value="0"/>
+ <reserved0 value="0"/>
+ <reserved1 value="0"/>
+ <reserved2 value="0"/>
+ <reserved3 value="0"/>
+ <metricDataFormat value="0"/>
+ <numberOfHMetrics value="1"/>
+ </hhea>
+
+ <maxp>
+ <!-- Most of this table will be recalculated by the compiler -->
+ <tableVersion value="0x10000"/>
+ <numGlyphs value="8"/>
+ <maxPoints value="0"/>
+ <maxContours value="0"/>
+ <maxCompositePoints value="0"/>
+ <maxCompositeContours value="0"/>
+ <maxZones value="2"/>
+ <maxTwilightPoints value="12"/>
+ <maxStorage value="28"/>
+ <maxFunctionDefs value="119"/>
+ <maxInstructionDefs value="0"/>
+ <maxStackElements value="61"/>
+ <maxSizeOfInstructions value="2967"/>
+ <maxComponentElements value="0"/>
+ <maxComponentDepth value="0"/>
+ </maxp>
+
+ <OS_2>
+ <!-- The fields 'usFirstCharIndex' and 'usLastCharIndex'
+ will be recalculated by the compiler -->
+ <version value="3"/>
+ <xAvgCharWidth value="594"/>
+ <usWeightClass value="400"/>
+ <usWidthClass value="5"/>
+ <fsType value="00000000 00001000"/>
+ <ySubscriptXSize value="650"/>
+ <ySubscriptYSize value="600"/>
+ <ySubscriptXOffset value="0"/>
+ <ySubscriptYOffset value="75"/>
+ <ySuperscriptXSize value="650"/>
+ <ySuperscriptYSize value="600"/>
+ <ySuperscriptXOffset value="0"/>
+ <ySuperscriptYOffset value="350"/>
+ <yStrikeoutSize value="50"/>
+ <yStrikeoutPosition value="300"/>
+ <sFamilyClass value="0"/>
+ <panose>
+ <bFamilyType value="0"/>
+ <bSerifStyle value="0"/>
+ <bWeight value="5"/>
+ <bProportion value="0"/>
+ <bContrast value="0"/>
+ <bStrokeVariation value="0"/>
+ <bArmStyle value="0"/>
+ <bLetterForm value="0"/>
+ <bMidline value="0"/>
+ <bXHeight value="0"/>
+ </panose>
+ <ulUnicodeRange1 value="00000000 00000000 00000000 00000001"/>
+ <ulUnicodeRange2 value="00000000 00000000 00000000 00000000"/>
+ <ulUnicodeRange3 value="00000000 00000000 00000000 00000000"/>
+ <ulUnicodeRange4 value="00000000 00000000 00000000 00000000"/>
+ <achVendID value="UKWN"/>
+ <fsSelection value="00000000 01000000"/>
+ <usFirstCharIndex value="48"/>
+ <usLastCharIndex value="65535"/>
+ <sTypoAscender value="800"/>
+ <sTypoDescender value="-200"/>
+ <sTypoLineGap value="200"/>
+ <usWinAscent value="1000"/>
+ <usWinDescent value="200"/>
+ <ulCodePageRange1 value="00000000 00000000 00000000 00000001"/>
+ <ulCodePageRange2 value="00000000 00000000 00000000 00000000"/>
+ <sxHeight value="500"/>
+ <sCapHeight value="700"/>
+ <usDefaultChar value="0"/>
+ <usBreakChar value="32"/>
+ <usMaxContext value="0"/>
+ </OS_2>
+
+ <hmtx>
+ <mtx name=".notdef" width="500" lsb="93"/>
+ <mtx name="U+200D" width="500" lsb="93"/>
+ <mtx name="U+1F1E6" width="500" lsb="93"/>
+ <mtx name="U+1F1E7" width="500" lsb="93"/>
+ <mtx name="U+1F3FB" width="500" lsb="93"/>
+ <mtx name="U+1F3FC" width="500" lsb="93"/>
+ <mtx name="U+1F9B0" width="500" lsb="93"/>
+ <mtx name="U+1F9B1" width="500" lsb="93"/>
+ <mtx name="U+1F9B2" width="500" lsb="93"/>
+ <mtx name="U+1F9B3" width="500" lsb="93"/>
+ <mtx name="U+1F9B4" width="500" lsb="93"/>
+ <mtx name="U+1F9B5" width="500" lsb="93"/>
+ <mtx name="U+1F9B6" width="500" lsb="93"/>
+ <mtx name="U+1F9B7" width="500" lsb="93"/>
+ <mtx name="U+1F9B8" width="500" lsb="93"/>
+ <mtx name="U+1F9B9" width="500" lsb="93"/>
+ <mtx name="U+E0000" width="500" lsb="93"/>
+ <mtx name="U+E0001" width="500" lsb="93"/>
+ <mtx name="LigaForm1" width="500" lsb="93"/>
+ <mtx name="LigaForm2" width="500" lsb="93"/>
+ <mtx name="LigaForm3" width="500" lsb="93"/>
+ <mtx name="LigaForm4" width="500" lsb="93"/>
+ <mtx name="LigaForm5" width="500" lsb="93"/>
+ <mtx name="LigaForm6" width="500" lsb="93"/>
+ <mtx name="LigaForm7" width="500" lsb="93"/>
+ </hmtx>
+
+ <cmap>
+ <tableVersion version="0"/>
+ <cmap_format_12 format="12" reserved="0" length="3" nGroups="6" platformID="3" platEncID="1" language="0">
+ <map code="0x200D" name="U+200D" />
+ <map code="0x1F1E6" name="U+1F1E6" />
+ <map code="0x1F1E7" name="U+1F1E7" />
+ <map code="0x1F3FB" name="U+1F3FB" />
+ <map code="0x1F3FC" name="U+1F3FC" />
+ <map code="0x1F9B0" name="U+1F9B0" />
+ <map code="0x1F9B1" name="U+1F9B1" />
+ <map code="0x1F9B2" name="U+1F9B2" />
+ <map code="0x1F9B3" name="U+1F9B3" />
+ <map code="0x1F9B4" name="U+1F9B4" />
+ <map code="0x1F9B5" name="U+1F9B5" />
+ <map code="0x1F9B6" name="U+1F9B6" />
+ <map code="0x1F9B7" name="U+1F9B7" />
+ <map code="0x1F9B8" name="U+1F9B8" />
+ <map code="0x1F9B9" name="U+1F9B9" />
+ <map code="0xE0000" name="U+E0000" />
+ <map code="0xE0001" name="U+E0001" />
+ </cmap_format_12>
+ </cmap>
+
+ <loca>
+ <!-- The 'loca' table will be calculated by the compiler -->
+ </loca>
+
+ <glyf>
+
+ <!-- The xMin, yMin, xMax and yMax values
+ will be recalculated by the compiler. -->
+
+ <TTGlyph name=".notdef" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+200D" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F1E6" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F1E7" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F3FB" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F3FC" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B0" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B1" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B2" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B3" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B4" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B5" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B6" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B7" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B8" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B9" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+E0000" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+E0001" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="LigaForm1" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="LigaForm2" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="LigaForm3" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="LigaForm4" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="LigaForm5" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="LigaForm6" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="LigaForm7" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ </glyf>
+
+ <name>
+ <namerecord nameID="1" platformID="3" platEncID="1" langID="0x409">
+ EmojiBaseFont
+ </namerecord>
+ <namerecord nameID="2" platformID="3" platEncID="1" langID="0x409">
+ Regular
+ </namerecord>
+ <namerecord nameID="4" platformID="3" platEncID="1" langID="0x409">
+ EmojiBaseFont
+ </namerecord>
+ <namerecord nameID="6" platformID="3" platEncID="1" langID="0x409">
+ EmojiBaseFont
+ </namerecord>
+ </name>
+
+ <post>
+ <formatType value="3.0"/>
+ <italicAngle value="0.0"/>
+ <underlinePosition value="-75"/>
+ <underlineThickness value="50"/>
+ <isFixedPitch value="0"/>
+ <minMemType42 value="0"/>
+ <maxMemType42 value="0"/>
+ <minMemType1 value="0"/>
+ <maxMemType1 value="0"/>
+ </post>
+
+ <GSUB>
+ <Version value="0x00010000"/>
+ <ScriptList>
+ <ScriptRecord index="0">
+ <ScriptTag value="DFLT"/>
+ <Script>
+ <DefaultLangSys>
+ <ReqFeatureIndex value="65535"/>
+ <FeatureIndex index="0" value="0"/>
+ </DefaultLangSys>
+ </Script>
+ </ScriptRecord>
+ </ScriptList>
+ <FeatureList>
+ <FeatureRecord index="0">
+ <FeatureTag value="ccmp"/>
+ <Feature>
+ <LookupListIndex index="0" value="0"/>
+ </Feature>
+ </FeatureRecord>
+ </FeatureList>
+ <LookupList>
+ <Lookup index="0">
+ <LookupType value="4"/>
+ <LookupFlag value="0"/>
+ <LigatureSubst index="0" Format="1">
+ <LigatureSet glyph="U+1F9B0">
+ <!-- U+1F9B0 U+1F3FB -> LigaForm1 -->
+ <Ligature components="U+1F3FB" glyph="LigaForm1"/>
+
+ <!-- U+1F9B0 U+1F3FC -> LigaForm2 -->
+ <Ligature components="U+1F3FC" glyph="LigaForm2"/>
+ </LigatureSet>
+ <LigatureSet glyph="U+1F9B1">
+ <!-- U+1F9B1 U+1F3FB -> LigaForm3 -->
+ <Ligature components="U+1F3FB" glyph="LigaForm3"/>
+ </LigatureSet>
+ <LigatureSet glyph="U+1F9B2">
+ <Ligature components="U+200D,U+1F9B3,U+200D,U+1F9B4" glyph="LigaForm4"/>
+ </LigatureSet>
+ <LigatureSet glyph="U+1F9B6">
+ <!-- U+1F9B6 U+1F3FB -> LigaForm3 -->
+ <Ligature components="U+1F3FB" glyph="LigaForm3"/>
+ </LigatureSet>
+ <LigatureSet glyph="U+1F1E6">
+ <Ligature components="U+1F1E6" glyph="LigaForm6"/>
+ <Ligature components="U+1F1E7" glyph="LigaForm7"/>
+ </LigatureSet>
+ </LigatureSubst>
+ </Lookup>
+ </LookupList>
+ </GSUB>
+</ttFont>
diff --git a/tests/data/OverrideEmoji.ttf b/tests/data/OverrideEmoji.ttf
new file mode 100644
index 0000000..890796b
--- /dev/null
+++ b/tests/data/OverrideEmoji.ttf
Binary files differ
diff --git a/tests/data/OverrideEmoji.ttx b/tests/data/OverrideEmoji.ttx
new file mode 100644
index 0000000..d5d4091
--- /dev/null
+++ b/tests/data/OverrideEmoji.ttx
@@ -0,0 +1,521 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (C) 2021 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.
+-->
+<ttFont sfntVersion="\x00\x01\x00\x00" ttLibVersion="3.9">
+
+ <GlyphOrder>
+ <!-- The 'id' attribute is only for humans; it is ignored when parsed. -->
+ <GlyphID id="0" name=".notdef"/>
+
+ <!-- Compbining characters for Emoji -->
+ <GlyphID id="1" name="U+200D"/>
+ <GlyphID id="2" name="U+1F3FB"/>
+ <GlyphID id="3" name="U+1F3FC"/>
+
+ <!-- Random Emoji -->
+ <GlyphID id="4" name="U+1F9B0"/>
+ <GlyphID id="5" name="U+1F9B1"/>
+ <GlyphID id="6" name="U+1F9B2"/>
+ <GlyphID id="7" name="U+1F9B3"/>
+ <GlyphID id="8" name="U+1F9B4"/>
+ <GlyphID id="9" name="U+1F9B5"/>
+ <!--
+ Following four glyphs are removed from EmojiBase.ttf for verifying fallback.
+ <GlyphID id="10" name="U+1F9B6"/>
+ <GlyphID id="11" name="U+1F9B7"/>
+ <GlyphID id="12" name="U+1F9B8"/>
+ <GlyphID id="13" name="U+1F9B9"/>
+ -->
+
+ <!-- Unassigned Code Points -->
+ <GlyphID id="14" name="U+E0000"/>
+ <!--
+ Following glyph is removed from EmojiBase.ttf for verifying fallback.
+ <GlyphID id="15" name="U+E0001"/>
+ -->
+
+ <!-- Ligature Form. Not in cmap -->
+ <GlyphID id="16" name="LigaForm1"/>
+ <GlyphID id="17" name="LigaForm2"/>
+ <GlyphID id="18" name="LigaForm3"/>
+ <!--
+ Following glyphs are removed from EmojiBase.ttf for verifying fallback.
+ <GlyphID id="19" name="LigaForm4"/>
+ <GlyphID id="20" name="LigaForm5"/>
+ -->
+ <GlyphID id="21" name="LigaForm6"/>
+ <!--
+ Following glyph is removed from EmojiBase.ttf for verifying fallback.
+ <GlyphID id="22" name="LigaForm7"/>
+ -->
+
+ <GlyphID id="23" name="U+1F1E6"/>
+ <GlyphID id="24" name="U+1F1E7"/>
+ </GlyphOrder>
+
+ <head>
+ <!-- Most of this table will be recalculated by the compiler -->
+ <tableVersion value="1.0"/>
+ <fontRevision value="1.0"/>
+ <checkSumAdjustment value="0x640cdb2f"/>
+ <magicNumber value="0x5f0f3cf5"/>
+ <flags value="00000000 00000011"/>
+ <unitsPerEm value="1000"/>
+ <created value="Wed Sep 9 08:01:17 2015"/>
+ <modified value="Wed Sep 9 08:48:07 2015"/>
+ <xMin value="0"/>
+ <yMin value="0"/>
+ <xMax value="0"/>
+ <yMax value="0"/>
+ <macStyle value="00000000 00000000"/>
+ <lowestRecPPEM value="7"/>
+ <fontDirectionHint value="2"/>
+ <indexToLocFormat value="0"/>
+ <glyphDataFormat value="0"/>
+ </head>
+
+ <hhea>
+ <tableVersion value="0x00010000"/>
+ <ascent value="1000"/>
+ <descent value="-200"/>
+ <lineGap value="0"/>
+ <advanceWidthMax value="500"/>
+ <minLeftSideBearing value="0"/>
+ <minRightSideBearing value="0"/>
+ <xMaxExtent value="0"/>
+ <caretSlopeRise value="1"/>
+ <caretSlopeRun value="0"/>
+ <caretOffset value="0"/>
+ <reserved0 value="0"/>
+ <reserved1 value="0"/>
+ <reserved2 value="0"/>
+ <reserved3 value="0"/>
+ <metricDataFormat value="0"/>
+ <numberOfHMetrics value="1"/>
+ </hhea>
+
+ <maxp>
+ <!-- Most of this table will be recalculated by the compiler -->
+ <tableVersion value="0x10000"/>
+ <numGlyphs value="8"/>
+ <maxPoints value="0"/>
+ <maxContours value="0"/>
+ <maxCompositePoints value="0"/>
+ <maxCompositeContours value="0"/>
+ <maxZones value="2"/>
+ <maxTwilightPoints value="12"/>
+ <maxStorage value="28"/>
+ <maxFunctionDefs value="119"/>
+ <maxInstructionDefs value="0"/>
+ <maxStackElements value="61"/>
+ <maxSizeOfInstructions value="2967"/>
+ <maxComponentElements value="0"/>
+ <maxComponentDepth value="0"/>
+ </maxp>
+
+ <OS_2>
+ <!-- The fields 'usFirstCharIndex' and 'usLastCharIndex'
+ will be recalculated by the compiler -->
+ <version value="3"/>
+ <xAvgCharWidth value="594"/>
+ <usWeightClass value="400"/>
+ <usWidthClass value="5"/>
+ <fsType value="00000000 00001000"/>
+ <ySubscriptXSize value="650"/>
+ <ySubscriptYSize value="600"/>
+ <ySubscriptXOffset value="0"/>
+ <ySubscriptYOffset value="75"/>
+ <ySuperscriptXSize value="650"/>
+ <ySuperscriptYSize value="600"/>
+ <ySuperscriptXOffset value="0"/>
+ <ySuperscriptYOffset value="350"/>
+ <yStrikeoutSize value="50"/>
+ <yStrikeoutPosition value="300"/>
+ <sFamilyClass value="0"/>
+ <panose>
+ <bFamilyType value="0"/>
+ <bSerifStyle value="0"/>
+ <bWeight value="5"/>
+ <bProportion value="0"/>
+ <bContrast value="0"/>
+ <bStrokeVariation value="0"/>
+ <bArmStyle value="0"/>
+ <bLetterForm value="0"/>
+ <bMidline value="0"/>
+ <bXHeight value="0"/>
+ </panose>
+ <ulUnicodeRange1 value="00000000 00000000 00000000 00000001"/>
+ <ulUnicodeRange2 value="00000000 00000000 00000000 00000000"/>
+ <ulUnicodeRange3 value="00000000 00000000 00000000 00000000"/>
+ <ulUnicodeRange4 value="00000000 00000000 00000000 00000000"/>
+ <achVendID value="UKWN"/>
+ <fsSelection value="00000000 01000000"/>
+ <usFirstCharIndex value="48"/>
+ <usLastCharIndex value="65535"/>
+ <sTypoAscender value="800"/>
+ <sTypoDescender value="-200"/>
+ <sTypoLineGap value="200"/>
+ <usWinAscent value="1000"/>
+ <usWinDescent value="200"/>
+ <ulCodePageRange1 value="00000000 00000000 00000000 00000001"/>
+ <ulCodePageRange2 value="00000000 00000000 00000000 00000000"/>
+ <sxHeight value="500"/>
+ <sCapHeight value="700"/>
+ <usDefaultChar value="0"/>
+ <usBreakChar value="32"/>
+ <usMaxContext value="0"/>
+ </OS_2>
+
+ <hmtx>
+ <mtx name=".notdef" width="500" lsb="93"/>
+ <mtx name="U+200D" width="500" lsb="93"/>
+ <mtx name="U+1F1E6" width="500" lsb="93"/>
+ <mtx name="U+1F1E7" width="500" lsb="93"/>
+ <mtx name="U+1F3FB" width="500" lsb="93"/>
+ <mtx name="U+1F3FC" width="500" lsb="93"/>
+ <mtx name="U+1F9B0" width="500" lsb="93"/>
+ <mtx name="U+1F9B1" width="500" lsb="93"/>
+ <mtx name="U+1F9B2" width="500" lsb="93"/>
+ <mtx name="U+1F9B3" width="500" lsb="93"/>
+ <mtx name="U+1F9B4" width="500" lsb="93"/>
+ <mtx name="U+1F9B5" width="500" lsb="93"/>
+ <!--
+ Following four glyphs are removed from EmojiBase.ttf for verifying fallback.
+ <mtx name="U+1F9B6" width="500" lsb="93"/>
+ <mtx name="U+1F9B7" width="500" lsb="93"/>
+ <mtx name="U+1F9B8" width="500" lsb="93"/>
+ <mtx name="U+1F9B9" width="500" lsb="93"/>
+ -->
+ <mtx name="U+E0000" width="500" lsb="93"/>
+ <!--
+ Following glyph is removed from EmojiBase.ttf for verifying fallback.
+ <mtx name="U+1F9B6" width="500" lsb="93"/>
+ -->
+ <mtx name="U+E0001" width="500" lsb="93"/>
+ <mtx name="LigaForm1" width="500" lsb="93"/>
+ <mtx name="LigaForm2" width="500" lsb="93"/>
+ <mtx name="LigaForm3" width="500" lsb="93"/>
+ <!--
+ Following two glyphs are removed from EmojiBase.ttf for verifying fallback.
+ <mtx name="LigaForm4" width="500" lsb="93"/>
+ <mtx name="LigaForm5" width="500" lsb="93"/>
+ -->
+ <mtx name="LigaForm6" width="500" lsb="93"/>
+ <!--
+ Following glyph is removed from EmojiBase.ttf for verifying fallback.
+ <mtx name="LigaForm7" width="500" lsb="93"/>
+ -->
+ </hmtx>
+
+ <cmap>
+ <tableVersion version="0"/>
+ <cmap_format_12 format="12" reserved="0" length="3" nGroups="6" platformID="3" platEncID="1" language="0">
+ <map code="0x200D" name="U+200D" />
+ <map code="0x1F1E6" name="U+1F1E6" />
+ <map code="0x1F1E7" name="U+1F1E7" />
+ <map code="0x1F3FB" name="U+1F3FB" />
+ <map code="0x1F3FC" name="U+1F3FC" />
+ <map code="0x1F9B0" name="U+1F9B0" />
+ <map code="0x1F9B1" name="U+1F9B1" />
+ <map code="0x1F9B2" name="U+1F9B2" />
+ <map code="0x1F9B3" name="U+1F9B3" />
+ <map code="0x1F9B4" name="U+1F9B4" />
+ <map code="0x1F9B5" name="U+1F9B5" />
+ <!--
+ Following four glyphs are removed from EmojiBase.ttf for verifying fallback.
+ <map code="0x1F9B6" name="U+1F9B6" />
+ <map code="0x1F9B7" name="U+1F9B7" />
+ <map code="0x1F9B8" name="U+1F9B8" />
+ <map code="0x1F9B9" name="U+1F9B9" />
+ -->
+ <map code="0xE0000" name="U+E0000" />
+ <!--
+ Following glyph is removed from EmojiBase.ttf for verifying fallback.
+ <map code="0xE0001" name="U+E0001" />
+ -->
+ </cmap_format_12>
+ </cmap>
+
+ <loca>
+ <!-- The 'loca' table will be calculated by the compiler -->
+ </loca>
+
+ <glyf>
+
+ <!-- The xMin, yMin, xMax and yMax values
+ will be recalculated by the compiler. -->
+
+ <TTGlyph name=".notdef" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+200D" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F1E6" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F1E7" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F3FB" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F3FC" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B0" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B1" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B2" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B3" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B4" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="U+1F9B5" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <!--
+ Following four glyphs are removed from EmojiBase.ttf for verifying fallback.
+ <TTGlyph name="U+1F9B6">
+ <TTGlyph name="U+1F9B7">
+ <TTGlyph name="U+1F9B8">
+ <TTGlyph name="U+1F9B9">
+ -->
+ <TTGlyph name="U+E0000" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <!--
+ Following glyph is removed from EmojiBase.ttf for verifying fallback.
+ <TTGlyph name="U+E0001"/>
+ -->
+ <TTGlyph name="LigaForm1" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="LigaForm2" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <TTGlyph name="LigaForm3" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <!--
+ Following two glyphs are removed from EmojiBase.ttf for verifying fallback.
+ <TTGlyph name="LigaForm4">
+ <TTGlyph name="LigaForm5">
+ -->
+ <TTGlyph name="LigaForm6" xMin="0" yMin="0" xMax="100" yMax="100">
+ <contour>
+ <pt x="0" y="0" on="1" />
+ <pt x="100" y="0" on="1" />
+ <pt x="100" y="100" on="1" />
+ <pt x="0" y="100" on="1" />
+ </contour>
+ <instructions><assembly></assembly></instructions>
+ </TTGlyph>
+ <!--
+ Following glyph is removed from EmojiBase.ttf for verifying fallback.
+ <TTGlyph name="LigaForm7">
+ -->
+ </glyf>
+
+ <name>
+ <namerecord nameID="1" platformID="3" platEncID="1" langID="0x409">
+ OverrideEmojiFont
+ </namerecord>
+ <namerecord nameID="2" platformID="3" platEncID="1" langID="0x409">
+ Regular
+ </namerecord>
+ <namerecord nameID="4" platformID="3" platEncID="1" langID="0x409">
+ OverrideEmojiFont
+ </namerecord>
+ <namerecord nameID="6" platformID="3" platEncID="1" langID="0x409">
+ OverrideEmojiFont
+ </namerecord>
+ </name>
+
+ <post>
+ <formatType value="3.0"/>
+ <italicAngle value="0.0"/>
+ <underlinePosition value="-75"/>
+ <underlineThickness value="50"/>
+ <isFixedPitch value="0"/>
+ <minMemType42 value="0"/>
+ <maxMemType42 value="0"/>
+ <minMemType1 value="0"/>
+ <maxMemType1 value="0"/>
+ </post>
+
+ <GSUB>
+ <Version value="0x00010000"/>
+ <ScriptList>
+ <ScriptRecord index="0">
+ <ScriptTag value="DFLT"/>
+ <Script>
+ <DefaultLangSys>
+ <ReqFeatureIndex value="65535"/>
+ <FeatureIndex index="0" value="0"/>
+ </DefaultLangSys>
+ </Script>
+ </ScriptRecord>
+ </ScriptList>
+ <FeatureList>
+ <FeatureRecord index="0">
+ <FeatureTag value="ccmp"/>
+ <Feature>
+ <LookupListIndex index="0" value="0"/>
+ </Feature>
+ </FeatureRecord>
+ </FeatureList>
+ <LookupList>
+ <Lookup index="0">
+ <LookupType value="4"/>
+ <LookupFlag value="0"/>
+ <LigatureSubst index="0" Format="1">
+ <LigatureSet glyph="U+1F9B0">
+ <!-- U+1F9B0 U+1F3FB -> LigaForm0 -->
+ <Ligature components="U+1F3FB" glyph="LigaForm1"/>
+
+ <!-- U+1F9B0 U+1F3FC -> LigaForm1 -->
+ <!--
+ Following ligature is removed from the EmojiBase.ttf for verifying fallback
+ <Ligature components="U+1F3FC" glyph="LigaForm2"/>
+ -->
+ </LigatureSet>
+ <!--
+ Following ligature is removed from the EmojiBase.ttf for verifying fallback
+ <LigatureSet glyph="U+1F9B1">
+ <Ligature components="U+1F3FB" glyph="LigaForm3"/>
+ </LigatureSet>
+ -->
+ <LigatureSet glyph="U+1F9B2">
+ <Ligature components="U+200D,U+1F9B3" glyph="LigaForm3"/>
+ </LigatureSet>
+ <!--
+ Following ligature is removed from the EmojIBase.ttf for verifying fallback.
+ <LigatureSet glyph="U+1F9B6">
+ <Ligature components="U+1F3FB" glyph="LigaForm3"/>
+ </LigatureSet>
+ -->
+ <LigatureSet glyph="U+1F1E6">
+ <Ligature components="U+1F1E6" glyph="LigaForm6"/>
+ <Ligature components="U+1F1E7" glyph=".notdef"/>
+ </LigatureSet>
+ </LigatureSubst>
+ </Lookup>
+ </LookupList>
+ </GSUB>
+</ttFont>
diff --git a/tests/data/emoji_itemization.xml b/tests/data/emoji_itemization.xml
new file mode 100644
index 0000000..d4213f9
--- /dev/null
+++ b/tests/data/emoji_itemization.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 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.
+-->
+<familyset version="22">
+ <!-- Place NoGlyphFont here since the first font can be chosen if no font is
+ available for the code point. -->
+ <family>
+ <font weight="400" style="normal">Ascii.ttf</font>
+ </family>
+ <family lang="und-Zsye">
+ <font weight="400" style="normal">EmojiSubset.ttf</font>
+ </family>
+ <family lang="und-Zsye">
+ <font weight="400" style="normal">EmojiBase.ttf</font>
+ </family>
+</familyset>
diff --git a/tests/stresstest/FontFamilyTest.cpp b/tests/stresstest/FontFamilyTest.cpp
index 7554314..7a9813e 100644
--- a/tests/stresstest/FontFamilyTest.cpp
+++ b/tests/stresstest/FontFamilyTest.cpp
@@ -36,7 +36,7 @@
int ttcIndex = GetParam().second;
auto font = std::make_shared<FreeTypeMinikinFontForTest>(fontPath);
- std::vector<Font> fonts;
+ std::vector<std::shared_ptr<Font>> fonts;
fonts.push_back(Font::Builder(font).build());
std::shared_ptr<FontFamily> family = std::make_shared<FontFamily>(std::move(fonts));
diff --git a/tests/unittest/Android.bp b/tests/unittest/Android.bp
index e47030a..cae9003 100644
--- a/tests/unittest/Android.bp
+++ b/tests/unittest/Android.bp
@@ -45,12 +45,15 @@
srcs: [
"AndroidLineBreakerHelperTest.cpp",
"BidiUtilsTest.cpp",
+ "BufferTest.cpp",
+ "BoundsCacheTest.cpp",
"CmapCoverageTest.cpp",
"EmojiTest.cpp",
"FontTest.cpp",
"FontCollectionTest.cpp",
"FontCollectionItemizeTest.cpp",
"FontFamilyTest.cpp",
+ "FontFileParserTest.cpp",
"FontLanguageListCacheTest.cpp",
"FontUtilsTest.cpp",
"HasherTest.cpp",
diff --git a/tests/unittest/BoundsCacheTest.cpp b/tests/unittest/BoundsCacheTest.cpp
new file mode 100644
index 0000000..8c727f9
--- /dev/null
+++ b/tests/unittest/BoundsCacheTest.cpp
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+#include <gtest/gtest.h>
+
+#include "minikin/BoundsCache.h"
+
+#include "FontTestUtils.h"
+#include "LocaleListCache.h"
+#include "UnicodeUtils.h"
+
+namespace minikin {
+
+class TestableBoundsCache : public BoundsCache {
+public:
+ TestableBoundsCache(uint32_t maxEntries) : BoundsCache(maxEntries) {}
+};
+
+class BoundsCapture {
+public:
+ BoundsCapture() {}
+
+ void operator()(const MinikinRect& rect, float advance) {
+ mRect = rect;
+ mAdvance = advance;
+ }
+
+ const MinikinRect& rect() const { return mRect; }
+ float advance() const { return mAdvance; }
+
+private:
+ MinikinRect mRect;
+ float mAdvance;
+};
+
+TEST(BoundsCacheTest, cacheHitTest) {
+ auto text = utf8ToUtf16("android");
+ Range range(0, text.size());
+ MinikinPaint paint(buildFontCollection("Ascii.ttf"));
+
+ TestableBoundsCache boundsCache(10);
+
+ BoundsCapture bounds1;
+ boundsCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, bounds1);
+
+ BoundsCapture bounds2;
+ boundsCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, bounds2);
+
+ EXPECT_EQ(bounds1.rect(), bounds2.rect());
+ EXPECT_EQ(bounds1.advance(), bounds2.advance());
+}
+
+TEST(BoundsCacheTest, cacheMissTest) {
+ auto text1 = utf8ToUtf16("android");
+ auto text2 = utf8ToUtf16("αβγδζ");
+ MinikinPaint paint(buildFontCollection("Ascii.ttf"));
+
+ TestableBoundsCache boundsCache(10);
+
+ BoundsCapture bounds1;
+ BoundsCapture bounds2;
+
+ {
+ SCOPED_TRACE("Different text");
+ boundsCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds1);
+ boundsCache.getOrCreate(text2, Range(0, text2.size()), paint, false /* LTR */,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
+ EXPECT_NE(bounds1.rect(), bounds2.rect());
+ EXPECT_NE(bounds1.advance(), bounds2.advance());
+ }
+ {
+ SCOPED_TRACE("Different range");
+ boundsCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds1);
+ boundsCache.getOrCreate(text1, Range(1, text1.size()), paint, false /* LTR */,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
+ EXPECT_NE(bounds1.rect(), bounds2.rect());
+ EXPECT_NE(bounds1.advance(), bounds2.advance());
+ }
+ {
+ SCOPED_TRACE("Different collection");
+ MinikinPaint paint1(buildFontCollection("Ascii.ttf"));
+ paint1.size = 10.0f;
+ paint1.scaleX = 1.0f;
+ boundsCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds1);
+ MinikinPaint paint2(buildFontCollection("Emoji.ttf"));
+ paint2.size = 10.0f;
+ paint2.scaleX = 1.0f;
+ boundsCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
+ EXPECT_NE(bounds1.rect(), bounds2.rect());
+ EXPECT_NE(bounds1.advance(), bounds2.advance());
+ }
+ {
+ SCOPED_TRACE("Different size");
+ auto collection = buildFontCollection("Ascii.ttf");
+ MinikinPaint paint1(collection);
+ paint1.size = 10.0f;
+ paint1.scaleX = 1.0f;
+ boundsCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds1);
+ MinikinPaint paint2(collection);
+ paint2.size = 20.0f;
+ paint2.scaleX = 1.0f;
+ boundsCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
+ EXPECT_NE(bounds1.rect(), bounds2.rect());
+ EXPECT_NE(bounds1.advance(), bounds2.advance());
+ }
+ {
+ SCOPED_TRACE("Different letter spacing");
+ auto collection = buildFontCollection("Ascii.ttf");
+ MinikinPaint paint1(collection);
+ paint1.letterSpacing = 0.0f;
+ paint1.size = 10.0f;
+ paint1.scaleX = 1.0f;
+ boundsCache.getOrCreate(text1, Range(0, text1.size()), paint1, false /* LTR */,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds1);
+ MinikinPaint paint2(collection);
+ paint2.letterSpacing = 1.0f;
+ paint2.size = 10.0f;
+ paint2.scaleX = 1.0f;
+ boundsCache.getOrCreate(text1, Range(0, text1.size()), paint2, false /* LTR */,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
+ EXPECT_NE(bounds1.rect(), bounds2.rect());
+ EXPECT_NE(bounds1.advance(), bounds2.advance());
+ }
+}
+
+TEST(BoundsCacheTest, cacheOverflowTest) {
+ auto text = utf8ToUtf16("android");
+ Range range(0, text.size());
+ MinikinPaint paint(buildFontCollection("Ascii.ttf"));
+
+ TestableBoundsCache boundsCache(5);
+
+ BoundsCapture bounds1;
+ boundsCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, bounds1);
+
+ for (char c = 'a'; c <= 'z'; c++) {
+ auto text1 = utf8ToUtf16(std::string(10, c));
+ BoundsCapture bounds2;
+ boundsCache.getOrCreate(text1, Range(0, text1.size()), paint, false /* LTR */,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, bounds2);
+ }
+
+ BoundsCapture bounds3;
+ boundsCache.getOrCreate(text, range, paint, false /* LTR */, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, bounds3);
+ EXPECT_EQ(bounds1.rect(), bounds3.rect());
+ EXPECT_EQ(bounds1.advance(), bounds3.advance());
+}
+
+} // namespace minikin
diff --git a/tests/unittest/BufferTest.cpp b/tests/unittest/BufferTest.cpp
new file mode 100644
index 0000000..8b1db33
--- /dev/null
+++ b/tests/unittest/BufferTest.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2020 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.
+ */
+
+#include "minikin/Buffer.h"
+
+#include <gtest/gtest.h>
+
+namespace minikin {
+
+class TestObject {
+public:
+ void writeTo(BufferWriter* writer) const {
+ // Total size = 20
+ // uint8_t (1)
+ writer->write<uint8_t>(0xAB);
+ // padding (1), uint16_t (2)
+ writer->write<uint16_t>(0xCDEF);
+ // uint8_t(1)
+ writer->write<uint8_t>(0x01);
+ // padding (3), array size (4), uint32_t (4) * 2
+ uint32_t uint32Array[] = {0x98765432, 0x98765433};
+ writer->writeArray<uint32_t>(uint32Array, 2);
+ }
+};
+
+TEST(BufferTest, testMeasureWriteRead) {
+ TestObject testObject;
+ BufferWriter fakeWriter(nullptr);
+ testObject.writeTo(&fakeWriter);
+ ASSERT_EQ(fakeWriter.size(), 20u);
+ std::vector<uint8_t> buffer(fakeWriter.size());
+
+ BufferWriter writer(buffer.data());
+ testObject.writeTo(&writer);
+ ASSERT_EQ(writer.size(), buffer.size());
+
+ BufferReader reader(buffer.data());
+ ASSERT_EQ(reader.data(), buffer.data());
+ ASSERT_EQ(reader.pos(), 0u);
+ ASSERT_EQ(reader.read<uint8_t>(), 0xABu);
+ ASSERT_EQ(reader.pos(), 1u);
+ ASSERT_EQ(reader.read<uint16_t>(), 0xCDEFu);
+ ASSERT_EQ(reader.pos(), 4u);
+ ASSERT_EQ(reader.read<uint8_t>(), 0x01u);
+ ASSERT_EQ(reader.pos(), 5u);
+ auto [uint32Array, size] = reader.readArray<uint32_t>();
+ ASSERT_EQ(size, 2u);
+ ASSERT_EQ(uint32Array[0], 0x98765432u);
+ ASSERT_EQ(uint32Array[1], 0x98765433u);
+ ASSERT_EQ(reader.pos(), 20u);
+}
+
+TEST(BufferTest, testSkip) {
+ TestObject testObject;
+ BufferWriter fakeWriter(nullptr);
+ testObject.writeTo(&fakeWriter);
+ ASSERT_EQ(fakeWriter.size(), 20u);
+ std::vector<uint8_t> buffer(fakeWriter.size());
+
+ BufferWriter writer(buffer.data());
+ testObject.writeTo(&writer);
+ ASSERT_EQ(writer.size(), buffer.size());
+
+ BufferReader reader(buffer.data());
+ ASSERT_EQ(reader.data(), buffer.data());
+ ASSERT_EQ(reader.pos(), 0u);
+ reader.skip<uint8_t>();
+ ASSERT_EQ(reader.pos(), 1u);
+ reader.read<uint16_t>();
+ ASSERT_EQ(reader.pos(), 4u);
+ reader.skip<uint8_t>();
+ ASSERT_EQ(reader.pos(), 5u);
+ reader.skipArray<uint32_t>();
+ ASSERT_EQ(reader.pos(), 20u);
+}
+
+} // namespace minikin
diff --git a/tests/unittest/FontCollectionItemizeTest.cpp b/tests/unittest/FontCollectionItemizeTest.cpp
index 8cd95aa..6f1e194 100644
--- a/tests/unittest/FontCollectionItemizeTest.cpp
+++ b/tests/unittest/FontCollectionItemizeTest.cpp
@@ -21,6 +21,7 @@
#include <gtest/gtest.h>
#include "minikin/FontFamily.h"
+#include "minikin/FontFileParser.h"
#include "minikin/LocaleList.h"
#include "minikin/MinikinPaint.h"
@@ -55,10 +56,15 @@
const char kHasCmapFormat14Font[] = "NoCmapFormat14.ttf";
const char kNoCmapFormat14Font[] = "VariationSelectorTest-Regular.ttf";
+struct Run {
+ FakedFont fakedFont;
+ int start;
+ int end;
+};
+
// Utility functions for calling itemize function.
-std::vector<FontCollection::Run> itemize(const std::shared_ptr<FontCollection>& collection,
- const char* str, FontStyle style,
- const std::string& localeList) {
+std::vector<Run> itemize(const std::shared_ptr<FontCollection>& collection, const char* str,
+ FontStyle style, const std::string& localeList) {
const size_t BUF_SIZE = 256;
uint16_t buf[BUF_SIZE];
size_t len;
@@ -76,35 +82,38 @@
for (uint32_t i = 0; i < runMax; ++i) {
EXPECT_EQ(result[i].start, resultWithRunMax[i].start);
EXPECT_EQ(result[i].end, resultWithRunMax[i].end);
- EXPECT_EQ(result[i].fakedFont, resultWithRunMax[i].fakedFont);
+ EXPECT_EQ(result[i].familyMatch, resultWithRunMax[i].familyMatch);
}
}
- return result;
+ std::vector<Run> runs;
+ for (const auto& r : result) {
+ runs.push_back(
+ {collection->getBestFont(U16StringPiece(buf, len), r, style), r.start, r.end});
+ }
+ return runs;
}
// Overloaded version for default font style.
-std::vector<FontCollection::Run> itemize(const std::shared_ptr<FontCollection>& collection,
- const char* str, const std::string& localeList) {
+std::vector<Run> itemize(const std::shared_ptr<FontCollection>& collection, const char* str,
+ const std::string& localeList) {
return itemize(collection, str, FontStyle(), localeList);
}
// Overloaded version for empty locale list id.
-std::vector<FontCollection::Run> itemize(const std::shared_ptr<FontCollection>& collection,
- const char* str, FontStyle style) {
+std::vector<Run> itemize(const std::shared_ptr<FontCollection>& collection, const char* str,
+ FontStyle style) {
return itemize(collection, str, style, "");
}
// Overloaded version for default font style and empty locale list id.
-std::vector<FontCollection::Run> itemize(const std::shared_ptr<FontCollection>& collection,
- const char* str) {
+std::vector<Run> itemize(const std::shared_ptr<FontCollection>& collection, const char* str) {
return itemize(collection, str, FontStyle(), "");
}
// Utility function to obtain font path associated with run.
-std::string getFontName(const FontCollection::Run& run) {
- EXPECT_NE(nullptr, run.fakedFont.font);
- return getBasename(
- ((FreeTypeMinikinFontForTest*)run.fakedFont.font->typeface().get())->fontPath());
+std::string getFontName(const Run& run) {
+ EXPECT_NE(nullptr, run.fakedFont.font.get());
+ return getBasename(run.fakedFont.font.get()->typeface()->GetFontPath());
}
// Utility function to obtain LocaleList from string.
@@ -515,13 +524,13 @@
ASSERT_EQ(1U, runs.size());
EXPECT_EQ(0, runs[0].start);
EXPECT_EQ(1, runs[0].end);
- EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontName(runs[0]));
+ EXPECT_TRUE(runs[0].fakedFont.font.get() == nullptr || kLatinFont == getFontName(runs[0]));
runs = itemize(collection, "U+FE00", "zh-Hant");
ASSERT_EQ(1U, runs.size());
EXPECT_EQ(0, runs[0].start);
EXPECT_EQ(1, runs[0].end);
- EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontName(runs[0]));
+ EXPECT_TRUE(runs[0].fakedFont.font.get() == nullptr || kLatinFont == getFontName(runs[0]));
// First font family (Regular.ttf) supports U+203C but doesn't support U+203C U+FE0F.
// Emoji.ttf font supports U+203C U+FE0F. Emoji.ttf should be selected.
@@ -652,13 +661,13 @@
ASSERT_EQ(1U, runs.size());
EXPECT_EQ(0, runs[0].start);
EXPECT_EQ(2, runs[0].end);
- EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontName(runs[0]));
+ EXPECT_TRUE(runs[0].fakedFont.font.get() == nullptr || kLatinFont == getFontName(runs[0]));
runs = itemize(collection, "U+E0100", "zh-Hant");
ASSERT_EQ(1U, runs.size());
EXPECT_EQ(0, runs[0].start);
EXPECT_EQ(2, runs[0].end);
- EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontName(runs[0]));
+ EXPECT_TRUE(runs[0].fakedFont.font.get() == nullptr || kLatinFont == getFontName(runs[0]));
}
TEST(FontCollectionItemizeTest, itemize_no_crash) {
@@ -926,7 +935,7 @@
// Prepare first font which doesn't supports U+9AA8
auto firstFamilyMinikinFont =
std::make_shared<FreeTypeMinikinFontForTest>(getTestFontPath(kNoGlyphFont));
- std::vector<Font> fonts;
+ std::vector<std::shared_ptr<Font>> fonts;
fonts.push_back(Font::Builder(firstFamilyMinikinFont).build());
auto firstFamily =
std::make_shared<FontFamily>(registerLocaleList("und"), FamilyVariant::DEFAULT,
@@ -941,7 +950,7 @@
for (size_t i = 0; i < testCase.fontLocales.size(); ++i) {
auto minikinFont =
std::make_shared<FreeTypeMinikinFontForTest>(getTestFontPath(kJAFont));
- std::vector<Font> fonts;
+ std::vector<std::shared_ptr<Font>> fonts;
fonts.push_back(Font::Builder(minikinFont).build());
auto family = std::make_shared<FontFamily>(registerLocaleList(testCase.fontLocales[i]),
FamilyVariant::DEFAULT, std::move(fonts),
@@ -953,14 +962,15 @@
// Do itemize
auto runs = itemize(collection, "U+9AA8", testCase.userPreferredLocale);
ASSERT_EQ(1U, runs.size());
- ASSERT_NE(nullptr, runs[0].fakedFont.font);
+ ASSERT_NE(nullptr, runs[0].fakedFont.font.get());
// First family doesn't support U+9AA8 and others support it, so the first font should not
// be selected.
- EXPECT_NE(firstFamilyMinikinFont.get(), runs[0].fakedFont.font->typeface().get());
+ EXPECT_NE(firstFamilyMinikinFont.get(), runs[0].fakedFont.font.get()->typeface().get());
// Lookup used font family by MinikinFont*.
- const int usedLocaleIndex = fontLocaleIdxMap[runs[0].fakedFont.font->typeface().get()];
+ const int usedLocaleIndex =
+ fontLocaleIdxMap[runs[0].fakedFont.font.get()->typeface().get()];
EXPECT_EQ(testCase.selectedFontIndex, usedLocaleIndex);
}
}
@@ -1521,10 +1531,10 @@
// Both fontA/fontB support U+35A8 but don't support U+35A8 U+E0100. The first font should be
// selected.
auto runs = itemize(collection, "U+35A8 U+E0100");
- EXPECT_EQ(familyA->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(familyA->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(reversedCollection, "U+35A8 U+E0100");
- EXPECT_EQ(familyB->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(familyB->getFont(0), runs[0].fakedFont.font.get());
}
// For b/29585939
@@ -1544,10 +1554,10 @@
// Both hasCmapFormat14Font/noCmapFormat14Font support U+5380 but don't support U+5380 U+E0100.
// The first font should be selected.
auto runs = itemize(collection, "U+5380 U+E0100");
- EXPECT_EQ(hasCmapFormat14Family->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(hasCmapFormat14Family->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(reversedCollection, "U+5380 U+E0100");
- EXPECT_EQ(noCmapFormat14Family->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(noCmapFormat14Family->getFont(0), runs[0].fakedFont.font.get());
}
TEST(FontCollectionItemizeTest, colorEmojiSelectionTest) {
@@ -1561,44 +1571,44 @@
// Both textEmojiFamily and colorEmojiFamily supports U+203C and U+23E9.
// U+203C is text default emoji, and U+23E9 is color default emoji.
auto runs = itemize(collection, "U+203C", "en-US,en-Zsym");
- EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+23E9", "en-US,en-Zsym");
- EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+203C", "en-US,en-Zsye");
- EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+23E9", "en-US,en-Zsye");
- EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+203C", "ja-Zsym-JP");
- EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+23E9", "ja-Zsym-JP");
- EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+203C", "ja-Zsye-JP");
- EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+23E9", "ja-Zsye-JP");
- EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+203C", "ja-JP-u-em-text");
- EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+23E9", "ja-JP-u-em-text");
- EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+203C", "ja-JP-u-em-emoji");
- EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+23E9", "ja-JP-u-em-emoji");
- EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+203C", "ja-JP,und-Zsym");
- EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+23E9", "ja-JP,und-Zsym");
- EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(textEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+203C", "ja-JP,und-Zsye");
- EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "U+23E9", "ja-JP,und-Zsye");
- EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(colorEmojiFamily->getFont(0), runs[0].fakedFont.font.get());
}
TEST(FontCollectionItemizeTest, customFallbackTest) {
@@ -1612,11 +1622,60 @@
auto collection = std::make_shared<FontCollection>(families);
auto runs = itemize(collection, "'a'", "");
- EXPECT_EQ(customFallbackFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(customFallbackFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "'a'", "en-US");
- EXPECT_EQ(customFallbackFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(customFallbackFamily->getFont(0), runs[0].fakedFont.font.get());
runs = itemize(collection, "'a'", "ja-JP");
- EXPECT_EQ(customFallbackFamily->getFont(0), runs[0].fakedFont.font);
+ EXPECT_EQ(customFallbackFamily->getFont(0), runs[0].fakedFont.font.get());
+}
+
+std::string itemizeEmojiAndFontPostScriptName(const std::string& txt) {
+ auto firstFamily = buildFontFamily(kAsciiFont);
+ auto OverrideEmojiFamily = buildFontFamily("OverrideEmoji.ttf", "und-Zsye");
+ auto emojiBaseFamily = buildFontFamily("EmojiBase.ttf", "und-Zsye");
+
+ std::vector<std::shared_ptr<FontFamily>> families = {firstFamily, OverrideEmojiFamily,
+ emojiBaseFamily};
+
+ auto collection = std::make_shared<FontCollection>(families);
+ auto runs = itemize(collection, txt.c_str());
+
+ EXPECT_EQ(1u, runs.size());
+ return FontFileParser(runs[0].fakedFont.font->baseFont()).getPostScriptName().value();
+}
+
+TEST(FontCollectionItemizeTest, emojiFallback) {
+ // OverrideEmojiFont supports U+1F9B0, U+E0000, U+1F3FB and U+1F9B0 U+1F3FB sequence.
+ // Use Override font.
+ EXPECT_EQ("OverrideEmojiFont", itemizeEmojiAndFontPostScriptName("U+1F9B0"));
+ EXPECT_EQ("OverrideEmojiFont", itemizeEmojiAndFontPostScriptName("U+E0000"));
+ EXPECT_EQ("OverrideEmojiFont", itemizeEmojiAndFontPostScriptName("U+1F9B0 U+1F3FB"));
+ EXPECT_EQ("OverrideEmojiFont", itemizeEmojiAndFontPostScriptName("U+1F9B0 U+FE0F U+1F3FB"));
+
+ // OverrideEmojiFont doesn't suppot U+1F9B6 U+E0001 and U+1F3FC.
+ EXPECT_EQ("EmojiBaseFont", itemizeEmojiAndFontPostScriptName("U+1F9B6"));
+ EXPECT_EQ("EmojiBaseFont", itemizeEmojiAndFontPostScriptName("U+E0001"));
+ EXPECT_EQ("EmojiBaseFont", itemizeEmojiAndFontPostScriptName("U+1F9B6 U+1F3FC"));
+ EXPECT_EQ("EmojiBaseFont", itemizeEmojiAndFontPostScriptName("U+1F9B6 U+FE0F U+1F3FC"));
+
+ // OverrideEmojiFont support U+1F9B1, U+1F3FB but doesn't support the sequence U+1F9B1 U+1F3FB.
+ EXPECT_EQ("OverrideEmojiFont", itemizeEmojiAndFontPostScriptName("U+1F9B1"));
+ EXPECT_EQ("OverrideEmojiFont", itemizeEmojiAndFontPostScriptName("U+1F3FB"));
+ EXPECT_EQ("EmojiBaseFont", itemizeEmojiAndFontPostScriptName("U+1F9B1 U+1F3FB"));
+ EXPECT_EQ("EmojiBaseFont", itemizeEmojiAndFontPostScriptName("U+1F9B1 U+FE0F U+1F3FB"));
+
+ // Find the longest sequence if two sequences are supported.
+ EXPECT_EQ("OverrideEmojiFont", itemizeEmojiAndFontPostScriptName("U+1F9B2 U+200D U+1F9B3"));
+ EXPECT_EQ("EmojiBaseFont",
+ itemizeEmojiAndFontPostScriptName("U+1F9B2 U+200D U+1F9B3 U+200D U+1F9B4"));
+}
+
+TEST(FontCollectionItemizeTest, emojiFlagFallback) {
+ // If the OverrideEmojiFont supports U+1F1E6 U+1F1E6, use that font.
+ EXPECT_EQ("OverrideEmojiFont", itemizeEmojiAndFontPostScriptName("U+1F1E6 U+1F1E6"));
+
+ // Even if the OverrideEmojiFont directs to .notdef (i.e. Tofu glyph) for the sequence, use it.
+ EXPECT_EQ("OverrideEmojiFont", itemizeEmojiAndFontPostScriptName("U+1F1E6 U+1F1E7"));
}
} // namespace minikin
diff --git a/tests/unittest/FontCollectionTest.cpp b/tests/unittest/FontCollectionTest.cpp
index 6b39508..aa9d4a8 100644
--- a/tests/unittest/FontCollectionTest.cpp
+++ b/tests/unittest/FontCollectionTest.cpp
@@ -19,6 +19,7 @@
#include <gtest/gtest.h>
#include "FontTestUtils.h"
+#include "FreeTypeMinikinFontForTest.h"
#include "MinikinInternal.h"
namespace minikin {
@@ -56,22 +57,23 @@
}
}
-TEST(FontCollectionTest, hasVariationSelectorTest) {
- auto fc = buildFontCollection(kVsTestFont);
-
+void expectVSGlyphsForVsTestFont(const FontCollection* fc) {
EXPECT_FALSE(fc->hasVariationSelector(0x82A6, 0));
- expectVSGlyphs(fc.get(), 0x82A6,
- std::set<uint32_t>({0xFE00, 0xFE0E, 0xE0100, 0xE0101, 0xE0102}));
+ expectVSGlyphs(fc, 0x82A6, std::set<uint32_t>({0xFE00, 0xFE0E, 0xE0100, 0xE0101, 0xE0102}));
EXPECT_FALSE(fc->hasVariationSelector(0x845B, 0));
- expectVSGlyphs(fc.get(), 0x845B,
- std::set<uint32_t>({0xFE01, 0xFE0E, 0xE0101, 0xE0102, 0xE0103}));
+ expectVSGlyphs(fc, 0x845B, std::set<uint32_t>({0xFE01, 0xFE0E, 0xE0101, 0xE0102, 0xE0103}));
EXPECT_FALSE(fc->hasVariationSelector(0x537F, 0));
- expectVSGlyphs(fc.get(), 0x537F, std::set<uint32_t>({0xFE0E}));
+ expectVSGlyphs(fc, 0x537F, std::set<uint32_t>({0xFE0E}));
EXPECT_FALSE(fc->hasVariationSelector(0x717D, 0));
- expectVSGlyphs(fc.get(), 0x717D, std::set<uint32_t>({0xFE02, 0xE0102, 0xE0103}));
+ expectVSGlyphs(fc, 0x717D, std::set<uint32_t>({0xFE02, 0xE0102, 0xE0103}));
+}
+
+TEST(FontCollectionTest, hasVariationSelectorTest) {
+ auto fc = buildFontCollection(kVsTestFont);
+ expectVSGlyphsForVsTestFont(fc.get());
}
const char kEmojiXmlFile[] = "emoji.xml";
@@ -175,4 +177,144 @@
}
}
+std::vector<uint8_t> writeToBuffer(
+ const std::vector<std::shared_ptr<FontCollection>>& collections) {
+ BufferWriter fakeWriter(nullptr);
+ FontCollection::writeVector<writeFreeTypeMinikinFontForTest>(&fakeWriter, collections);
+ std::vector<uint8_t> buffer(fakeWriter.size());
+ BufferWriter writer(buffer.data());
+ FontCollection::writeVector<writeFreeTypeMinikinFontForTest>(&writer, collections);
+ return buffer;
+}
+
+TEST(FontCollectionTest, bufferTest) {
+ {
+ std::vector<std::shared_ptr<FontCollection>> original({buildFontCollection(kVsTestFont)});
+ std::vector<uint8_t> buffer = writeToBuffer(original);
+ BufferReader reader(buffer.data());
+ auto copied = FontCollection::readVector<readFreeTypeMinikinFontForTest>(&reader);
+ EXPECT_EQ(1u, copied.size());
+ expectVSGlyphsForVsTestFont(copied[0].get());
+ EXPECT_EQ(original[0]->getSupportedTags(), copied[0]->getSupportedTags());
+ // Id will be different.
+ EXPECT_NE(original[0]->getId(), copied[0]->getId());
+ std::vector<uint8_t> newBuffer = writeToBuffer(copied);
+ EXPECT_EQ(buffer, newBuffer);
+ }
+ {
+ // Test that FontFamily instances are shared.
+ std::vector<std::shared_ptr<FontFamily>> families = {buildFontFamily(kVsTestFont)};
+ auto fc1 = std::make_shared<FontCollection>(families);
+ auto fc2 = std::make_shared<FontCollection>(families);
+ std::vector<std::shared_ptr<FontCollection>> original({fc1, fc2});
+ std::vector<uint8_t> buffer = writeToBuffer(original);
+ BufferReader reader(buffer.data());
+ auto copied = FontCollection::readVector<readFreeTypeMinikinFontForTest>(&reader);
+ EXPECT_EQ(2u, copied.size());
+ EXPECT_EQ(copied[0]->mFamilies[0], copied[1]->mFamilies[0]);
+ std::vector<uint8_t> newBuffer = writeToBuffer(copied);
+ EXPECT_EQ(buffer, newBuffer);
+ }
+ {
+ // Test axes.
+ // This font has 'wdth' and 'wght' axes.
+ const char kMultiAxisFont[] = "MultiAxis.ttf";
+ std::vector<std::shared_ptr<FontCollection>> original(
+ {buildFontCollection(kMultiAxisFont)});
+ std::vector<uint8_t> buffer = writeToBuffer(original);
+ BufferReader reader(buffer.data());
+ auto copied = FontCollection::readVector<readFreeTypeMinikinFontForTest>(&reader);
+ EXPECT_EQ(1u, copied.size());
+ EXPECT_EQ(1u,
+ copied[0]->getSupportedTags().count(MinikinFont::MakeTag('w', 'd', 't', 'h')));
+ EXPECT_EQ(1u,
+ copied[0]->getSupportedTags().count(MinikinFont::MakeTag('w', 'g', 'h', 't')));
+ std::vector<uint8_t> newBuffer = writeToBuffer(copied);
+ EXPECT_EQ(buffer, newBuffer);
+ }
+}
+
+TEST(FontCollectionTest, FamilyMatchResultBuilderTest) {
+ using Builder = FontCollection::FamilyMatchResult::Builder;
+ EXPECT_TRUE(Builder().empty());
+ EXPECT_EQ(0u, Builder().size());
+ EXPECT_EQ(1u, Builder().add(5).size());
+ EXPECT_EQ(2u, Builder().add(5).add(4).size());
+
+ // Reset
+ EXPECT_TRUE(Builder().add(5).reset().empty());
+ EXPECT_EQ(0u, Builder().add(5).reset().size());
+}
+
+TEST(FontCollectionTest, FamilyMatchResultTest) {
+ using Builder = FontCollection::FamilyMatchResult::Builder;
+
+ auto r = Builder().build();
+ EXPECT_EQ(0u, r.size());
+ EXPECT_TRUE(r.empty());
+
+ r = Builder().add(1).build();
+ EXPECT_EQ(1u, r.size());
+ EXPECT_FALSE(r.empty());
+ EXPECT_EQ(1u, r[0]);
+
+ r = Builder().add(1).add(2).build();
+ EXPECT_EQ(2u, r.size());
+ EXPECT_FALSE(r.empty());
+ EXPECT_EQ(1u, r[0]);
+ EXPECT_EQ(2u, r[1]);
+}
+
+TEST(FontCollectionTest, FamilyMatchResultTest_BuilderHoldeFirst7) {
+ auto b = FontCollection::FamilyMatchResult::Builder();
+ for (uint8_t i = 0; i < 128; ++i) {
+ b.add(i);
+ }
+ auto r = b.build();
+ EXPECT_EQ(7u, r.size());
+ EXPECT_FALSE(r.empty());
+ EXPECT_EQ(0u, r[0]);
+ EXPECT_EQ(1u, r[1]);
+ EXPECT_EQ(2u, r[2]);
+ EXPECT_EQ(3u, r[3]);
+ EXPECT_EQ(4u, r[4]);
+ EXPECT_EQ(5u, r[5]);
+ EXPECT_EQ(6u, r[6]);
+}
+
+TEST(FontCollectionTest, FamilyMatchResultTest_iterator) {
+ auto b = FontCollection::FamilyMatchResult::Builder();
+ for (uint8_t i = 0; i < 7; ++i) {
+ b.add(i);
+ }
+ auto r = b.build();
+ EXPECT_EQ(7u, r.size());
+ EXPECT_FALSE(r.empty());
+ int i = 0;
+ for (auto v : r) {
+ EXPECT_EQ(i, v);
+ i++;
+ }
+}
+
+TEST(FontCollectionTest, FamilyMatchResultTest_intersect) {
+ using Builder = FontCollection::FamilyMatchResult::Builder;
+
+ EXPECT_EQ(Builder().add(1).add(2).add(3).build(),
+ FontCollection::FamilyMatchResult::intersect(Builder().add(1).add(2).add(3).build(),
+ Builder().add(1).add(2).add(3).build()));
+
+ EXPECT_EQ(Builder().build(),
+ FontCollection::FamilyMatchResult::intersect(Builder().add(1).add(2).add(3).build(),
+ Builder().build()));
+
+ EXPECT_EQ(Builder().build(),
+ FontCollection::FamilyMatchResult::intersect(Builder().add(2).add(4).add(6).build(),
+ Builder().add(1).add(3).add(5).build()));
+
+ EXPECT_EQ(Builder().add(1).add(3).build(),
+ FontCollection::FamilyMatchResult::intersect(Builder().add(1).add(2).add(3).build(),
+ Builder().add(1).add(3).add(5).build()));
+}
+
} // namespace minikin
diff --git a/tests/unittest/FontFamilyTest.cpp b/tests/unittest/FontFamilyTest.cpp
index 2b70faf..fd2fc9a 100644
--- a/tests/unittest/FontFamilyTest.cpp
+++ b/tests/unittest/FontFamilyTest.cpp
@@ -20,6 +20,7 @@
#include "minikin/LocaleList.h"
+#include "BufferUtils.h"
#include "FontTestUtils.h"
#include "FreeTypeMinikinFontForTest.h"
#include "LocaleListCache.h"
@@ -156,6 +157,40 @@
EXPECT_EQ("zzz-Zzzz-999", createLocaleWithoutICUSanitization("zzz-Zzzz-999").getString());
}
+TEST(LocaleTest, ReconstructFromIdentifierTest) {
+ std::string locales[] = {
+ // Language
+ "en",
+ "fil",
+ "und",
+ // Script
+ "en-Latn",
+ "fil-Taga",
+ "und-Zsye",
+ // Region
+ "en-US",
+ "fil-PH",
+ "es-419",
+ // Variant
+ "de-Latn-DE",
+ "de-Latn-DE-1901",
+ "de-Latn-DE-1996",
+ // Line break style
+ "ja-JP-u-lb-loose",
+ "ja-JP-u-lb-normal",
+ "ja-JP-u-lb-strict",
+ // Emoji subtag
+ "es-Latn-419-u-em-emoji",
+ // Everything
+ "de-Latn-DE-1996-u-lb-loose-u-em-emoji",
+ };
+ for (const std::string& locale : locales) {
+ EXPECT_EQ(createLocaleWithoutICUSanitization(locale),
+ Locale(createLocaleWithoutICUSanitization(locale).getIdentifier()))
+ << "locale = " << locale;
+ }
+}
+
TEST(LocaleTest, ScriptEqualTest) {
EXPECT_TRUE(createLocale("en").isEqualScript(createLocale("en")));
EXPECT_TRUE(createLocale("en-Latn").isEqualScript(createLocale("en")));
@@ -515,9 +550,7 @@
}
}
-TEST_F(FontFamilyTest, hasVariationSelectorTest) {
- std::shared_ptr<FontFamily> family = buildFontFamily(kVsTestFont);
-
+void expectVSGlyphsForVsTestFont(FontFamily* family) {
const uint32_t kVS1 = 0xFE00;
const uint32_t kVS2 = 0xFE01;
const uint32_t kVS3 = 0xFE02;
@@ -528,23 +561,28 @@
const uint32_t kSupportedChar1 = 0x82A6;
EXPECT_TRUE(family->getCoverage().get(kSupportedChar1));
- expectVSGlyphs(family.get(), kSupportedChar1, std::set<uint32_t>({kVS1, kVS17, kVS18, kVS19}));
+ expectVSGlyphs(family, kSupportedChar1, std::set<uint32_t>({kVS1, kVS17, kVS18, kVS19}));
const uint32_t kSupportedChar2 = 0x845B;
EXPECT_TRUE(family->getCoverage().get(kSupportedChar2));
- expectVSGlyphs(family.get(), kSupportedChar2, std::set<uint32_t>({kVS2, kVS18, kVS19, kVS20}));
+ expectVSGlyphs(family, kSupportedChar2, std::set<uint32_t>({kVS2, kVS18, kVS19, kVS20}));
const uint32_t kNoVsSupportedChar = 0x537F;
EXPECT_TRUE(family->getCoverage().get(kNoVsSupportedChar));
- expectVSGlyphs(family.get(), kNoVsSupportedChar, std::set<uint32_t>());
+ expectVSGlyphs(family, kNoVsSupportedChar, std::set<uint32_t>());
const uint32_t kVsOnlySupportedChar = 0x717D;
EXPECT_FALSE(family->getCoverage().get(kVsOnlySupportedChar));
- expectVSGlyphs(family.get(), kVsOnlySupportedChar, std::set<uint32_t>({kVS3, kVS19, kVS20}));
+ expectVSGlyphs(family, kVsOnlySupportedChar, std::set<uint32_t>({kVS3, kVS19, kVS20}));
const uint32_t kNotSupportedChar = 0x845C;
EXPECT_FALSE(family->getCoverage().get(kNotSupportedChar));
- expectVSGlyphs(family.get(), kNotSupportedChar, std::set<uint32_t>());
+ expectVSGlyphs(family, kNotSupportedChar, std::set<uint32_t>());
+}
+
+TEST_F(FontFamilyTest, hasVariationSelectorTest) {
+ std::shared_ptr<FontFamily> family = buildFontFamily(kVsTestFont);
+ expectVSGlyphsForVsTestFont(family.get());
}
TEST_F(FontFamilyTest, hasVSTableTest) {
@@ -728,7 +766,7 @@
for (const TestCase& testCase : testCases) {
std::vector<std::shared_ptr<MinikinFont>> dummyFonts;
- std::vector<Font> fonts;
+ std::vector<std::shared_ptr<Font>> fonts;
for (auto familyStyle : testCase.familyStyles) {
std::shared_ptr<MinikinFont> dummyFont(
new FreeTypeMinikinFontForTest(getTestFontPath(kTestFont)));
@@ -756,4 +794,41 @@
}
}
+TEST_F(FontFamilyTest, bufferTest) {
+ {
+ // Font with variation selectors
+ std::shared_ptr<FontFamily> original = buildFontFamily(kVsTestFont);
+ std::vector<uint8_t> buffer =
+ writeToBuffer<FontFamily, writeFreeTypeMinikinFontForTest>(*original);
+ BufferReader reader(buffer.data());
+ std::shared_ptr<FontFamily> copied =
+ FontFamily::readFrom<readFreeTypeMinikinFontForTest>(&reader);
+ ASSERT_EQ(original->localeListId(), copied->localeListId());
+ ASSERT_EQ(original->variant(), copied->variant());
+ ASSERT_EQ(original->getNumFonts(), copied->getNumFonts());
+ ASSERT_EQ(original->supportedAxes(), copied->supportedAxes());
+ ASSERT_EQ(original->isColorEmojiFamily(), copied->isColorEmojiFamily());
+ ASSERT_EQ(original->isCustomFallback(), copied->isCustomFallback());
+ ASSERT_EQ(original->hasVSTable(), copied->hasVSTable());
+ expectVSGlyphsForVsTestFont(copied.get());
+ std::vector<uint8_t> newBuffer =
+ writeToBuffer<FontFamily, writeFreeTypeMinikinFontForTest>(*copied);
+ ASSERT_EQ(buffer, newBuffer);
+ }
+ {
+ // Font with axes
+ constexpr char kMultiAxisFont[] = "MultiAxis.ttf";
+ std::shared_ptr<FontFamily> original = buildFontFamily(kMultiAxisFont);
+ std::vector<uint8_t> buffer =
+ writeToBuffer<FontFamily, writeFreeTypeMinikinFontForTest>(*original);
+ BufferReader reader(buffer.data());
+ std::shared_ptr<FontFamily> copied =
+ FontFamily::readFrom<readFreeTypeMinikinFontForTest>(&reader);
+ ASSERT_EQ(original->supportedAxes(), copied->supportedAxes());
+ std::vector<uint8_t> newBuffer =
+ writeToBuffer<FontFamily, writeFreeTypeMinikinFontForTest>(*copied);
+ ASSERT_EQ(buffer, newBuffer);
+ }
+}
+
} // namespace minikin
diff --git a/tests/unittest/FontFileParserTest.cpp b/tests/unittest/FontFileParserTest.cpp
new file mode 100644
index 0000000..d960217
--- /dev/null
+++ b/tests/unittest/FontFileParserTest.cpp
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+#include "minikin/FontFileParser.h"
+
+#include <gtest/gtest.h>
+
+#include "FontTestUtils.h"
+#include "FreeTypeMinikinFontForTest.h"
+#include "PathUtils.h"
+
+namespace minikin {
+namespace {
+
+static size_t writeU16(uint16_t x, uint8_t* out, size_t offset) {
+ out[offset] = x >> 8;
+ out[offset + 1] = x;
+ return offset + 2;
+}
+
+static size_t writeU32(uint32_t x, uint8_t* out, size_t offset) {
+ out[offset] = x >> 24;
+ out[offset + 1] = x >> 16;
+ out[offset + 2] = x >> 8;
+ out[offset + 3] = x;
+ return offset + 4;
+}
+
+class TestableFontFileParser : public FontFileParser {
+public:
+ using FontFileParser::analyzeFontRevision;
+ using FontFileParser::checkPSName;
+};
+
+// Returns valid head table contents.
+static std::vector<uint8_t> buildHeadTable(uint32_t fontRevision) {
+ std::vector<uint8_t> out(46);
+ size_t head = writeU16(1, out.data(), 0); // major version
+ head = writeU16(0, out.data(), head); // minor version
+ head = writeU32(fontRevision, out.data(), head); // fontRevision
+ head = writeU32(0xB1B0AFBA, out.data(), head); // checksum. (random value)
+ head = writeU32(0x5F0F3CF5, out.data(), head); // magicNumber
+ head = writeU16(0, out.data(), head); // flasgs
+ head = writeU16(1024, out.data(), head); // unitsPerEm
+ head = writeU32(123457890, out.data(), head); // created (random value)
+ head = writeU32(123457890, out.data(), head); // modified (random value)
+ head = writeU16(0, out.data(), head); // xMin
+ head = writeU16(100, out.data(), head); // yMin
+ head = writeU16(1024, out.data(), head); // xMax
+ head = writeU16(2048, out.data(), head); // yMax
+ head = writeU16(0, out.data(), head); // macStyle
+ head = writeU16(10, out.data(), head); // lowestRecPPEM
+ head = writeU16(1, out.data(), head); // fontDirectionHint
+ head = writeU16(1, out.data(), head); // indexToLocFormat
+ head = writeU16(0, out.data(), head); // glyphDataFormat;
+
+ return out;
+}
+
+TEST(FontFileParserTest, analyzeFontRevision) {
+ uint32_t rev = 0x12345678;
+ std::vector<uint8_t> head = buildHeadTable(rev);
+
+ uint32_t out = 0;
+ EXPECT_TRUE(TestableFontFileParser::analyzeFontRevision(head.data(), head.size(), &out));
+ EXPECT_EQ(rev, out);
+}
+
+TEST(FontFileParserTest, headInvalidLength) {
+ uint32_t rev = 0x12345678;
+ std::vector<uint8_t> head = buildHeadTable(rev);
+
+ uint32_t out = 0;
+ EXPECT_FALSE(TestableFontFileParser::analyzeFontRevision(head.data(), 6, &out));
+}
+
+TEST(FontFileParserTest, parseFontForRev) {
+ auto minikinFont = std::make_shared<FreeTypeMinikinFontForTest>(getTestFontPath("Ascii.ttf"));
+ auto parser = FontFileParser(minikinFont->GetFontData(), minikinFont->GetFontSize(), 0);
+
+ auto revision = parser.getFontRevision();
+ EXPECT_TRUE(revision.has_value());
+ EXPECT_EQ(0x00010000u, revision.value());
+}
+
+TEST(FontFileParser, checkPSName) {
+ EXPECT_TRUE(TestableFontFileParser::checkPSName("Roboto-Regular"));
+ EXPECT_TRUE(TestableFontFileParser::checkPSName("NotoColorEmoji"));
+
+ // Space character is not allowed.
+ EXPECT_FALSE(TestableFontFileParser::checkPSName("Roboto Regular"));
+ EXPECT_FALSE(TestableFontFileParser::checkPSName("Noto Color Emoji"));
+
+ // parens are not not allowed.
+ EXPECT_FALSE(TestableFontFileParser::checkPSName("Roboto (Regular)"));
+ EXPECT_FALSE(TestableFontFileParser::checkPSName("Noto <Color> {Emoji}"));
+
+ // control characters are not allowed
+ EXPECT_FALSE(TestableFontFileParser::checkPSName("Roboto-Regular\b"));
+ EXPECT_FALSE(TestableFontFileParser::checkPSName("NotoColorEmoji\t"));
+
+ // Up to 63 character is allowed.
+ EXPECT_FALSE(TestableFontFileParser::checkPSName(std::string(64, 'a')));
+
+ // Only printable ASCII is allowed.
+ EXPECT_FALSE(TestableFontFileParser::checkPSName("ろぼとふぉんと"));
+}
+
+TEST(FontFileParserTest, parseFontForPSName) {
+ auto minikinFont = std::make_shared<FreeTypeMinikinFontForTest>(getTestFontPath("Ascii.ttf"));
+ auto parser = FontFileParser(minikinFont->GetFontData(), minikinFont->GetFontSize(), 0);
+
+ auto psName = parser.getPostScriptName();
+ EXPECT_TRUE(psName.has_value());
+ EXPECT_EQ("SampleFont-Regular", psName.value());
+}
+
+} // namespace
+} // namespace minikin
diff --git a/tests/unittest/FontLanguageListCacheTest.cpp b/tests/unittest/FontLanguageListCacheTest.cpp
index e957cfc..e68922d 100644
--- a/tests/unittest/FontLanguageListCacheTest.cpp
+++ b/tests/unittest/FontLanguageListCacheTest.cpp
@@ -61,4 +61,25 @@
EXPECT_EQ(japanese, locales2[1]);
}
+TEST(LocaleListCacheTest, buffer) {
+ std::string locales[] = {"en", "jp", "en,zh-Hans"};
+ // Measure
+ BufferWriter fakeWriter(nullptr);
+ for (const std::string& locale : locales) {
+ LocaleListCache::writeTo(&fakeWriter, LocaleListCache::getId(locale));
+ }
+ // Write
+ std::vector<uint8_t> buffer(fakeWriter.size());
+ BufferWriter writer(buffer.data());
+ for (const std::string& locale : locales) {
+ LocaleListCache::writeTo(&writer, LocaleListCache::getId(locale));
+ }
+ // Read
+ BufferReader reader(buffer.data());
+ for (const std::string& locale : locales) {
+ EXPECT_EQ(LocaleListCache::getId(locale), LocaleListCache::readFrom(&reader))
+ << "locale = " << locale;
+ }
+}
+
} // namespace minikin
diff --git a/tests/unittest/FontTest.cpp b/tests/unittest/FontTest.cpp
index ff2f9bc..68f5b51 100644
--- a/tests/unittest/FontTest.cpp
+++ b/tests/unittest/FontTest.cpp
@@ -18,28 +18,25 @@
#include <gtest/gtest.h>
+#include "BufferUtils.h"
#include "FontTestUtils.h"
#include "FreeTypeMinikinFontForTest.h"
namespace minikin {
-TEST(FontTest, CopyTest) {
+TEST(FontTest, BufferTest) {
auto minikinFont = std::make_shared<FreeTypeMinikinFontForTest>(getTestFontPath("Ascii.ttf"));
- {
- Font font = Font::Builder(minikinFont).build();
- {
- Font copied(font);
- EXPECT_EQ(font.typeface(), copied.typeface());
- EXPECT_EQ(font.style(), copied.style());
- EXPECT_EQ(font.baseFont(), copied.baseFont());
- }
- {
- Font copied = font;
- EXPECT_EQ(font.typeface(), copied.typeface());
- EXPECT_EQ(font.style(), copied.style());
- EXPECT_EQ(font.baseFont(), copied.baseFont());
- }
- }
+ std::shared_ptr<Font> original = Font::Builder(minikinFont).build();
+ std::vector<uint8_t> buffer = writeToBuffer<Font, writeFreeTypeMinikinFontForTest>(*original);
+
+ BufferReader reader(buffer.data());
+ std::shared_ptr<Font> font =
+ Font::readFrom<readFreeTypeMinikinFontForTest>(&reader, kEmptyLocaleListId);
+ EXPECT_EQ(minikinFont->GetFontPath(), font->typeface()->GetFontPath());
+ EXPECT_EQ(original->style(), font->style());
+ EXPECT_NE(nullptr, font->baseFont());
+ std::vector<uint8_t> newBuffer = writeToBuffer<Font, writeFreeTypeMinikinFontForTest>(*font);
+ EXPECT_EQ(buffer, newBuffer);
}
} // namespace minikin
diff --git a/tests/unittest/GreedyLineBreakerTest.cpp b/tests/unittest/GreedyLineBreakerTest.cpp
index 13cc03c..e9da1a1 100644
--- a/tests/unittest/GreedyLineBreakerTest.cpp
+++ b/tests/unittest/GreedyLineBreakerTest.cpp
@@ -93,6 +93,33 @@
std::vector<uint8_t> mHyphenationPattern;
};
+TEST_F(GreedyLineBreakerTest, roundingError) {
+ MeasuredTextBuilder builder;
+ auto family1 = buildFontFamily("Ascii.ttf");
+ std::vector<std::shared_ptr<FontFamily>> families = {family1};
+ auto fc = std::make_shared<FontCollection>(families);
+ MinikinPaint paint(fc);
+ paint.size = 56.0f; // Make 1em=56px
+ paint.scaleX = 1;
+ paint.letterSpacing = -0.093f;
+ paint.localeListId = LocaleListCache::getId("en-US");
+ const std::vector<uint16_t> textBuffer = utf8ToUtf16("8888888888888888888");
+
+ float measured = Layout::measureText(textBuffer, Range(0, textBuffer.size()), Bidi::LTR, paint,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, nullptr);
+
+ builder.addStyleRun(0, textBuffer.size(), std::move(paint), false);
+ std::unique_ptr<MeasuredText> measuredText =
+ builder.build(textBuffer, false /* compute hyphenation */,
+ false /* compute full layout */, nullptr /* no hint */);
+ RectangleLineWidth rectangleLineWidth(measured);
+ TabStops tabStops(nullptr, 0, 10);
+ LineBreakResult r = breakLineGreedy(textBuffer, *measuredText, rectangleLineWidth, tabStops,
+ false /* do hyphenation */);
+
+ EXPECT_EQ(1u, r.breakPoints.size());
+}
+
TEST_F(GreedyLineBreakerTest, testBreakWithoutHyphenation) {
constexpr bool NO_HYPHEN = false; // No hyphenation in this test case.
const std::vector<uint16_t> textBuf = utf8ToUtf16("This is an example text.");
diff --git a/tests/unittest/HasherTest.cpp b/tests/unittest/HasherTest.cpp
index 8e11cc6..02cbda8 100644
--- a/tests/unittest/HasherTest.cpp
+++ b/tests/unittest/HasherTest.cpp
@@ -35,4 +35,9 @@
EXPECT_EQ(hasher.hash(), hasher.hash());
}
+TEST(HasherTest, hasherTestFloat) {
+ float x = 1.1f;
+ EXPECT_NE(Hasher().update(x).hash(), Hasher().update(1).hash());
+}
+
} // namespace minikin
diff --git a/tests/unittest/LayoutCoreTest.cpp b/tests/unittest/LayoutCoreTest.cpp
index ef972a0..2ab7543 100644
--- a/tests/unittest/LayoutCoreTest.cpp
+++ b/tests/unittest/LayoutCoreTest.cpp
@@ -74,7 +74,6 @@
auto layout = buildLayout("I", {"LayoutTestFont.ttf"});
EXPECT_EQ(1u, layout.glyphCount());
EXPECT_EQ(Point(0, 0), layout.pointAt(0));
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), layout.bounds());
EXPECT_EQ(MinikinExtent(-100.0f, 20.0f), layout.extent());
EXPECT_EQ(1u, layout.fonts().size());
EXPECT_TRUE(layout.fontAt(0).font);
@@ -87,7 +86,6 @@
EXPECT_EQ(2u, layout.glyphCount());
EXPECT_EQ(Point(0, 0), layout.pointAt(0));
EXPECT_EQ(Point(10.0f, 0), layout.pointAt(1));
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 20.0f, 0.0f), layout.bounds());
EXPECT_EQ(MinikinExtent(-100.0f, 20.0f), layout.extent());
EXPECT_EQ(1u, layout.fonts().size());
EXPECT_TRUE(layout.fontAt(0).font);
@@ -103,7 +101,6 @@
EXPECT_EQ(2u, layout.glyphCount());
EXPECT_EQ(Point(0, 0), layout.pointAt(0));
EXPECT_EQ(Point(10.0f, 0), layout.pointAt(1));
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 60.0f, 0.0f), layout.bounds());
EXPECT_EQ(MinikinExtent(-100.0f, 20.0f), layout.extent());
EXPECT_EQ(1u, layout.fonts().size());
EXPECT_TRUE(layout.fontAt(0).font);
@@ -130,7 +127,6 @@
EXPECT_EQ(2u, layout.glyphCount());
EXPECT_EQ(Point(0, 0), layout.pointAt(0));
EXPECT_EQ(Point(10.0f, 0), layout.pointAt(1));
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 30.0f, 0.0f), layout.bounds());
EXPECT_EQ(MinikinExtent(-160.0f, 40.0f), layout.extent());
EXPECT_EQ(2u, layout.fonts().size());
EXPECT_TRUE(layout.fontAt(0).font);
@@ -146,7 +142,6 @@
EXPECT_EQ(2u, layout.glyphCount());
EXPECT_EQ(Point(0, 0), layout.pointAt(0));
EXPECT_EQ(Point(20.0f, 0), layout.pointAt(1));
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 30.0f, 0.0f), layout.bounds());
EXPECT_EQ(MinikinExtent(-160.0f, 40.0f), layout.extent());
EXPECT_EQ(2u, layout.fonts().size());
EXPECT_TRUE(layout.fontAt(0).font);
@@ -168,7 +163,6 @@
auto layout = buildLayout("fi", {"Ligature.ttf"});
EXPECT_EQ(1u, layout.glyphCount());
EXPECT_EQ(Point(0, 0), layout.pointAt(0));
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), layout.bounds());
EXPECT_EQ(MinikinExtent(-80.0f, 20.0f), layout.extent());
EXPECT_EQ(1u, layout.fonts().size());
EXPECT_TRUE(layout.fontAt(0).font);
@@ -181,7 +175,6 @@
auto layout = buildLayout("ff", {"Ligature.ttf"});
EXPECT_EQ(1u, layout.glyphCount());
EXPECT_EQ(Point(0, 0), layout.pointAt(0));
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), layout.bounds());
EXPECT_EQ(MinikinExtent(-80.0f, 20.0f), layout.extent());
EXPECT_EQ(1u, layout.fonts().size());
EXPECT_TRUE(layout.fontAt(0).font);
@@ -194,7 +187,6 @@
auto layout = buildLayout("fi", {"Ligature.ttf"}, "'liga' off");
EXPECT_EQ(1u, layout.glyphCount());
EXPECT_EQ(Point(0, 0), layout.pointAt(0));
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), layout.bounds());
EXPECT_EQ(MinikinExtent(-80.0f, 20.0f), layout.extent());
EXPECT_EQ(1u, layout.fonts().size());
EXPECT_TRUE(layout.fontAt(0).font);
@@ -207,7 +199,6 @@
auto layout = buildLayout("ff", {"Ligature.ttf"}, "'liga' off");
EXPECT_EQ(2u, layout.glyphCount());
EXPECT_EQ(Point(0, 0), layout.pointAt(0));
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 20.0f, 0.0f), layout.bounds());
EXPECT_EQ(MinikinExtent(-80.0f, 20.0f), layout.extent());
EXPECT_EQ(1u, layout.fonts().size());
EXPECT_TRUE(layout.fontAt(0).font);
@@ -222,7 +213,6 @@
auto layout = buildLayout("fii", {"Ligature.ttf"});
EXPECT_EQ(2u, layout.glyphCount());
EXPECT_EQ(Point(0, 0), layout.pointAt(0));
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 20.0f, 0.0f), layout.bounds());
EXPECT_EQ(MinikinExtent(-80.0f, 20.0f), layout.extent());
EXPECT_EQ(1u, layout.fonts().size());
EXPECT_TRUE(layout.fontAt(0).font);
@@ -238,7 +228,6 @@
auto layout = buildLayout("if", {"Ligature.ttf"});
EXPECT_EQ(2u, layout.glyphCount());
EXPECT_EQ(Point(0, 0), layout.pointAt(0));
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 20.0f, 0.0f), layout.bounds());
EXPECT_EQ(MinikinExtent(-80.0f, 20.0f), layout.extent());
EXPECT_EQ(1u, layout.fonts().size());
EXPECT_TRUE(layout.fontAt(0).font);
diff --git a/tests/unittest/LayoutTest.cpp b/tests/unittest/LayoutTest.cpp
index 4b97cee..7771051 100644
--- a/tests/unittest/LayoutTest.cpp
+++ b/tests/unittest/LayoutTest.cpp
@@ -20,6 +20,7 @@
#include "minikin/FontCollection.h"
#include "minikin/LayoutPieces.h"
+#include "minikin/Measurement.h"
#include "FontTestUtils.h"
#include "UnicodeUtils.h"
@@ -35,6 +36,12 @@
}
}
+static void getBounds(const U16StringPiece& text, Bidi bidiFlags, const MinikinPaint& paint,
+ MinikinRect* out) {
+ getBounds(text, Range(0, text.size()), bidiFlags, paint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, out);
+}
+
class LayoutTest : public testing::Test {
protected:
LayoutTest() : mCollection(nullptr) {}
@@ -64,7 +71,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(70.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(70.0f, rect.mRight);
@@ -82,7 +90,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(90.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(90.0f, rect.mRight);
@@ -100,7 +109,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(160.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(160.0f, rect.mRight);
@@ -118,7 +128,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(110.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(110.0f, rect.mRight);
@@ -148,7 +159,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(70.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(70.0f, rect.mRight);
@@ -166,7 +178,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(95.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(95.0f, rect.mRight);
@@ -185,7 +198,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(170.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(170.0f, rect.mRight);
@@ -205,7 +219,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(120.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(120.0f, rect.mRight);
@@ -238,7 +253,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(70.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(70.0f, rect.mRight);
@@ -256,7 +272,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(85.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(85.0f, rect.mRight);
@@ -275,7 +292,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(140.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(140.0f, rect.mRight);
@@ -295,7 +313,8 @@
Layout layout(text, range, Bidi::LTR, paint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
EXPECT_EQ(100.0f, layout.getAdvance());
- layout.getBounds(&rect);
+
+ getBounds(text, Bidi::LTR, paint, &rect);
EXPECT_EQ(0.0f, rect.mLeft);
EXPECT_EQ(10.0f, rect.mTop);
EXPECT_EQ(100.0f, rect.mRight);
diff --git a/tests/unittest/MeasuredTextTest.cpp b/tests/unittest/MeasuredTextTest.cpp
index 1934ed8..e5766a1 100644
--- a/tests/unittest/MeasuredTextTest.cpp
+++ b/tests/unittest/MeasuredTextTest.cpp
@@ -19,6 +19,7 @@
#include <gtest/gtest.h>
#include "minikin/LineBreaker.h"
+#include "minikin/Measurement.h"
#include "FontTestUtils.h"
#include "UnicodeUtils.h"
@@ -75,6 +76,34 @@
EXPECT_EQ(MinikinRect(0.0f, 10.0f, 130.0f, 0.0f), mt->getBounds(text, Range(0, text.size())));
}
+TEST(MeasuredTextTest, getBoundsTest_LTR) {
+ auto text = utf8ToUtf16("\u0028"); // U+0028 has 1em in LTR, 3em in RTL.
+ auto font = buildFontCollection("Bbox.ttf");
+
+ MeasuredTextBuilder builder;
+ MinikinPaint paint(font);
+ paint.size = 10.0f;
+ builder.addStyleRun(0, text.size(), std::move(paint), false /* is RTL */);
+ auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
+ nullptr /* no hint */);
+
+ EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), mt->getBounds(text, Range(0, 1)));
+}
+
+TEST(MeasuredTextTest, getBoundsTest_RTL) {
+ auto text = utf8ToUtf16("\u0028"); // U+0028 has 1em in LTR, 3em in RTL.
+ auto font = buildFontCollection("Bbox.ttf");
+
+ MeasuredTextBuilder builder;
+ MinikinPaint paint(font);
+ paint.size = 10.0f;
+ builder.addStyleRun(0, text.size(), std::move(paint), true /* is RTL */);
+ auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
+ nullptr /* no hint */);
+
+ EXPECT_EQ(MinikinRect(0.0f, 30.0f, 30.0f, 0.0f), mt->getBounds(text, Range(0, 2)));
+}
+
TEST(MeasuredTextTest, getBoundsTest_multiStyle) {
auto text = utf8ToUtf16("Hello, World!");
auto font = buildFontCollection("Ascii.ttf");
@@ -155,6 +184,7 @@
auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
nullptr /* no hint */);
+ MinikinRect rect;
MinikinPaint samePaint(font);
samePaint.size = 10.0f;
@@ -171,7 +201,9 @@
EXPECT_EQ(10.0f, layout.getAdvance());
EXPECT_EQ(10.0f, layout.getCharAdvance(0));
EXPECT_EQ(1u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(0, 1), Bidi::LTR, samePaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(0, 2), fullContext, samePaint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
@@ -185,7 +217,9 @@
EXPECT_EQ(10.0f, layout.getCharAdvance(0));
EXPECT_EQ(10.0f, layout.getCharAdvance(1));
EXPECT_EQ(2u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 20.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(0, 2), Bidi::LTR, samePaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 10.0f, 20.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(1, 2), fullContext, samePaint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
@@ -196,7 +230,9 @@
EXPECT_EQ(10.0f, layout.getAdvance());
EXPECT_EQ(10.0f, layout.getCharAdvance(0));
EXPECT_EQ(1u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(1, 2), Bidi::LTR, samePaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(0, text.size()), fullContext, samePaint,
StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT);
@@ -210,7 +246,9 @@
}
EXPECT_EQ(130.0f, layout.getAdvance());
EXPECT_EQ(text.size(), layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 130.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(0, text.size()), Bidi::LTR, samePaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 10.0f, 130.0f, 0.0f), rect);
}
TEST(MeasuredTextTest, buildLayoutTest_multiStyle) {
@@ -229,6 +267,7 @@
auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
nullptr /* no hint */);
+ MinikinRect rect;
MinikinPaint samePaint(font);
samePaint.size = 10.0f;
@@ -245,7 +284,9 @@
EXPECT_EQ(10.0f, layout.getAdvance());
EXPECT_EQ(10.0f, layout.getCharAdvance(0));
EXPECT_EQ(1u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(0, 1), Bidi::LTR, samePaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(0, 2), fullContext, samePaint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
@@ -259,7 +300,9 @@
EXPECT_EQ(10.0f, layout.getCharAdvance(0));
EXPECT_EQ(10.0f, layout.getCharAdvance(1));
EXPECT_EQ(2u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 20.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(0, 2), Bidi::LTR, samePaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 10.0f, 20.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(1, 2), fullContext, samePaint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
@@ -270,7 +313,9 @@
EXPECT_EQ(10.0f, layout.getAdvance());
EXPECT_EQ(10.0f, layout.getCharAdvance(0));
EXPECT_EQ(1u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(1, 2), Bidi::LTR, samePaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 10.0f, 10.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(7, 7), fullContext, samePaint, StartHyphenEdit::NO_EDIT,
EndHyphenEdit::NO_EDIT);
@@ -287,7 +332,9 @@
EXPECT_EQ(20.0f, layout.getAdvance());
EXPECT_EQ(20.0f, layout.getCharAdvance(0));
EXPECT_EQ(1u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 20.0f, 20.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(7, 8), Bidi::LTR, samePaint2, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 20.0f, 20.0f, 0.0f), rect);
}
TEST(MeasuredTextTest, buildLayoutTest_differentPaint) {
@@ -302,6 +349,7 @@
auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
nullptr /* no hint */);
+ MinikinRect rect;
MinikinPaint differentPaint(font);
differentPaint.size = 20.0f;
@@ -318,7 +366,9 @@
EXPECT_EQ(20.0f, layout.getAdvance());
EXPECT_EQ(20.0f, layout.getCharAdvance(0));
EXPECT_EQ(1u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 20.0f, 20.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(0, 1), Bidi::LTR, differentPaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 20.0f, 20.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(0, 2), fullContext, differentPaint,
StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT);
@@ -332,7 +382,9 @@
EXPECT_EQ(20.0f, layout.getCharAdvance(0));
EXPECT_EQ(20.0f, layout.getCharAdvance(1));
EXPECT_EQ(2u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 20.0f, 40.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(0, 2), Bidi::LTR, differentPaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 20.0f, 40.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(1, 2), fullContext, differentPaint,
StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT);
@@ -343,7 +395,9 @@
EXPECT_EQ(20.0f, layout.getAdvance());
EXPECT_EQ(20.0f, layout.getCharAdvance(0));
EXPECT_EQ(1u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 20.0f, 20.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(1, 2), Bidi::LTR, differentPaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 20.0f, 20.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(0, text.size()), fullContext, differentPaint,
StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT);
@@ -357,7 +411,9 @@
}
EXPECT_EQ(260.0f, layout.getAdvance());
EXPECT_EQ(text.size(), layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 20.0f, 260.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(0, text.size()), Bidi::LTR, differentPaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 20.0f, 260.0f, 0.0f), rect);
}
TEST(MeasuredTextTest, buildLayoutTest_multiStyle_differentPaint) {
@@ -376,6 +432,7 @@
auto mt = builder.build(text, true /* hyphenation */, true /* full layout */,
nullptr /* no hint */);
+ MinikinRect rect;
MinikinPaint differentPaint(font);
differentPaint.size = 30.0f;
@@ -392,7 +449,9 @@
EXPECT_EQ(30.0f, layout.getAdvance());
EXPECT_EQ(30.0f, layout.getCharAdvance(0));
EXPECT_EQ(1u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 30.0f, 30.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(0, 1), Bidi::LTR, differentPaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 30.0f, 30.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(0, 2), fullContext, differentPaint,
StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT);
@@ -406,7 +465,9 @@
EXPECT_EQ(30.0f, layout.getCharAdvance(0));
EXPECT_EQ(30.0f, layout.getCharAdvance(1));
EXPECT_EQ(2u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 30.0f, 60.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(0, 2), Bidi::LTR, differentPaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 30.0f, 60.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(1, 2), fullContext, differentPaint,
StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT);
@@ -417,7 +478,9 @@
EXPECT_EQ(30.0f, layout.getAdvance());
EXPECT_EQ(30.0f, layout.getCharAdvance(0));
EXPECT_EQ(1u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 30.0f, 30.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(1, 2), Bidi::LTR, differentPaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 30.0f, 30.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(7, 7), fullContext, differentPaint,
StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT);
@@ -432,7 +495,9 @@
EXPECT_EQ(30.0f, layout.getAdvance());
EXPECT_EQ(30.0f, layout.getCharAdvance(0));
EXPECT_EQ(1u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 30.0f, 30.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(7, 8), Bidi::LTR, differentPaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 30.0f, 30.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(6, 8), fullContext, differentPaint,
StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT);
@@ -446,7 +511,9 @@
EXPECT_EQ(30.0f, layout.getCharAdvance(0));
EXPECT_EQ(30.0f, layout.getCharAdvance(1));
EXPECT_EQ(2u, layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 30.0f, 60.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(6, 8), Bidi::LTR, differentPaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 30.0f, 60.0f, 0.0f), rect);
layout = mt->buildLayout(text, Range(0, text.size()), fullContext, differentPaint,
StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT);
@@ -460,7 +527,9 @@
}
EXPECT_EQ(390.0f, layout.getAdvance());
EXPECT_EQ(text.size(), layout.getAdvances().size());
- EXPECT_EQ(MinikinRect(0.0f, 30.0f, 390.0f, 0.0f), layout.getBounds());
+ getBounds(text, Range(0, text.size()), Bidi::LTR, differentPaint, StartHyphenEdit::NO_EDIT,
+ EndHyphenEdit::NO_EDIT, &rect);
+ EXPECT_EQ(MinikinRect(0.0f, 30.0f, 390.0f, 0.0f), rect);
}
} // namespace minikin
diff --git a/tests/unittest/OptimalLineBreakerTest.cpp b/tests/unittest/OptimalLineBreakerTest.cpp
index 51aab60..d6801cc 100644
--- a/tests/unittest/OptimalLineBreakerTest.cpp
+++ b/tests/unittest/OptimalLineBreakerTest.cpp
@@ -2080,5 +2080,33 @@
<< toString(textBuf, actual);
}
}
+
+TEST_F(OptimalLineBreakerTest, roundingError) {
+ MeasuredTextBuilder builder;
+ auto family1 = buildFontFamily("Ascii.ttf");
+ std::vector<std::shared_ptr<FontFamily>> families = {family1};
+ auto fc = std::make_shared<FontCollection>(families);
+ MinikinPaint paint(fc);
+ paint.size = 56.0f; // Make 1em=56px
+ paint.scaleX = 1;
+ paint.letterSpacing = -0.093f;
+ paint.localeListId = LocaleListCache::getId("en-US");
+ const std::vector<uint16_t> textBuffer = utf8ToUtf16("8888888888888888888");
+
+ float measured = Layout::measureText(textBuffer, Range(0, textBuffer.size()), Bidi::LTR, paint,
+ StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT, nullptr);
+
+ builder.addStyleRun(0, textBuffer.size(), std::move(paint), false);
+ std::unique_ptr<MeasuredText> measuredText =
+ builder.build(textBuffer, false /* compute hyphenation */,
+ false /* compute full layout */, nullptr /* no hint */);
+ RectangleLineWidth rectangleLineWidth(measured);
+ TabStops tabStops(nullptr, 0, 10);
+ LineBreakResult r = doLineBreak(textBuffer, *measuredText, BreakStrategy::Balanced,
+ HyphenationFrequency::None, measured);
+
+ EXPECT_EQ(1u, r.breakPoints.size());
+}
+
} // namespace
} // namespace minikin
diff --git a/tests/unittest/SparseBitSetTest.cpp b/tests/unittest/SparseBitSetTest.cpp
index 03a14d9..8c67964 100644
--- a/tests/unittest/SparseBitSetTest.cpp
+++ b/tests/unittest/SparseBitSetTest.cpp
@@ -20,6 +20,8 @@
#include <gtest/gtest.h>
+#include "BufferUtils.h"
+
namespace minikin {
TEST(SparseBitSetTest, randomTest) {
@@ -52,4 +54,29 @@
}
}
+TEST(SparseBitSetTest, bufferTest) {
+ std::vector<uint32_t> range({10, 20});
+ SparseBitSet originalBitset(range.data(), range.size() / 2);
+ std::vector<uint8_t> buffer = writeToBuffer(originalBitset);
+ BufferReader reader(buffer.data());
+ SparseBitSet bitset(&reader);
+
+ for (size_t i = 0; i < 10; ++i) ASSERT_FALSE(bitset.get(i)) << i;
+ for (size_t i = 10; i < 20; ++i) ASSERT_TRUE(bitset.get(i)) << i;
+ for (size_t i = 20; i < 30; ++i) ASSERT_FALSE(bitset.get(i)) << i;
+ std::vector<uint8_t> newBuffer = writeToBuffer(bitset);
+ ASSERT_EQ(buffer, newBuffer);
+}
+
+TEST(SparseBitSetTest, emptyBitSetBufferTest) {
+ SparseBitSet empty;
+ std::vector<uint8_t> buffer = writeToBuffer(empty);
+ BufferReader reader(buffer.data());
+ SparseBitSet bitset(&reader);
+
+ ASSERT_FALSE(bitset.get(0));
+ std::vector<uint8_t> newBuffer = writeToBuffer(bitset);
+ ASSERT_EQ(buffer, newBuffer);
+}
+
} // namespace minikin
diff --git a/tests/unittest/SystemFontsTest.cpp b/tests/unittest/SystemFontsTest.cpp
index fe603a9..f1b0109 100644
--- a/tests/unittest/SystemFontsTest.cpp
+++ b/tests/unittest/SystemFontsTest.cpp
@@ -21,6 +21,7 @@
#include "minikin/FontCollection.h"
#include "FontTestUtils.h"
+#include "PathUtils.h"
namespace minikin {
namespace {
@@ -30,10 +31,18 @@
TestableSystemFonts() : SystemFonts() {}
virtual ~TestableSystemFonts() {}
- std::shared_ptr<FontCollection> findFontCollection(const std::string& familyName) const {
+ std::shared_ptr<FontCollection> findFontCollection(const std::string& familyName) {
return findFontCollectionInternal(familyName);
}
+ void addFontMap(std::shared_ptr<FontCollection>&& collections) {
+ addFontMapInternal(std::move(collections));
+ }
+
+ void getFontSet(std::function<void(const std::vector<std::shared_ptr<Font>>&)> func) {
+ getFontSetInternal(func);
+ }
+
void registerFallback(const std::string& familyName,
const std::shared_ptr<FontCollection>& fc) {
registerFallbackInternal(familyName, fc);
@@ -66,5 +75,44 @@
EXPECT_EQ(fc2, systemFonts.findFontCollection("sans"));
}
+TEST(SystemFontsTest, updateDefaultAndFallback) {
+ TestableSystemFonts systemFonts;
+ auto fc1 = buildFontCollection("Ascii.ttf");
+ auto fc2 = buildFontCollection("Bold.ttf");
+ systemFonts.registerDefault(fc1);
+ systemFonts.registerFallback("sans", fc2);
+ systemFonts.registerDefault(fc2);
+ systemFonts.registerFallback("sans", fc1);
+ EXPECT_EQ(fc2, systemFonts.findFontCollection("unknown-name"));
+ EXPECT_EQ(fc1, systemFonts.findFontCollection("sans"));
+}
+
+TEST(SystemFontTest, getAvailableFont_dedupFonts) {
+ TestableSystemFonts systemFonts;
+ auto asciiFamily = buildFontFamily("Ascii.ttf");
+ auto boldFamily = buildFontFamily("Bold.ttf");
+ auto boldItalicFamily = buildFontFamily("BoldItalic.ttf");
+
+ auto fc1Families = std::vector<std::shared_ptr<FontFamily>>{asciiFamily, boldItalicFamily};
+ auto fc2Families = std::vector<std::shared_ptr<FontFamily>>{boldFamily, boldItalicFamily};
+ auto fc1 = std::make_shared<FontCollection>(std::move(fc1Families));
+ auto fc2 = std::make_shared<FontCollection>(std::move(fc2Families));
+
+ systemFonts.addFontMap(std::move(fc1));
+ systemFonts.addFontMap(std::move(fc2));
+
+ systemFonts.getFontSet([](const std::vector<std::shared_ptr<Font>>& fonts) {
+ EXPECT_EQ(3u, fonts.size()); // Ascii, Bold and BoldItalic
+ std::unordered_set<std::string> fontPaths;
+ for (const auto& font : fonts) {
+ fontPaths.insert(getBasename(font->typeface()->GetFontPath()));
+ }
+
+ EXPECT_TRUE(fontPaths.find("Ascii.ttf") != fontPaths.end());
+ EXPECT_TRUE(fontPaths.find("Bold.ttf") != fontPaths.end());
+ EXPECT_TRUE(fontPaths.find("BoldItalic.ttf") != fontPaths.end());
+ });
+}
+
} // namespace
} // namespace minikin
diff --git a/tests/util/BufferUtils.h b/tests/util/BufferUtils.h
new file mode 100644
index 0000000..355e74e
--- /dev/null
+++ b/tests/util/BufferUtils.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2020 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.
+ */
+
+#ifndef MINIKIN_TEST_BUFFER_UTILS_H
+#define MINIKIN_TEST_BUFFER_UTILS_H
+
+#include <minikin/Buffer.h>
+#include <vector>
+
+namespace minikin {
+
+template <class T>
+std::vector<uint8_t> allocateBuffer(const T& t) {
+ BufferWriter writer(nullptr);
+ t.writeTo(&writer);
+ // Fill with 0xFF for debugging.
+ return std::vector<uint8_t>(writer.size(), 0xFFu);
+}
+
+template <class T, auto arg>
+std::vector<uint8_t> allocateBuffer(const T& t) {
+ BufferWriter writer(nullptr);
+ t.template writeTo<arg>(&writer);
+ // Fill with 0xFF for debugging.
+ return std::vector<uint8_t>(writer.size(), 0xFFu);
+}
+
+template <class T>
+std::vector<uint8_t> writeToBuffer(const T& t) {
+ std::vector<uint8_t> buffer = allocateBuffer(t);
+ BufferWriter writer(buffer.data());
+ t.writeTo(&writer);
+ return buffer;
+}
+
+template <class T, auto arg>
+std::vector<uint8_t> writeToBuffer(const T& t) {
+ std::vector<uint8_t> buffer = allocateBuffer<T, arg>(t);
+ BufferWriter writer(buffer.data());
+ t.template writeTo<arg>(&writer);
+ return buffer;
+}
+
+} // namespace minikin
+
+#endif // MINIKIN_TEST_BUFFER_UTILS_H
diff --git a/tests/util/FontTestUtils.cpp b/tests/util/FontTestUtils.cpp
index 4143c04..5370ab6 100644
--- a/tests/util/FontTestUtils.cpp
+++ b/tests/util/FontTestUtils.cpp
@@ -67,7 +67,7 @@
}
}
- std::vector<Font> fonts;
+ std::vector<std::shared_ptr<Font>> fonts;
for (xmlNode* fontNode = familyNode->children; fontNode; fontNode = fontNode->next) {
if (xmlStrcmp(fontNode->name, (const xmlChar*)"font") != 0) {
continue;
@@ -124,7 +124,7 @@
std::shared_ptr<FontFamily> buildFontFamily(const std::string& filePath) {
auto font = std::make_shared<FreeTypeMinikinFontForTest>(getTestFontPath(filePath));
- std::vector<Font> fonts;
+ std::vector<std::shared_ptr<Font>> fonts;
fonts.push_back(Font::Builder(font).build());
return std::make_shared<FontFamily>(std::move(fonts));
}
@@ -132,7 +132,7 @@
std::shared_ptr<FontFamily> buildFontFamily(const std::string& filePath, const std::string& lang,
bool isCustomFallback) {
auto font = std::make_shared<FreeTypeMinikinFontForTest>(getTestFontPath(filePath));
- std::vector<Font> fonts;
+ std::vector<std::shared_ptr<Font>> fonts;
fonts.push_back(Font::Builder(font).build());
return std::make_shared<FontFamily>(LocaleListCache::getId(lang), FamilyVariant::DEFAULT,
std::move(fonts), isCustomFallback);
diff --git a/tests/util/FreeTypeMinikinFontForTest.cpp b/tests/util/FreeTypeMinikinFontForTest.cpp
index 1ea0631..1be466a 100644
--- a/tests/util/FreeTypeMinikinFontForTest.cpp
+++ b/tests/util/FreeTypeMinikinFontForTest.cpp
@@ -37,8 +37,6 @@
namespace minikin {
namespace {
-static int uniqueId = 0;
-
constexpr FT_Int32 LOAD_FLAG =
FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
@@ -62,7 +60,7 @@
} // namespace
FreeTypeMinikinFontForTest::FreeTypeMinikinFontForTest(const std::string& font_path, int index)
- : MinikinFont(uniqueId++), mFontPath(font_path), mFontIndex(index) {
+ : mFontPath(font_path), mFontIndex(index) {
int fd = open(font_path.c_str(), O_RDONLY);
LOG_ALWAYS_FATAL_IF(fd == -1, "Open failed: %s", font_path.c_str());
struct stat st = {};
@@ -114,4 +112,18 @@
extent->descent = -static_cast<float>(mFtFace->descender) * paint.size / upem;
}
+void writeFreeTypeMinikinFontForTest(BufferWriter* writer, const MinikinFont* typeface) {
+ writer->writeString(typeface->GetFontPath());
+}
+
+std::shared_ptr<MinikinFont> loadFreeTypeMinikinFontForTest(BufferReader reader) {
+ std::string fontPath(reader.readString());
+ return std::make_shared<FreeTypeMinikinFontForTest>(fontPath);
+}
+
+Font::TypefaceLoader* readFreeTypeMinikinFontForTest(BufferReader* reader) {
+ reader->skipString(); // fontPath
+ return &loadFreeTypeMinikinFontForTest;
+}
+
} // namespace minikin
diff --git a/tests/util/FreeTypeMinikinFontForTest.h b/tests/util/FreeTypeMinikinFontForTest.h
index 4b6ea05..4cdb6d8 100644
--- a/tests/util/FreeTypeMinikinFontForTest.h
+++ b/tests/util/FreeTypeMinikinFontForTest.h
@@ -19,6 +19,8 @@
#include <string>
+#include "minikin/Buffer.h"
+#include "minikin/Font.h"
#include "minikin/MinikinFont.h"
#include <ft2build.h>
@@ -43,8 +45,7 @@
void GetFontExtent(MinikinExtent* extent, const MinikinPaint& paint,
const FontFakery& fakery) const override;
- const std::string& fontPath() const { return mFontPath; }
-
+ const std::string& GetFontPath() const override { return mFontPath; }
const void* GetFontData() const { return mFontData; }
size_t GetFontSize() const { return mFontSize; }
int GetFontIndex() const { return mFontIndex; }
@@ -63,6 +64,10 @@
MINIKIN_PREVENT_COPY_AND_ASSIGN(FreeTypeMinikinFontForTest);
};
+void writeFreeTypeMinikinFontForTest(BufferWriter* writer, const MinikinFont* typeface);
+
+Font::TypefaceLoader* readFreeTypeMinikinFontForTest(BufferReader* reader);
+
} // namespace minikin
#endif // MINIKIN_TEST_FREE_TYPE_MINIKIN_FONT_FOR_TEST_H
