From cd404cb5e1aed30b46a7af7ddb91ba6e126fe4c2 Mon Sep 17 00:00:00 2001 From: Chad Jones Date: Fri, 19 Apr 2013 10:28:48 -0700 Subject: [PATCH 001/364] Initial empty repository From c1a6032ce6990fe982cddf67e1902fdad4fb398b Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Tue, 23 Apr 2013 15:45:41 -0700 Subject: [PATCH 002/364] Initial commit of Minikin library This is the initial draft of Minikin, a library intended to perform text layout functions. This version does basic weight selection and font runs for scripts, and also has a simple renderer for drawing into bitmaps, but is lacking measurement, line breaking, and a number of other important features. It also lacks caching and other performance refinements. Change-Id: I789a2e47d11d71202dc84b4751b51a5e2cd9c451 --- .../flutter/include/minikin/AnalyzeStyle.h | 26 ++ .../flutter/include/minikin/CmapCoverage.h | 31 ++ engine/src/flutter/include/minikin/CssParse.h | 86 ++++++ .../flutter/include/minikin/FontCollection.h | 90 ++++++ .../src/flutter/include/minikin/FontFamily.h | 67 +++++ engine/src/flutter/include/minikin/Layout.h | 89 ++++++ .../flutter/include/minikin/SparseBitSet.h | 92 ++++++ .../src/flutter/libs/minikin/AnalyzeStyle.cpp | 43 +++ engine/src/flutter/libs/minikin/Android.mk | 43 +++ .../src/flutter/libs/minikin/CmapCoverage.cpp | 179 ++++++++++++ engine/src/flutter/libs/minikin/CssParse.cpp | 162 +++++++++++ .../flutter/libs/minikin/FontCollection.cpp | 150 ++++++++++ .../src/flutter/libs/minikin/FontFamily.cpp | 95 +++++++ engine/src/flutter/libs/minikin/Layout.cpp | 264 ++++++++++++++++++ .../src/flutter/libs/minikin/SparseBitSet.cpp | 147 ++++++++++ engine/src/flutter/sample/Android.mk | 42 +++ engine/src/flutter/sample/example.cpp | 100 +++++++ 17 files changed, 1706 insertions(+) create mode 100644 engine/src/flutter/include/minikin/AnalyzeStyle.h create mode 100644 engine/src/flutter/include/minikin/CmapCoverage.h create mode 100644 engine/src/flutter/include/minikin/CssParse.h create mode 100644 engine/src/flutter/include/minikin/FontCollection.h create mode 100644 engine/src/flutter/include/minikin/FontFamily.h create mode 100644 engine/src/flutter/include/minikin/Layout.h create mode 100644 engine/src/flutter/include/minikin/SparseBitSet.h create mode 100644 engine/src/flutter/libs/minikin/AnalyzeStyle.cpp create mode 100644 engine/src/flutter/libs/minikin/Android.mk create mode 100644 engine/src/flutter/libs/minikin/CmapCoverage.cpp create mode 100644 engine/src/flutter/libs/minikin/CssParse.cpp create mode 100644 engine/src/flutter/libs/minikin/FontCollection.cpp create mode 100644 engine/src/flutter/libs/minikin/FontFamily.cpp create mode 100644 engine/src/flutter/libs/minikin/Layout.cpp create mode 100644 engine/src/flutter/libs/minikin/SparseBitSet.cpp create mode 100644 engine/src/flutter/sample/Android.mk create mode 100644 engine/src/flutter/sample/example.cpp diff --git a/engine/src/flutter/include/minikin/AnalyzeStyle.h b/engine/src/flutter/include/minikin/AnalyzeStyle.h new file mode 100644 index 0000000000..298947742a --- /dev/null +++ b/engine/src/flutter/include/minikin/AnalyzeStyle.h @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINIKIN_ANALYZE_STYLE_H +#define MINIKIN_ANALYZE_STYLE_H + +namespace android { + +bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic); + +} // namespace android + +#endif // MINIKIN_ANALYZE_STYLE_H \ No newline at end of file diff --git a/engine/src/flutter/include/minikin/CmapCoverage.h b/engine/src/flutter/include/minikin/CmapCoverage.h new file mode 100644 index 0000000000..7054e315fd --- /dev/null +++ b/engine/src/flutter/include/minikin/CmapCoverage.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINIKIN_CMAP_COVERAGE_H +#define MINIKIN_CMAP_COVERAGE_H + +#include + +namespace android { + +class CmapCoverage { +public: + static bool getCoverage(SparseBitSet &coverage, const uint8_t* cmap_data, size_t cmap_size); +}; + +} // namespace android + +#endif // MINIKIN_CMAP_COVERAGE_H diff --git a/engine/src/flutter/include/minikin/CssParse.h b/engine/src/flutter/include/minikin/CssParse.h new file mode 100644 index 0000000000..f79ba1f61c --- /dev/null +++ b/engine/src/flutter/include/minikin/CssParse.h @@ -0,0 +1,86 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINIKIN_CSS_PARSE_H +#define MINIKIN_CSS_PARSE_H + +#include +#include + +namespace android { + +enum CssTag { + unknown, + fontSize, + fontWeight, + fontStyle, + minikinHinting, +}; + +const std::string cssTagNames[] = { + "unknown", + "font-size", + "font-weight", + "font-style", + "-minikin-hinting", +}; + +class CssValue { +public: + enum Type { + UNKNOWN, + FLOAT + }; + enum Units { + SCALAR, + PERCENT, + PX, + EM + }; + CssValue() : mType(UNKNOWN) { } + explicit CssValue(double v) : + mType(FLOAT), floatValue(v), mUnits(SCALAR) { } + Type getType() const { return mType; } + double getFloatValue() const { return floatValue; } + int getIntValue() const { return floatValue; } + std::string toString(CssTag tag) const; + void setFloatValue(double v) { + mType = FLOAT; + floatValue = v; + } +private: + Type mType; + double floatValue; + Units mUnits; +}; + +class CssProperties { +public: + bool parse(const std::string& str); + bool hasTag(CssTag tag) const; + CssValue value(CssTag tag) const; + + // primarily for debugging + std::string toString() const; +private: + // We'll use STL map for now but can replace it with something + // more efficient if needed + std::map mMap; +}; + +} // namespace android + +#endif // MINIKIN_CSS_PARSE_H \ No newline at end of file diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h new file mode 100644 index 0000000000..3aa2acace2 --- /dev/null +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINIKIN_FONT_COLLECTION_H +#define MINIKIN_FONT_COLLECTION_H + +#include + +#include +#include FT_FREETYPE_H +#include FT_TRUETYPE_TABLES_H + +#include "SparseBitSet.h" +#include "FontFamily.h" + +namespace android { + +class FontCollection { +public: + explicit FontCollection(const std::vector& typefaces); + + ~FontCollection(); + + const FontFamily* getFamilyForChar(uint32_t ch) const; + class Run { + public: + // Do copy constructor, assignment, destructor so it can be used in vectors + Run() : font(NULL) { } + Run(const Run& other): font(other.font), start(other.start), end(other.end) { + if (font) FT_Reference_Face(font); + } + Run& operator=(const Run& other) { + if (other.font) FT_Reference_Face(other.font); + if (font) FT_Done_Face(font); + font = other.font; + start = other.start; + end = other.end; + return *this; + } + ~Run() { if (font) FT_Done_Face(font); } + + FT_Face font; + int start; + int end; + }; + void itemize(const uint16_t *string, size_t string_length, FontStyle style, + std::vector* result) const; + private: + static const int kLogCharsPerPage = 8; + static const int kPageMask = (1 << kLogCharsPerPage) - 1; + + struct FontInstance { + SparseBitSet* mCoverage; + FontFamily* mFamily; + }; + + struct Range { + size_t start; + size_t end; + }; + + // Highest UTF-32 code point that can be mapped + uint32_t mMaxChar; + + // This vector has ownership of the bitsets and typeface objects. + std::vector mInstances; + + // This vector contains pointers into mInstances + std::vector mInstanceVec; + + // These are offsets into mInstanceVec, one range per page + std::vector mRanges; +}; + +} // namespace android + +#endif // MINIKIN_FONT_COLLECTION_H diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h new file mode 100644 index 0000000000..01ea232252 --- /dev/null +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINIKIN_FONT_FAMILY_H +#define MINIKIN_FONT_FAMILY_H + +#include + +namespace android { + +// FontStyle represents all style information needed to select an actual font +// from a collection. The implementation is packed into a single 32-bit word +// so it can be efficiently copied, embedded in other objects, etc. +class FontStyle { +public: + FontStyle(int weight = 4, bool italic = false) { + bits = (weight & kWeightMask) | (italic ? kItalicMask : 0); + } + int getWeight() { return bits & kWeightMask; } + bool getItalic() { return (bits & kItalicMask) != 0; } + bool operator==(const FontStyle other) { return bits == other.bits; } + // TODO: language, variant +private: + static const int kWeightMask = 0xf; + static const int kItalicMask = 16; + uint32_t bits; +}; + +class FontFamily { +public: + // Add font to family, extracting style information from the font + bool addFont(FT_Face typeface); + + void addFont(FT_Face typeface, FontStyle style); + FT_Face getClosestMatch(FontStyle style) const; + + // API's for enumerating the fonts in a family. These don't guarantee any particular order + size_t getNumFonts() const; + FT_Face getFont(size_t index) const; + FontStyle getStyle(size_t index) const; +private: + class Font { + public: + Font(FT_Face typeface, FontStyle style) : + typeface(typeface), style(style) { } + FT_Face typeface; + FontStyle style; + }; + std::vector mFonts; +}; + +} // namespace android + +#endif // MINIKIN_FONT_FAMILY_H diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h new file mode 100644 index 0000000000..7a6c6cfc25 --- /dev/null +++ b/engine/src/flutter/include/minikin/Layout.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINIKIN_LAYOUT_H +#define MINIKIN_LAYOUT_H + +#include +#include FT_FREETYPE_H + +#include + +#include + +#include +#include + +namespace android { + +// The Bitmap class is for debugging. We'll probably move it out +// of here into a separate lightweight software rendering module +// (optional, as we'd hope most clients would do their own) +class Bitmap { +public: + Bitmap(int width, int height); + ~Bitmap(); + void writePnm(std::ofstream& o) const; + void drawGlyph(const FT_Bitmap& bitmap, int x, int y); +private: + int width; + int height; + uint8_t* buf; +}; + +struct LayoutGlyph { + // index into mFaces and mHbFonts vectors. We could imagine + // moving this into a run length representation, because it's + // more efficient for long strings, and we'll probably need + // something like that for paint attributes (color, underline, + // fake b/i, etc), as having those per-glyph is bloated. + int font_ix; + + unsigned int glyph_id; + float x; + float y; +}; + +class Layout { +public: + void dump() const; + void setFontCollection(const FontCollection *collection); + void doLayout(const uint16_t* buf, size_t nchars); + void draw(Bitmap*, int x0, int y0) const; + void setProperties(const std::string css); + + // This must be called before any invocations. + // TODO: probably have a factory instead + static void init(); +private: + // Find a face in the mFaces vector, or create a new entry + int findFace(FT_Face face); + + CssProperties mProps; // TODO: want spans + std::vector mGlyphs; + + // In future, this will be some kind of mapping from the + // identifier used to represent font-family to a font collection. + // But for the time being, it should be ok to have just one + // per layout. + const FontCollection *mCollection; + std::vector mFaces; + std::vector mHbFonts; +}; + +} // namespace android + +#endif // MINIKIN_LAYOUT_H diff --git a/engine/src/flutter/include/minikin/SparseBitSet.h b/engine/src/flutter/include/minikin/SparseBitSet.h new file mode 100644 index 0000000000..4004606f1d --- /dev/null +++ b/engine/src/flutter/include/minikin/SparseBitSet.h @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2012 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_SPARSE_BIT_SET_H +#define MINIKIN_SPARSE_BIT_SET_H + +#include +#include +#include "utils/UniquePtr.h" + +// --------------------------------------------------------------------------- + +namespace android { + +// This is an implementation of a set of integers. It is optimized for +// values that are somewhat sparse, in the ballpark of a maximum value +// of thousands to millions. It is particularly efficient when there are +// large gaps. The motivating example is Unicode coverage of a font, but +// the abstraction itself is fully general. + +class SparseBitSet { +public: + SparseBitSet(): mMaxVal(0) { + } + + // Clear the set + void clear(); + + // Initialize the set to a new value, represented by ranges. For + // simplicity, these ranges are arranged as pairs of values, + // inclusive of start, exclusive of end, laid out in a uint32 array. + void initFromRanges(const uint32_t* ranges, size_t nRanges); + + // Determine whether the value is included in the set + bool get(uint32_t ch) const { + if (ch >= mMaxVal) return false; + uint32_t *bitmap = &mBitmaps[mIndices[ch >> kLogValuesPerPage]]; + uint32_t index = ch & kPageMask; + return (bitmap[index >> kLogBitsPerEl] & (kElFirst >> (index & kElMask))) != 0; + } + + // One more than the maximum value in the set, or zero if empty + uint32_t length() const { + return mMaxVal; + } + + // The next set bit starting at fromIndex, inclusive, or kNotFound + // if none exists. + uint32_t nextSetBit(uint32_t fromIndex) const; + + static const uint32_t kNotFound = ~0u; + +private: + static const int kLogValuesPerPage = 8; + static const int kPageMask = (1 << kLogValuesPerPage) - 1; + static const int kLogBytesPerEl = 2; + static const int kLogBitsPerEl = kLogBytesPerEl + 3; + static const int kElMask = (1 << kLogBitsPerEl) - 1; + // invariant: sizeof(element) == (1 << kLogBytesPerEl) + typedef uint32_t element; + static const element kElAllOnes = ~((element)0); + static const element kElFirst = ((element)1) << kElMask; + static const uint32_t noZeroPage = ~0u; + + static uint32_t calcNumPages(const uint32_t* ranges, size_t nRanges); + static int CountLeadingZeros(element x); + + uint32_t mMaxVal; + UniquePtr mIndices; + UniquePtr mBitmaps; + uint32_t mZeroPageIndex; +}; + +// Note: this thing cannot be used in vectors yet. If that were important, we'd need to +// make the copy constructor work, and probably set up move traits as well. + +}; // namespace android + +#endif // MINIKIN_SPARSE_BIT_SET_H diff --git a/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp b/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp new file mode 100644 index 0000000000..0961645290 --- /dev/null +++ b/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include + +namespace android { + +// should we have a single FontAnalyzer class this stuff lives in, to avoid dup? +static int32_t readU16(const uint8_t* data, size_t offset) { + return data[offset] << 8 | data[offset + 1]; +} + +bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic) { + const size_t kUsWeightClassOffset = 4; + const size_t kFsSelectionOffset = 62; + const uint16_t kItalicFlag = (1 << 0); + if (os2_size < kFsSelectionOffset + 2) { + return false; + } + uint16_t weightClass = readU16(os2_data, kUsWeightClassOffset); + *weight = weightClass / 100; + uint16_t fsSelection = readU16(os2_data, kFsSelectionOffset); + *italic = (fsSelection & kItalicFlag) != 0; + return true; +} + +} // namespace android diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk new file mode 100644 index 0000000000..9795ad05d0 --- /dev/null +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -0,0 +1,43 @@ +# Copyright (C) 2013 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) +include external/stlport/libstlport.mk + +LOCAL_SRC_FILES := \ + AnalyzeStyle.cpp \ + CmapCoverage.cpp \ + CssParse.cpp \ + FontCollection.cpp \ + FontFamily.cpp \ + Layout.cpp \ + SparseBitSet.cpp + +LOCAL_MODULE := libminikin + +LOCAL_C_INCLUDES += \ + external/harfbuzz_ng/src \ + external/freetype/include \ + frameworks/minikin/include + +LOCAL_SHARED_LIBRARIES := \ + libharfbuzz_ng \ + libstlport + +LOCAL_STATIC_LIBARIES := \ + libft2 + +include $(BUILD_STATIC_LIBRARY) diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp new file mode 100644 index 0000000000..4156d69d5a --- /dev/null +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -0,0 +1,179 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Determine coverage of font given its raw "cmap" OpenType table + +#ifdef PRINTF_DEBUG +#include +#endif + +#include +using std::vector; + +#include +#include + +namespace android { + +// These could perhaps be optimized to use __builtin_bswap16 and friends. +static uint32_t readU16(const uint8_t* data, size_t offset) { + return data[offset] << 8 | data[offset + 1]; +} + +static uint32_t readU32(const uint8_t* data, size_t offset) { + return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]; +} + +static void addRange(vector &coverage, uint32_t start, uint32_t end) { +#ifdef PRINTF_DEBUG + printf("adding range %d-%d\n", start, end); +#endif + if (coverage.empty() || coverage.back() < start) { + coverage.push_back(start); + coverage.push_back(end); + } else { + coverage.back() = end; + } +} + +// Get the coverage information out of a Format 12 subtable, storing it in the coverage vector +static bool getCoverageFormat4(vector& coverage, const uint8_t* data, size_t size) { + const size_t kSegCountOffset = 6; + const size_t kEndCountOffset = 14; + const size_t kHeaderSize = 16; + const size_t kSegmentSize = 8; // total size of array elements for one segment + if (kEndCountOffset > size) { + return false; + } + size_t segCount = readU16(data, kSegCountOffset) >> 1; + if (kHeaderSize + segCount * kSegmentSize > size) { + return false; + } + for (size_t i = 0; i < segCount; i++) { + int end = readU16(data, kEndCountOffset + 2 * i); + int start = readU16(data, kHeaderSize + 2 * (segCount + i)); + int rangeOffset = readU16(data, kHeaderSize + 2 * (3 * segCount + i)); + if (rangeOffset == 0) { + int delta = readU16(data, kHeaderSize + 2 * (2 * segCount + i)); + if (((end + delta) & 0xffff) > end - start) { + addRange(coverage, start, end + 1); + } else { + for (int j = start; j < end + 1; j++) { + if (((j + delta) & 0xffff) != 0) { + addRange(coverage, j, j + 1); + } + } + } + } else { + for (int j = start; j < end + 1; j++) { + uint32_t actualRangeOffset = kHeaderSize + 6 * segCount + rangeOffset + + (i + j - start) * 2; + if (actualRangeOffset + 2 > size) { + return false; + } + int glyphId = readU16(data, actualRangeOffset); + if (glyphId != 0) { + addRange(coverage, j, j + 1); + } + } + } + } + return true; +} + +// Get the coverage information out of a Format 12 subtable, storing it in the coverage vector +static bool getCoverageFormat12(vector& coverage, const uint8_t* data, size_t size) { + const size_t kNGroupsOffset = 12; + const size_t kFirstGroupOffset = 16; + const size_t kGroupSize = 12; + const size_t kStartCharCodeOffset = 0; + const size_t kEndCharCodeOffset = 4; + if (kFirstGroupOffset > size) { + return false; + } + uint32_t nGroups = readU32(data, kNGroupsOffset); + if (kFirstGroupOffset + nGroups * kGroupSize > size) { + return false; + } + for (uint32_t i = 0; i < nGroups; i++) { + uint32_t groupOffset = kFirstGroupOffset + i * kGroupSize; + uint32_t start = readU32(data, groupOffset + kStartCharCodeOffset); + uint32_t end = readU32(data, groupOffset + kEndCharCodeOffset); + addRange(coverage, start, end + 1); // file is inclusive, vector is exclusive + } + return true; +} + +bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, size_t cmap_size) { + vector coverageVec; + const size_t kHeaderSize = 4; + const size_t kNumTablesOffset = 2; + const size_t kTableSize = 8; + const size_t kPlatformIdOffset = 0; + const size_t kEncodingIdOffset = 2; + const size_t kOffsetOffset = 4; + const int kMicrosoftPlatformId = 3; + const int kUnicodeBmpEncodingId = 1; + const int kUnicodeUcs4EncodingId = 10; + if (kHeaderSize > cmap_size) { + return false; + } + int numTables = readU16(cmap_data, kNumTablesOffset); + if (kHeaderSize + numTables * kTableSize > cmap_size) { + return false; + } + int bestTable = -1; + for (int i = 0; i < numTables; i++) { + uint16_t platformId = readU16(cmap_data, kHeaderSize + i * kTableSize + kPlatformIdOffset); + uint16_t encodingId = readU16(cmap_data, kHeaderSize + i * kTableSize + kEncodingIdOffset); + if (platformId == kMicrosoftPlatformId && encodingId == kUnicodeUcs4EncodingId) { + bestTable = i; + break; + } else if (platformId == kMicrosoftPlatformId && encodingId == kUnicodeBmpEncodingId) { + bestTable = i; + } + } +#ifdef PRINTF_DEBUG + printf("best table = %d\n", bestTable); +#endif + if (bestTable < 0) { + return false; + } + uint32_t offset = readU32(cmap_data, kHeaderSize + bestTable * kTableSize + kOffsetOffset); + if (offset + 2 > cmap_size) { + return false; + } + uint16_t format = readU16(cmap_data, offset); + bool success = false; + const uint8_t* tableData = cmap_data + offset; + const size_t tableSize = cmap_size - offset; + if (format == 4) { + success = getCoverageFormat4(coverageVec, tableData, tableSize); + } else if (format == 12) { + success = getCoverageFormat12(coverageVec, tableData, tableSize); + } + if (success) { + coverage.initFromRanges(&coverageVec.front(), coverageVec.size() >> 1); + } +#ifdef PRINTF_DEBUG + for (int i = 0; i < coverageVec.size(); i += 2) { + printf("%x:%x\n", coverageVec[i], coverageVec[i + 1]); + } +#endif + return success; +} + +} // namespace android diff --git a/engine/src/flutter/libs/minikin/CssParse.cpp b/engine/src/flutter/libs/minikin/CssParse.cpp new file mode 100644 index 0000000000..d4de23bee0 --- /dev/null +++ b/engine/src/flutter/libs/minikin/CssParse.cpp @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include // for sprintf - for debugging + +#include + +using std::map; +using std::pair; +using std::string; + +namespace android { + +bool strEqC(const string str, size_t off, size_t len, const char* str2) { + if (len != strlen(str2)) return false; + return !memcmp(str.data() + off, str2, len); +} + +CssTag parseTag(const string str, size_t off, size_t len) { + if (len == 0) return unknown; + char c = str[off]; + if (c == 'f') { + if (strEqC(str, off, len, "font-size")) return fontSize; + if (strEqC(str, off, len, "font-weight")) return fontWeight; + if (strEqC(str, off, len, "font-style")) return fontStyle; + } else if (c == '-') { + if (strEqC(str, off, len, "-minikin-hinting")) return minikinHinting; + } + return unknown; +} + +bool parseValue(const string str, size_t *off, size_t len, CssTag tag, + CssValue* v) { + const char* data = str.data(); + char* endptr; + double fv = strtod(data + *off, &endptr); + if (endptr == data + *off) { + // No numeric value, try tag-specific idents + size_t end; + for (end = *off; end < len; end++) { + char c = data[end]; + if (c != '-' && !(c >= 'a' && c <= 'z') && + !(c >= '0' && c <= '9')) break; + } + size_t taglen = end - *off; + endptr += taglen; + if (tag == fontStyle) { + if (strEqC(str, *off, taglen, "normal")) { + fv = 0; + } else if (strEqC(str, *off, taglen, "italic")) { + fv = 1; + // TODO: oblique, but who really cares? + } else { + return false; + } + } else if (tag == fontWeight) { + if (strEqC(str, *off, taglen, "normal")) { + fv = 400; + } else if (strEqC(str, *off, taglen, "bold")) { + fv = 700; + } else { + return false; + } + } else { + return false; + } + } + v->setFloatValue(fv); + *off = endptr - data; + return true; +} + +string CssValue::toString(CssTag tag) const { + if (mType == FLOAT) { + if (tag == fontStyle) { + return floatValue ? "italic" : "normal"; + } + char buf[64]; + sprintf(buf, "%g", floatValue); + return string(buf); + } + return ""; +} + +bool CssProperties::parse(const string& str) { + size_t len = str.size(); + size_t i = 0; + while (true) { + size_t j = i; + while (j < len && str[j] == ' ') j++; + if (j == len) break; + size_t k = str.find_first_of(':', j); + if (k == string::npos) { + return false; // error: junk after end + } + CssTag tag = parseTag(str, j, k - j); +#ifdef VERBOSE + printf("parseTag result %d, ijk %lu %lu %lu\n", tag, i, j, k); +#endif + if (tag == unknown) return false; // error: unknown tag + k++; // skip over colon + while (k < len && str[k] == ' ') k++; + if (k == len) return false; // error: missing value + CssValue v; + if (!parseValue(str, &k, len, tag, &v)) break; +#ifdef VERBOSE + printf("parseValue ok\n"); +#endif + mMap.insert(pair(tag, v)); + while (k < len && str[k] == ' ') k++; + if (k < len) { + if (str[k] != ';') return false; + k++; + } + i = k; + } + return true; +} + +bool CssProperties::hasTag(CssTag tag) const { + return (mMap.find(tag) != mMap.end()); +} + +CssValue CssProperties::value(CssTag tag) const { + map::const_iterator it = mMap.find(tag); + if (it == mMap.end()) { + CssValue unknown; + return unknown; + } else { + return it->second; + } +} + +string CssProperties::toString() const { + string result; + for (map::const_iterator it = mMap.begin(); + it != mMap.end(); it++) { + result += cssTagNames[it->first]; + result += ": "; + result += it->second.toString(it->first); + result += ";\n"; + } + return result; +} + +} // namespace android diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp new file mode 100644 index 0000000000..7abbd3b302 --- /dev/null +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifdef VERBOSE_DEBUG +#include // for debugging - remove +#endif + +#include +#include + +using std::vector; + +namespace android { + +template +static inline T max(T a, T b) { + return a>b ? a : b; +} + +FontCollection::FontCollection(const vector& typefaces) : + mMaxChar(0) { + vector lastChar; + size_t nTypefaces = typefaces.size(); +#ifdef VERBOSE_DEBUG + printf("nTypefaces = %d\n", nTypefaces); +#endif + const FontStyle defaultStyle; + for (size_t i = 0; i < nTypefaces; i++) { + FontFamily* family = typefaces[i]; + FontInstance dummy; + mInstances.push_back(dummy); // emplace_back would be better + FontInstance* instance = &mInstances.back(); + instance->mFamily = family; + instance->mCoverage = new SparseBitSet; + FT_Face typeface = family->getClosestMatch(defaultStyle); +#ifdef VERBOSE_DEBUG + printf("closest match = %x, family size = %d\n", typeface, family->getNumFonts()); +#endif + const uint32_t cmapTag = FT_MAKE_TAG('c', 'm', 'a', 'p'); + FT_ULong cmapSize = 0; + FT_Error error = FT_Load_Sfnt_Table(typeface, cmapTag, 0, NULL, &cmapSize); + UniquePtr cmapData(new uint8_t[cmapSize]); + error = FT_Load_Sfnt_Table(typeface, cmapTag, 0, + cmapData.get(), &cmapSize); + CmapCoverage::getCoverage(*instance->mCoverage, cmapData.get(), cmapSize); +#ifdef VERBOSE_DEBUG + printf("font coverage length=%d, first ch=%x\n", instance->mCoverage->length(), + instance->mCoverage->nextSetBit(0)); +#endif + mMaxChar = max(mMaxChar, instance->mCoverage->length()); + lastChar.push_back(instance->mCoverage->nextSetBit(0)); + // TODO: should probably ref typeface here, hmm + } + size_t nPages = mMaxChar >> kLogCharsPerPage; + size_t offset = 0; + for (size_t i = 0; i < nPages; i++) { + Range dummy; + mRanges.push_back(dummy); + Range* range = &mRanges.back(); +#ifdef VERBOSE_DEBUG + printf("i=%d: range start = %d\n", i, offset); +#endif + range->start = offset; + for (size_t j = 0; j < nTypefaces; j++) { + if (lastChar[j] < (i + 1) << kLogCharsPerPage) { + const FontInstance* instance = &mInstances[j]; + mInstanceVec.push_back(instance); + offset++; + uint32_t nextChar = instance->mCoverage->nextSetBit((i + 1) << kLogCharsPerPage); +#ifdef VERBOSE_DEBUG + printf("nextChar = %d (j = %d)\n", nextChar, j); +#endif + lastChar[j] = nextChar; + } + } + range->end = offset; + } +} + +FontCollection::~FontCollection() { + for (size_t i = 0; i < mInstances.size(); i++) { + delete mInstances[i].mCoverage; + // probably unref the typeface here too + } +} + +const FontFamily* FontCollection::getFamilyForChar(uint32_t ch) const { + if (ch >= mMaxChar) { + return NULL; + } + const Range& range = mRanges[ch >> kLogCharsPerPage]; +#ifdef VERBOSE_DEBUG + printf("querying range %d:%d\n", range.start, range.end); +#endif + for (size_t i = range.start; i < range.end; i++) { + const FontInstance* instance = mInstanceVec[i]; + if (instance->mCoverage->get(ch)) { + return instance->mFamily; + } + } + return NULL; +} + +void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style, + vector* result) const { + const FontFamily* lastFamily = NULL; + Run* run = NULL; + int nShorts; + for (size_t i = 0; i < string_size; i += nShorts) { + nShorts = 1; + uint32_t ch = string[i]; + // sigh, decode UTF-16 by hand here + if ((ch & 0xfc00) == 0xd800) { + if ((i + 1) < string_size) { + ch = 0x10000 + ((ch & 0x3ff) << 10) + (string[i + 1] & 0x3ff); + nShorts = 2; + } + } + const FontFamily* family = getFamilyForChar(ch); + if (i == 0 || family != lastFamily) { + Run dummy; + result->push_back(dummy); + run = &result->back(); + if (family == NULL) { + run->font = NULL; // maybe we should do something different here + } else { + run->font = family->getClosestMatch(style); + FT_Reference_Face(run->font); + } + lastFamily = family; + run->start = i; + } + run->end = i + nShorts; + } +} + +} // namespace android diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp new file mode 100644 index 0000000000..dc6e16ce83 --- /dev/null +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "Minikin" + +#include +#include +#include +#include +#include +#include FT_FREETYPE_H +#include FT_TRUETYPE_TABLES_H +#include +#include + +using std::vector; + +namespace android { + +bool FontFamily::addFont(FT_Face typeface) { + const uint32_t os2Tag = FT_MAKE_TAG('O', 'S', '/', '2'); + FT_ULong os2Size = 0; + FT_Error error = FT_Load_Sfnt_Table(typeface, os2Tag, 0, NULL, &os2Size); + if (error != 0) return false; + UniquePtr os2Data(new uint8_t[os2Size]); + error = FT_Load_Sfnt_Table(typeface, os2Tag, 0, os2Data.get(), &os2Size); + if (error != 0) return false; + int weight; + bool italic; + if (analyzeStyle(os2Data.get(), os2Size, &weight, &italic)) { + //ALOGD("analyzed weight = %d, italic = %s", weight, italic ? "true" : "false"); + FontStyle style(weight, italic); + addFont(typeface, style); + return true; + } else { + ALOGD("failed to analyze style"); + } + return false; +} + +void FontFamily::addFont(FT_Face typeface, FontStyle style) { + mFonts.push_back(Font(typeface, style)); + ALOGD("added font, mFonts.size() = %d", mFonts.size()); +} + +// Compute a matching metric between two styles - 0 is an exact match +int computeMatch(FontStyle style1, FontStyle style2) { + if (style1 == style2) return 0; + int score = abs(style1.getWeight() - style2.getWeight()); + if (style1.getItalic() != style2.getItalic()) { + score += 2; + } + return score; +} + +FT_Face FontFamily::getClosestMatch(FontStyle style) const { + const Font* bestFont = NULL; + int bestMatch = 0; + for (size_t i = 0; i < mFonts.size(); i++) { + const Font& font = mFonts[i]; + int match = computeMatch(font.style, style); + if (i == 0 || match < bestMatch) { + bestFont = &font; + bestMatch = match; + } + } + return bestFont == NULL ? NULL : bestFont->typeface; +} + +size_t FontFamily::getNumFonts() const { + return mFonts.size(); +} + +FT_Face FontFamily::getFont(size_t index) const { + return mFonts[index].typeface; +} + +FontStyle FontFamily::getStyle(size_t index) const { + return mFonts[index].style; +} + +} // namespace android diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp new file mode 100644 index 0000000000..a8a596d729 --- /dev/null +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -0,0 +1,264 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include // for debugging + +#include + +using std::string; +using std::vector; + +namespace android { + +// TODO: globals are not cool, move to a factory-ish object +hb_buffer_t* buffer = 0; + +Bitmap::Bitmap(int width, int height) : width(width), height(height) { + buf = new uint8_t[width * height](); +} + +Bitmap::~Bitmap() { + delete[] buf; +} + +void Bitmap::writePnm(std::ofstream &o) const { + o << "P5" << std::endl; + o << width << " " << height << std::endl; + o << "255" << std::endl; + o.write((const char *)buf, width * height); + o.close(); +} + +void Bitmap::drawGlyph(const FT_Bitmap& bitmap, int x, int y) { + int bmw = bitmap.width; + int bmh = bitmap.rows; + int x0 = std::max(0, x); + int x1 = std::min(width, x + bmw); + int y0 = std::max(0, y); + int y1 = std::min(height, y + bmh); + const unsigned char* src = bitmap.buffer + (y0 - y) * bmw + (x0 - x); + uint8_t* dst = buf + y0 * width; + for (int yy = y0; yy < y1; yy++) { + for (int xx = x0; xx < x1; xx++) { + int pixel = (int)dst[xx] + (int)src[xx - x]; + pixel = pixel > 0xff ? 0xff : pixel; + dst[xx] = pixel; + } + src += bmw; + dst += width; + } +} + +void Layout::init() { + buffer = hb_buffer_create(); +} + +void Layout::setFontCollection(const FontCollection *collection) { + mCollection = collection; +} + +hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { + FT_Face ftFace = reinterpret_cast(userData); + FT_ULong length = 0; + FT_Error error = FT_Load_Sfnt_Table(ftFace, tag, 0, NULL, &length); + if (error) { + return 0; + } + char *buffer = reinterpret_cast(malloc(length)); + if (!buffer) { + return 0; + } + error = FT_Load_Sfnt_Table(ftFace, tag, 0, + reinterpret_cast(buffer), &length); + if (error) { + free(buffer); + return 0; + } + return hb_blob_create(const_cast(buffer), length, + HB_MEMORY_MODE_WRITABLE, buffer, free); +} + +static hb_bool_t harfbuzzGetGlyph(hb_font_t* hbFont, void* fontData, hb_codepoint_t unicode, hb_codepoint_t variationSelector, hb_codepoint_t* glyph, void* userData) +{ + FT_Face ftFace = reinterpret_cast(fontData); + FT_UInt glyph_index = FT_Get_Char_Index(ftFace, unicode); + *glyph = glyph_index; + return !!*glyph; +} + +static hb_position_t ft_pos_to_hb(FT_Pos pos) { + return pos << 2; +} + +static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, void* userData) +{ + FT_Face ftFace = reinterpret_cast(fontData); + hb_position_t advance = 0; + + FT_Load_Glyph(ftFace, glyph, FT_LOAD_DEFAULT); + return ft_pos_to_hb(ftFace->glyph->advance.x); +} + +static hb_bool_t harfbuzzGetGlyphHorizontalOrigin(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, hb_position_t* x, hb_position_t* y, void* userData) +{ + // Just return true, following the way that Harfbuzz-FreeType + // implementation does. + return true; +} + +hb_font_funcs_t* getHbFontFuncs() { + static hb_font_funcs_t* hbFontFuncs = 0; + + if (hbFontFuncs == 0) { + hbFontFuncs = hb_font_funcs_create(); + hb_font_funcs_set_glyph_func(hbFontFuncs, harfbuzzGetGlyph, 0, 0); + hb_font_funcs_set_glyph_h_advance_func(hbFontFuncs, harfbuzzGetGlyphHorizontalAdvance, 0, 0); + hb_font_funcs_set_glyph_h_origin_func(hbFontFuncs, harfbuzzGetGlyphHorizontalOrigin, 0, 0); + hb_font_funcs_make_immutable(hbFontFuncs); + } + return hbFontFuncs; +} + +hb_font_t* create_hb_font(FT_Face ftFace) { + hb_face_t* face = hb_face_create_for_tables(referenceTable, ftFace, NULL); + hb_font_t* font = hb_font_create(face); + hb_font_set_funcs(font, getHbFontFuncs(), ftFace, 0); + // TODO: manage ownership of face + return font; +} + +static float HBFixedToFloat(hb_position_t v) +{ + return scalbnf (v, -8); +} + +static hb_position_t HBFloatToFixed(float v) +{ + return scalbnf (v, +8); +} + +void Layout::dump() const { + for (size_t i = 0; i < mGlyphs.size(); i++) { + const LayoutGlyph& glyph = mGlyphs[i]; + std::cout << glyph.glyph_id << ": " << glyph.x << ", " << glyph.y << std::endl; + } +} + +// A couple of things probably need to change: +// 1. Deal with multiple sizes in a layout +// 2. We'll probably store FT_Face as primary and then use a cache +// for the hb fonts +int Layout::findFace(FT_Face face) { + unsigned int ix; + for (ix = 0; ix < mFaces.size(); ix++) { + if (mFaces[ix] == face) { + return ix; + } + } + double size = mProps.value(fontSize).getFloatValue(); + FT_Error error = FT_Set_Pixel_Sizes(face, 0, size); + mFaces.push_back(face); + hb_font_t *font = create_hb_font(face); + hb_font_set_ppem(font, size, size); + hb_font_set_scale(font, HBFloatToFixed(size), HBFloatToFixed(size)); + mHbFonts.push_back(font); + return ix; +} + +static FontStyle styleFromCss(const CssProperties &props) { + int weight = 4; + if (props.hasTag(fontWeight)) { + weight = props.value(fontWeight).getIntValue() / 100; + } + bool italic = false; + if (props.hasTag(fontStyle)) { + italic = props.value(fontStyle).getIntValue() != 0; + } + // TODO: italic property from CSS + return FontStyle(weight, italic); +} + +// TODO: API should probably take context +void Layout::doLayout(const uint16_t* buf, size_t nchars) { + FT_Error error; + + vector items; + FontStyle style = styleFromCss(mProps); + mCollection->itemize(buf, nchars, style, &items); + + mGlyphs.clear(); + mFaces.clear(); + mHbFonts.clear(); + float x = 0; + float y = 0; + for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { + FontCollection::Run &run = items[run_ix]; + int font_ix = findFace(run.font); + hb_font_t *hbFont = mHbFonts[font_ix]; +#ifdef VERBOSE + std::cout << "Run " << run_ix << ", font " << font_ix << + " [" << run.start << ":" << run.end << "]" << std::endl; +#endif + + hb_buffer_reset(buffer); + hb_buffer_set_direction(buffer, HB_DIRECTION_LTR); + hb_buffer_add_utf16(buffer, buf, nchars, run.start, run.end - run.start); + hb_shape(hbFont, buffer, NULL, 0); + unsigned int numGlyphs; + hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); + hb_glyph_position_t *positions = hb_buffer_get_glyph_positions(buffer, NULL); + for (unsigned int i = 0; i < numGlyphs; i++) { +#ifdef VERBOSE + std::cout << positions[i].x_advance << " " << positions[i].y_advance << " " << positions[i].x_offset << " " << positions[i].y_offset << std::endl; std::cout << "DoLayout " << info[i].codepoint << + ": " << HBFixedToFloat(positions[i].x_advance) << "; " << positions[i].x_offset << ", " << positions[i].y_offset << std::endl; +#endif + hb_codepoint_t glyph_ix = info[i].codepoint; + float xoff = HBFixedToFloat(positions[i].x_offset); + float yoff = HBFixedToFloat(positions[i].y_offset); + LayoutGlyph glyph = {font_ix, glyph_ix, x + xoff, y + yoff}; + mGlyphs.push_back(glyph); + x += HBFixedToFloat(positions[i].x_advance); + } + } +} + +void Layout::draw(Bitmap* surface, int x0, int y0) const { + FT_Error error; + FT_Int32 load_flags = FT_LOAD_DEFAULT; + if (mProps.hasTag(minikinHinting)) { + int hintflags = mProps.value(minikinHinting).getIntValue(); + if (hintflags & 1) load_flags |= FT_LOAD_NO_HINTING; + if (hintflags & 2) load_flags |= FT_LOAD_NO_AUTOHINT; + } + for (size_t i = 0; i < mGlyphs.size(); i++) { + const LayoutGlyph& glyph = mGlyphs[i]; + FT_Face face = mFaces[glyph.font_ix]; + error = FT_Load_Glyph(face, glyph.glyph_id, load_flags); + error = FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL); + surface->drawGlyph(face->glyph->bitmap, + x0 + int(floor(glyph.x + 0.5)) + face->glyph->bitmap_left, + y0 + int(floor(glyph.y + 0.5)) - face->glyph->bitmap_top); + } +} + +void Layout::setProperties(string css) { + mProps.parse(css); +} + +} // namespace android diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp new file mode 100644 index 0000000000..e0b3c1d5a7 --- /dev/null +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -0,0 +1,147 @@ +/* + * Copyright (C) 2012 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 +#include +#include + +namespace android { + +const uint32_t SparseBitSet::kNotFound; + +void SparseBitSet::clear() { + mMaxVal = 0; + mIndices.reset(); + mBitmaps.reset(); +} + +uint32_t SparseBitSet::calcNumPages(const uint32_t* ranges, size_t nRanges) { + bool haveZeroPage = false; + uint32_t nonzeroPageEnd = 0; + uint32_t nPages = 0; + for (size_t i = 0; i < nRanges; i++) { + uint32_t start = ranges[i * 2]; + uint32_t end = ranges[i * 2 + 1]; + uint32_t startPage = start >> kLogValuesPerPage; + uint32_t endPage = (end - 1) >> kLogValuesPerPage; + if (startPage >= nonzeroPageEnd) { + if (startPage > nonzeroPageEnd) { + if (!haveZeroPage) { + haveZeroPage = true; + nPages++; + } + } + nPages++; + } + nPages += endPage - startPage; + nonzeroPageEnd = endPage + 1; + } + return nPages; +} + +void SparseBitSet::initFromRanges(const uint32_t* ranges, size_t nRanges) { + if (nRanges == 0) { + mMaxVal = 0; + mIndices.reset(); + mBitmaps.reset(); + return; + } + mMaxVal = ranges[nRanges * 2 - 1]; + size_t indexSize = (mMaxVal + kPageMask) >> kLogValuesPerPage; + mIndices.reset(new uint32_t[indexSize]); + uint32_t nPages = calcNumPages(ranges, nRanges); + mBitmaps.reset(new element[nPages << (kLogValuesPerPage - kLogBitsPerEl)]); + memset(mBitmaps.get(), 0, nPages << (kLogValuesPerPage - 3)); + mZeroPageIndex = noZeroPage; + uint32_t nonzeroPageEnd = 0; + uint32_t currentPage = 0; + for (size_t i = 0; i < nRanges; i++) { + uint32_t start = ranges[i * 2]; + uint32_t end = ranges[i * 2 + 1]; + uint32_t startPage = start >> kLogValuesPerPage; + uint32_t endPage = (end - 1) >> kLogValuesPerPage; + if (startPage >= nonzeroPageEnd) { + if (startPage > nonzeroPageEnd) { + if (mZeroPageIndex == noZeroPage) { + mZeroPageIndex = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl); + } + for (uint32_t j = nonzeroPageEnd; j < startPage; j++) { + mIndices[j] = mZeroPageIndex; + } + } + mIndices[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] |= (kElAllOnes >> (start & kElMask)) & + (kElAllOnes << ((-end) & kElMask)); + } else { + mBitmaps[index] |= kElAllOnes >> (start & kElMask); + for (size_t j = 1; j < nElements - 1; j++) { + mBitmaps[index + j] = kElAllOnes; + } + mBitmaps[index + nElements - 1] |= kElAllOnes << ((-end) & kElMask); + } + for (size_t j = startPage + 1; j < endPage + 1; j++) { + mIndices[j] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl); + } + nonzeroPageEnd = endPage + 1; + } +} + +// Note: this implementation depends on GCC builtin, and also assumes 32-bit elements. +int SparseBitSet::CountLeadingZeros(element x) { + return __builtin_clz(x); +} + +uint32_t SparseBitSet::nextSetBit(uint32_t fromIndex) const { + if (fromIndex >= mMaxVal) { + return kNotFound; + } + uint32_t fromPage = fromIndex >> kLogValuesPerPage; + const element* bitmap = &mBitmaps[mIndices[fromPage]]; + uint32_t offset = (fromIndex & kPageMask) >> kLogBitsPerEl; + element e = bitmap[offset] & (kElAllOnes >> (fromIndex & kElMask)); + if (e != 0) { + return (fromIndex & ~kElMask) + CountLeadingZeros(e); + } + for (uint32_t j = offset + 1; j < (1 << (kLogValuesPerPage - kLogBitsPerEl)); j++) { + e = bitmap[j]; + if (e != 0) { + return (fromIndex & ~kPageMask) + (j << kLogBitsPerEl) + CountLeadingZeros(e); + } + } + uint32_t maxPage = (mMaxVal + kPageMask) >> kLogValuesPerPage; + for (uint32_t page = fromPage + 1; page < maxPage; page++) { + uint32_t index = mIndices[page]; + if (index == mZeroPageIndex) { + continue; + } + bitmap = &mBitmaps[index]; + for (uint32_t j = 0; j < (1 << (kLogValuesPerPage - kLogBitsPerEl)); j++) { + e = bitmap[j]; + if (e != 0) { + return (page << kLogValuesPerPage) + (j << kLogBitsPerEl) + CountLeadingZeros(e); + } + } + } + return kNotFound; +} + +} // namespace android diff --git a/engine/src/flutter/sample/Android.mk b/engine/src/flutter/sample/Android.mk new file mode 100644 index 0000000000..335e7ce787 --- /dev/null +++ b/engine/src/flutter/sample/Android.mk @@ -0,0 +1,42 @@ +# Copyright (C) 2013 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +LOCAL_PATH:= $(call my-dir) + +include $(CLEAR_VARS) +include external/stlport/libstlport.mk + +LOCAL_MODULE_TAGS := tests + +LOCAL_C_INCLUDES += \ + external/harfbuzz_ng/src \ + external/freetype/include \ + external/icu4c/common \ + frameworks/minikin/include + +LOCAL_SRC_FILES:= example.cpp + +LOCAL_SHARED_LIBRARIES += \ + libutils \ + liblog \ + libcutils \ + libstlport \ + libharfbuzz_ng \ + libicuuc + +LOCAL_STATIC_LIBRARIES += libminikin libft2 + +LOCAL_MODULE:= minikin_example + +include $(BUILD_EXECUTABLE) diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp new file mode 100644 index 0000000000..3f0ad9d9a7 --- /dev/null +++ b/engine/src/flutter/sample/example.cpp @@ -0,0 +1,100 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// This is a test program that uses Minikin to layout and draw some text. +// At the moment, it just draws a string into /data/local/tmp/foo.pgm. + +#include +#include +#include + +#include +#include + +#include + +using std::vector; + +namespace android { + +FT_Library library; // TODO: this should not be a global + +FontCollection *makeFontCollection() { + vectortypefaces; + const char *fns[] = { + "/system/fonts/Roboto-Regular.ttf", + "/system/fonts/Roboto-Italic.ttf", + "/system/fonts/Roboto-BoldItalic.ttf", + "/system/fonts/Roboto-Light.ttf", + "/system/fonts/Roboto-Thin.ttf", + "/system/fonts/Roboto-Bold.ttf", + "/system/fonts/Roboto-ThinItalic.ttf", + "/system/fonts/Roboto-LightItalic.ttf" + }; + + FontFamily *family = new FontFamily(); + FT_Face face; + FT_Error error; + for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { + const char *fn = fns[i]; + printf("adding %s\n", fn); + error = FT_New_Face(library, fn, 0, &face); + if (error != 0) { + printf("error loading %s, %d\n", fn, error); + } + family->addFont(face); + } + typefaces.push_back(family); + +#if 0 + family = new FontFamily(); + const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; + error = FT_New_Face(library, fn, 0, &face); + family->addFont(face); + typefaces.push_back(family); +#endif + + return new FontCollection(typefaces); +} + +int runMinikinTest() { + FT_Error error = FT_Init_FreeType(&library); + if (error) { + return -1; + } + Layout::init(); + + FontCollection *collection = makeFontCollection(); + Layout layout; + layout.setFontCollection(collection); + layout.setProperties("font-size: 32;"); + const char *text = "hello world"; + icu::UnicodeString icuText = icu::UnicodeString::fromUTF8(text); + layout.doLayout(icuText.getBuffer(), icuText.length()); + layout.dump(); + Bitmap bitmap(200, 50); + layout.draw(&bitmap, 10, 40); + std::ofstream o; + o.open("/data/local/tmp/foo.pgm", std::ios::out | std::ios::binary); + bitmap.writePnm(o); + return 0; +} + +} + +int main(int argc, const char** argv) { + return android::runMinikinTest(); +} \ No newline at end of file From 8d9541c5fb3c7d3a8d960faf9d99aa5cde41ea72 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 22 May 2013 16:14:27 -0700 Subject: [PATCH 003/364] Introduce MinikinFont abstraction This commit removes the direct dependency on FreeType and replaces it with a MinikinFont abstraction, which is designed to support both FreeType and Skia fonts (and possibly others in the future). Also adds a "total advance" to the Layout, with an API for retrieving it. Change-Id: If20f92db9a43fd15b0fe9794b761ba00fb21338c --- .../flutter/include/minikin/FontCollection.h | 19 ++-- .../src/flutter/include/minikin/FontFamily.h | 12 +-- engine/src/flutter/include/minikin/Layout.h | 13 +-- .../src/flutter/include/minikin/MinikinFont.h | 70 ++++++++++++ .../include/minikin/MinikinFontFreeType.h | 71 +++++++++++++ engine/src/flutter/libs/minikin/Android.mk | 1 + .../flutter/libs/minikin/FontCollection.cpp | 13 ++- .../src/flutter/libs/minikin/FontFamily.cpp | 24 ++--- engine/src/flutter/libs/minikin/Layout.cpp | 100 +++++++++++------- .../libs/minikin/MinikinFontFreeType.cpp | 95 +++++++++++++++++ engine/src/flutter/sample/example.cpp | 15 +-- 11 files changed, 343 insertions(+), 90 deletions(-) create mode 100644 engine/src/flutter/include/minikin/MinikinFont.h create mode 100644 engine/src/flutter/include/minikin/MinikinFontFreeType.h create mode 100644 engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 3aa2acace2..a2a5391fc7 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -19,12 +19,9 @@ #include -#include -#include FT_FREETYPE_H -#include FT_TRUETYPE_TABLES_H - -#include "SparseBitSet.h" -#include "FontFamily.h" +#include +#include +#include namespace android { @@ -40,19 +37,19 @@ public: // Do copy constructor, assignment, destructor so it can be used in vectors Run() : font(NULL) { } Run(const Run& other): font(other.font), start(other.start), end(other.end) { - if (font) FT_Reference_Face(font); + if (font) font->Ref(); } Run& operator=(const Run& other) { - if (other.font) FT_Reference_Face(other.font); - if (font) FT_Done_Face(font); + if (other.font) other.font->Ref(); + if (font) font->Unref(); font = other.font; start = other.start; end = other.end; return *this; } - ~Run() { if (font) FT_Done_Face(font); } + ~Run() { if (font) font->Unref(); } - FT_Face font; + MinikinFont* font; int start; int end; }; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 01ea232252..290220bbad 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -42,21 +42,21 @@ private: class FontFamily { public: // Add font to family, extracting style information from the font - bool addFont(FT_Face typeface); + bool addFont(MinikinFont* typeface); - void addFont(FT_Face typeface, FontStyle style); - FT_Face getClosestMatch(FontStyle style) const; + void addFont(MinikinFont* typeface, FontStyle style); + MinikinFont* getClosestMatch(FontStyle style) const; // API's for enumerating the fonts in a family. These don't guarantee any particular order size_t getNumFonts() const; - FT_Face getFont(size_t index) const; + MinikinFont* getFont(size_t index) const; FontStyle getStyle(size_t index) const; private: class Font { public: - Font(FT_Face typeface, FontStyle style) : + Font(MinikinFont* typeface, FontStyle style) : typeface(typeface), style(style) { } - FT_Face typeface; + MinikinFont* typeface; FontStyle style; }; std::vector mFonts; diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 7a6c6cfc25..fd0ed7545c 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -17,15 +17,13 @@ #ifndef MINIKIN_LAYOUT_H #define MINIKIN_LAYOUT_H -#include -#include FT_FREETYPE_H - #include #include #include #include +#include namespace android { @@ -37,7 +35,7 @@ public: Bitmap(int width, int height); ~Bitmap(); void writePnm(std::ofstream& o) const; - void drawGlyph(const FT_Bitmap& bitmap, int x, int y); + void drawGlyph(const GlyphBitmap& bitmap, int x, int y); private: int width; int height; @@ -65,12 +63,14 @@ public: void draw(Bitmap*, int x0, int y0) const; void setProperties(const std::string css); + float getAdvance() const; + // This must be called before any invocations. // TODO: probably have a factory instead static void init(); private: // Find a face in the mFaces vector, or create a new entry - int findFace(FT_Face face); + int findFace(MinikinFont* face, MinikinPaint* paint); CssProperties mProps; // TODO: want spans std::vector mGlyphs; @@ -80,8 +80,9 @@ private: // But for the time being, it should be ok to have just one // per layout. const FontCollection *mCollection; - std::vector mFaces; + std::vector mFaces; std::vector mHbFonts; + float mAdvance; }; } // namespace android diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h new file mode 100644 index 0000000000..2c265c3bb3 --- /dev/null +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINIKIN_FONT_H +#define MINIKIN_FONT_H + +// An abstraction for platform fonts, allowing Minikin to be used with +// multiple actual implementations of fonts. + +namespace android { + +class MinikinFont; + +// Possibly move into own .h file? +struct MinikinPaint { + MinikinFont *font; + float size; + // todo: skew, stretch, hinting +}; + +class MinikinFontFreeType; + +class MinikinFont { +public: + void Ref() { mRefcount_++; } + void Unref() { if (--mRefcount_ == 0) { delete this; } } + + //MinikinFont(); + virtual ~MinikinFont() = 0; + + virtual bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const = 0; + + virtual float GetHorizontalAdvance(uint32_t glyph_id, + const MinikinPaint &paint) const = 0; + + // If buf is NULL, just update size + virtual bool GetTable(uint32_t tag, uint8_t *buf, size_t *size) = 0; + + virtual int32_t GetUniqueId() const = 0; + + 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; + } + + // This is used to implement a downcast without RTTI + virtual MinikinFontFreeType* GetFreeType() { + return NULL; + } + +private: + int mRefcount_; +}; + +} // namespace android + +#endif // MINIKIN_FONT_H diff --git a/engine/src/flutter/include/minikin/MinikinFontFreeType.h b/engine/src/flutter/include/minikin/MinikinFontFreeType.h new file mode 100644 index 0000000000..70518319ac --- /dev/null +++ b/engine/src/flutter/include/minikin/MinikinFontFreeType.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINIKIN_FONT_FREETYPE_H +#define MINIKIN_FONT_FREETYPE_H + +#include +#include FT_FREETYPE_H +#include FT_TRUETYPE_TABLES_H + +#include + +// An abstraction for platform fonts, allowing Minikin to be used with +// multiple actual implementations of fonts. + +namespace android { + +struct GlyphBitmap { + uint8_t *buffer; + int width; + int height; + int left; + int top; +}; + +class MinikinFontFreeType : public MinikinFont { +public: + explicit MinikinFontFreeType(FT_Face typeface); + + ~MinikinFontFreeType(); + + bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const; + + float GetHorizontalAdvance(uint32_t glyph_id, + const MinikinPaint &paint) const; + + // If buf is NULL, just update size + bool GetTable(uint32_t tag, uint8_t *buf, size_t *size); + + int32_t GetUniqueId() const; + + // Not a virtual method, as the protocol to access rendered + // glyph bitmaps is probably different depending on the + // backend. + bool Render(uint32_t glyph_id, + const MinikinPaint &paint, GlyphBitmap *result); + + MinikinFontFreeType* GetFreeType(); + +private: + FT_Face mTypeface; + int32_t mUniqueId; + static int32_t sIdCounter; +}; + +} // namespace android + +#endif // MINIKIN_FONT_FREETYPE_H diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 9795ad05d0..723ad1ff9e 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -24,6 +24,7 @@ LOCAL_SRC_FILES := \ FontCollection.cpp \ FontFamily.cpp \ Layout.cpp \ + MinikinFontFreeType.cpp \ SparseBitSet.cpp LOCAL_MODULE := libminikin diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 7abbd3b302..702bd2097f 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -45,16 +45,15 @@ FontCollection::FontCollection(const vector& typefaces) : FontInstance* instance = &mInstances.back(); instance->mFamily = family; instance->mCoverage = new SparseBitSet; - FT_Face typeface = family->getClosestMatch(defaultStyle); + MinikinFont* typeface = family->getClosestMatch(defaultStyle); #ifdef VERBOSE_DEBUG printf("closest match = %x, family size = %d\n", typeface, family->getNumFonts()); #endif - const uint32_t cmapTag = FT_MAKE_TAG('c', 'm', 'a', 'p'); - FT_ULong cmapSize = 0; - FT_Error error = FT_Load_Sfnt_Table(typeface, cmapTag, 0, NULL, &cmapSize); + const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); + size_t cmapSize = 0; + bool ok = typeface->GetTable(cmapTag, NULL, &cmapSize); UniquePtr cmapData(new uint8_t[cmapSize]); - error = FT_Load_Sfnt_Table(typeface, cmapTag, 0, - cmapData.get(), &cmapSize); + ok = typeface->GetTable(cmapTag, cmapData.get(), &cmapSize); CmapCoverage::getCoverage(*instance->mCoverage, cmapData.get(), cmapSize); #ifdef VERBOSE_DEBUG printf("font coverage length=%d, first ch=%x\n", instance->mCoverage->length(), @@ -138,7 +137,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty run->font = NULL; // maybe we should do something different here } else { run->font = family->getClosestMatch(style); - FT_Reference_Face(run->font); + run->font->Ref(); } lastFamily = family; run->start = i; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index dc6e16ce83..0bc38a7736 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -20,9 +20,7 @@ #include #include #include -#include -#include FT_FREETYPE_H -#include FT_TRUETYPE_TABLES_H +#include #include #include @@ -30,14 +28,14 @@ using std::vector; namespace android { -bool FontFamily::addFont(FT_Face typeface) { - const uint32_t os2Tag = FT_MAKE_TAG('O', 'S', '/', '2'); - FT_ULong os2Size = 0; - FT_Error error = FT_Load_Sfnt_Table(typeface, os2Tag, 0, NULL, &os2Size); - if (error != 0) return false; +bool FontFamily::addFont(MinikinFont* typeface) { + const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); + size_t os2Size = 0; + bool ok = typeface->GetTable(os2Tag, NULL, &os2Size); + if (!ok) return false; UniquePtr os2Data(new uint8_t[os2Size]); - error = FT_Load_Sfnt_Table(typeface, os2Tag, 0, os2Data.get(), &os2Size); - if (error != 0) return false; + ok = typeface->GetTable(os2Tag, os2Data.get(), &os2Size); + if (!ok) return false; int weight; bool italic; if (analyzeStyle(os2Data.get(), os2Size, &weight, &italic)) { @@ -51,7 +49,7 @@ bool FontFamily::addFont(FT_Face typeface) { return false; } -void FontFamily::addFont(FT_Face typeface, FontStyle style) { +void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { mFonts.push_back(Font(typeface, style)); ALOGD("added font, mFonts.size() = %d", mFonts.size()); } @@ -66,7 +64,7 @@ int computeMatch(FontStyle style1, FontStyle style2) { return score; } -FT_Face FontFamily::getClosestMatch(FontStyle style) const { +MinikinFont* FontFamily::getClosestMatch(FontStyle style) const { const Font* bestFont = NULL; int bestMatch = 0; for (size_t i = 0; i < mFonts.size(); i++) { @@ -84,7 +82,7 @@ size_t FontFamily::getNumFonts() const { return mFonts.size(); } -FT_Face FontFamily::getFont(size_t index) const { +MinikinFont* FontFamily::getFont(size_t index) const { return mFonts[index].typeface; } diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index a8a596d729..d4e09c5dfe 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -18,7 +18,9 @@ #include #include #include // for debugging +#include // ditto +#include #include using std::string; @@ -45,9 +47,11 @@ void Bitmap::writePnm(std::ofstream &o) const { o.close(); } -void Bitmap::drawGlyph(const FT_Bitmap& bitmap, int x, int y) { +void Bitmap::drawGlyph(const GlyphBitmap& bitmap, int x, int y) { int bmw = bitmap.width; - int bmh = bitmap.rows; + int bmh = bitmap.height; + x += bitmap.left; + y -= bitmap.top; int x0 = std::max(0, x); int x1 = std::min(width, x + bmw); int y0 = std::max(0, y); @@ -74,19 +78,20 @@ void Layout::setFontCollection(const FontCollection *collection) { } hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { - FT_Face ftFace = reinterpret_cast(userData); - FT_ULong length = 0; - FT_Error error = FT_Load_Sfnt_Table(ftFace, tag, 0, NULL, &length); - if (error) { + MinikinFont* font = reinterpret_cast(userData); + size_t length = 0; + bool ok = font->GetTable(tag, NULL, &length); + if (!ok) { return 0; } char *buffer = reinterpret_cast(malloc(length)); if (!buffer) { return 0; } - error = FT_Load_Sfnt_Table(ftFace, tag, 0, - reinterpret_cast(buffer), &length); - if (error) { + ok = font->GetTable(tag, reinterpret_cast(buffer), &length); + printf("referenceTable %c%c%c%c length=%d %d\n", + (tag >>24) & 0xff, (tag>>16)&0xff, (tag>>8)&0xff, tag&0xff, length, ok); + if (!ok) { free(buffer); return 0; } @@ -96,23 +101,22 @@ hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { static hb_bool_t harfbuzzGetGlyph(hb_font_t* hbFont, void* fontData, hb_codepoint_t unicode, hb_codepoint_t variationSelector, hb_codepoint_t* glyph, void* userData) { - FT_Face ftFace = reinterpret_cast(fontData); - FT_UInt glyph_index = FT_Get_Char_Index(ftFace, unicode); - *glyph = glyph_index; - return !!*glyph; -} - -static hb_position_t ft_pos_to_hb(FT_Pos pos) { - return pos << 2; + MinikinPaint* paint = reinterpret_cast(fontData); + MinikinFont* font = paint->font; + uint32_t glyph_id; + bool ok = font->GetGlyph(unicode, &glyph_id); + if (ok) { + *glyph = glyph_id; + } + return ok; } static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, void* userData) { - FT_Face ftFace = reinterpret_cast(fontData); - hb_position_t advance = 0; - - FT_Load_Glyph(ftFace, glyph, FT_LOAD_DEFAULT); - return ft_pos_to_hb(ftFace->glyph->advance.x); + MinikinPaint* paint = reinterpret_cast(fontData); + MinikinFont* font = paint->font; + float advance = font->GetHorizontalAdvance(glyph, *paint); + return 256 * advance + 0.5; } static hb_bool_t harfbuzzGetGlyphHorizontalOrigin(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, hb_position_t* x, hb_position_t* y, void* userData) @@ -135,10 +139,10 @@ hb_font_funcs_t* getHbFontFuncs() { return hbFontFuncs; } -hb_font_t* create_hb_font(FT_Face ftFace) { - hb_face_t* face = hb_face_create_for_tables(referenceTable, ftFace, NULL); +hb_font_t* create_hb_font(MinikinFont* minikinFont, MinikinPaint* minikinPaint) { + hb_face_t* face = hb_face_create_for_tables(referenceTable, minikinFont, NULL); hb_font_t* font = hb_font_create(face); - hb_font_set_funcs(font, getHbFontFuncs(), ftFace, 0); + hb_font_set_funcs(font, getHbFontFuncs(), minikinPaint, 0); // TODO: manage ownership of face return font; } @@ -164,19 +168,15 @@ void Layout::dump() const { // 1. Deal with multiple sizes in a layout // 2. We'll probably store FT_Face as primary and then use a cache // for the hb fonts -int Layout::findFace(FT_Face face) { +int Layout::findFace(MinikinFont* face, MinikinPaint* paint) { unsigned int ix; for (ix = 0; ix < mFaces.size(); ix++) { if (mFaces[ix] == face) { return ix; } } - double size = mProps.value(fontSize).getFloatValue(); - FT_Error error = FT_Set_Pixel_Sizes(face, 0, size); mFaces.push_back(face); - hb_font_t *font = create_hb_font(face); - hb_font_set_ppem(font, size, size); - hb_font_set_scale(font, HBFloatToFixed(size), HBFloatToFixed(size)); + hb_font_t *font = create_hb_font(face, paint); mHbFonts.push_back(font); return ix; } @@ -190,7 +190,6 @@ static FontStyle styleFromCss(const CssProperties &props) { if (props.hasTag(fontStyle)) { italic = props.value(fontStyle).getIntValue() != 0; } - // TODO: italic property from CSS return FontStyle(weight, italic); } @@ -202,6 +201,10 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { FontStyle style = styleFromCss(mProps); mCollection->itemize(buf, nchars, style, &items); + MinikinPaint paint; + double size = mProps.value(fontSize).getFloatValue(); + paint.size = size; + mGlyphs.clear(); mFaces.clear(); mHbFonts.clear(); @@ -209,12 +212,15 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { float y = 0; for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { FontCollection::Run &run = items[run_ix]; - int font_ix = findFace(run.font); + int font_ix = findFace(run.font, &paint); + paint.font = mFaces[font_ix]; hb_font_t *hbFont = mHbFonts[font_ix]; #ifdef VERBOSE std::cout << "Run " << run_ix << ", font " << font_ix << " [" << run.start << ":" << run.end << "]" << std::endl; #endif + hb_font_set_ppem(hbFont, size, size); + hb_font_set_scale(hbFont, HBFloatToFixed(size), HBFloatToFixed(size)); hb_buffer_reset(buffer); hb_buffer_set_direction(buffer, HB_DIRECTION_LTR); @@ -236,24 +242,32 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { x += HBFixedToFloat(positions[i].x_advance); } } + mAdvance = x; } void Layout::draw(Bitmap* surface, int x0, int y0) const { - FT_Error error; - FT_Int32 load_flags = FT_LOAD_DEFAULT; + /* + TODO: redo as MinikinPaint settings if (mProps.hasTag(minikinHinting)) { int hintflags = mProps.value(minikinHinting).getIntValue(); if (hintflags & 1) load_flags |= FT_LOAD_NO_HINTING; if (hintflags & 2) load_flags |= FT_LOAD_NO_AUTOHINT; } + */ for (size_t i = 0; i < mGlyphs.size(); i++) { const LayoutGlyph& glyph = mGlyphs[i]; - FT_Face face = mFaces[glyph.font_ix]; - error = FT_Load_Glyph(face, glyph.glyph_id, load_flags); - error = FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL); - surface->drawGlyph(face->glyph->bitmap, - x0 + int(floor(glyph.x + 0.5)) + face->glyph->bitmap_left, - y0 + int(floor(glyph.y + 0.5)) - face->glyph->bitmap_top); + MinikinFont *mf = mFaces[glyph.font_ix]; + MinikinFontFreeType *face = static_cast(mf); + GlyphBitmap glyphBitmap; + MinikinPaint paint; + paint.size = mProps.value(fontSize).getFloatValue(); + bool ok = face->Render(glyph.glyph_id, paint, &glyphBitmap); + printf("glyphBitmap.width=%d, glyphBitmap.height=%d (%d, %d) x=%f, y=%f, ok=%d\n", + glyphBitmap.width, glyphBitmap.height, glyphBitmap.left, glyphBitmap.top, glyph.x, glyph.y, ok); + if (ok) { + surface->drawGlyph(glyphBitmap, + x0 + int(floor(glyph.x + 0.5)), y0 + int(floor(glyph.y + 0.5))); + } } } @@ -261,4 +275,8 @@ void Layout::setProperties(string css) { mProps.parse(css); } +float Layout::getAdvance() const { + return mAdvance; +} + } // namespace android diff --git a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp new file mode 100644 index 0000000000..be61345a9c --- /dev/null +++ b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Implementation of MinikinFont abstraction specialized for FreeType + +#include + +#include +#include FT_FREETYPE_H +#include FT_TRUETYPE_TABLES_H +#include FT_ADVANCES_H + +#include + +namespace android { + +int32_t MinikinFontFreeType::sIdCounter = 0; + +MinikinFontFreeType::MinikinFontFreeType(FT_Face typeface) : + mTypeface(typeface) { + mUniqueId = sIdCounter++; +} + +MinikinFontFreeType::~MinikinFontFreeType() { + FT_Done_Face(mTypeface); +} + +bool MinikinFontFreeType::GetGlyph(uint32_t codepoint, uint32_t *glyph) const { + FT_UInt glyph_index = FT_Get_Char_Index(mTypeface, codepoint); + *glyph = glyph_index; + return !!glyph_index; +} + +float MinikinFontFreeType::GetHorizontalAdvance(uint32_t glyph_id, + const MinikinPaint &paint) const { + FT_Set_Pixel_Sizes(mTypeface, 0, paint.size); + FT_UInt32 flags = FT_LOAD_DEFAULT; // TODO: respect hinting settings + FT_Fixed advance; + FT_Error error = FT_Get_Advance(mTypeface, glyph_id, flags, &advance); + return advance * (1.0 / 65536); +} + +bool MinikinFontFreeType::GetTable(uint32_t tag, uint8_t *buf, size_t *size) { + FT_ULong ftsize = *size; + FT_Error error = FT_Load_Sfnt_Table(mTypeface, tag, 0, buf, &ftsize); + if (error != 0) { + return false; + } + *size = ftsize; + return true; +} + +int32_t MinikinFontFreeType::GetUniqueId() const { + return mUniqueId; +} + +bool MinikinFontFreeType::Render(uint32_t glyph_id, + const MinikinPaint &paint, GlyphBitmap *result) { + FT_Error error; + FT_Int32 load_flags = FT_LOAD_DEFAULT; // TODO: respect hinting settings + error = FT_Load_Glyph(mTypeface, glyph_id, load_flags); + if (error != 0) { + return false; + } + error = FT_Render_Glyph(mTypeface->glyph, FT_RENDER_MODE_NORMAL); + if (error != 0) { + return false; + } + FT_Bitmap &bitmap = mTypeface->glyph->bitmap; + result->buffer = bitmap.buffer; + result->width = bitmap.width; + result->height = bitmap.rows; + result->left = mTypeface->glyph->bitmap_left; + result->top = mTypeface->glyph->bitmap_top; + return true; +} + +MinikinFontFreeType* MinikinFontFreeType::GetFreeType() { + return this; +} + +} // namespace android diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index 3f0ad9d9a7..9b012ef086 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -24,6 +24,7 @@ #include #include +#include #include using std::vector; @@ -55,15 +56,17 @@ FontCollection *makeFontCollection() { if (error != 0) { printf("error loading %s, %d\n", fn, error); } - family->addFont(face); + MinikinFont *font = new MinikinFontFreeType(face); + family->addFont(font); } typefaces.push_back(family); -#if 0 +#if 1 family = new FontFamily(); const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; error = FT_New_Face(library, fn, 0, &face); - family->addFont(face); + MinikinFont *font = new MinikinFontFreeType(face); + family->addFont(font); typefaces.push_back(family); #endif @@ -81,11 +84,11 @@ int runMinikinTest() { Layout layout; layout.setFontCollection(collection); layout.setProperties("font-size: 32;"); - const char *text = "hello world"; + const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87"; icu::UnicodeString icuText = icu::UnicodeString::fromUTF8(text); layout.doLayout(icuText.getBuffer(), icuText.length()); layout.dump(); - Bitmap bitmap(200, 50); + Bitmap bitmap(250, 50); layout.draw(&bitmap, 10, 40); std::ofstream o; o.open("/data/local/tmp/foo.pgm", std::ios::out | std::ios::binary); @@ -97,4 +100,4 @@ int runMinikinTest() { int main(int argc, const char** argv) { return android::runMinikinTest(); -} \ No newline at end of file +} From c905bdf4be0f0a1e19af584fdbac20042c074e5d Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Fri, 14 Jun 2013 14:12:07 -0700 Subject: [PATCH 004/364] Fix build breakage The MinikinFont class was missing a destructor. The build error was not caught because incremental builds didn't see fit to relink after I deleted one of the source files (that contained the impl of this destructor). Change-Id: Ic72d56fe28316cd2b2f808910e34ca6f177a1220 --- engine/src/flutter/include/minikin/MinikinFont.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 2c265c3bb3..c08e4fe22d 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -38,8 +38,7 @@ public: void Ref() { mRefcount_++; } void Unref() { if (--mRefcount_ == 0) { delete this; } } - //MinikinFont(); - virtual ~MinikinFont() = 0; + virtual ~MinikinFont() { }; virtual bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const = 0; From 79497ccc90b2eee0d8bacf4f82fc0d691f87f4bf Mon Sep 17 00:00:00 2001 From: Victoria Lease Date: Thu, 27 Jun 2013 15:43:55 -0700 Subject: [PATCH 005/364] Use shared ft2 lib, deal with libpng/zlib deps Bug: 9603326 Change-Id: I7df1f68fa3a44b37b1b279387f4ddfe942928bb0 --- engine/src/flutter/libs/minikin/Android.mk | 6 +++--- engine/src/flutter/sample/Android.mk | 7 +++++-- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 723ad1ff9e..baac98c39d 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -36,9 +36,9 @@ LOCAL_C_INCLUDES += \ LOCAL_SHARED_LIBRARIES := \ libharfbuzz_ng \ + libft2 \ + libpng \ + libz \ libstlport -LOCAL_STATIC_LIBARIES := \ - libft2 - include $(BUILD_STATIC_LIBRARY) diff --git a/engine/src/flutter/sample/Android.mk b/engine/src/flutter/sample/Android.mk index 335e7ce787..939aca49f3 100644 --- a/engine/src/flutter/sample/Android.mk +++ b/engine/src/flutter/sample/Android.mk @@ -33,9 +33,12 @@ LOCAL_SHARED_LIBRARIES += \ libcutils \ libstlport \ libharfbuzz_ng \ - libicuuc + libicuuc \ + libft2 \ + libpng \ + libz -LOCAL_STATIC_LIBRARIES += libminikin libft2 +LOCAL_STATIC_LIBRARIES += libminikin LOCAL_MODULE:= minikin_example From 0ab6d024ffdc90c10f16331e8e553a533140d713 Mon Sep 17 00:00:00 2001 From: Kenny Root Date: Wed, 11 Sep 2013 15:02:30 -0700 Subject: [PATCH 006/364] Use canonical UniquePtr.h header Change-Id: Id50e9d6fe2f08d3121b168b45791a8e8fb045d7f --- engine/src/flutter/libs/minikin/FontFamily.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 0bc38a7736..558fd77c16 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -19,10 +19,10 @@ #include #include #include -#include #include #include #include +#include using std::vector; From 014dae7e78c849444274b75a50afa242534f3291 Mon Sep 17 00:00:00 2001 From: Kenny Root Date: Wed, 11 Sep 2013 23:24:24 -0700 Subject: [PATCH 007/364] Use canonical UniquePtr.h file Change-Id: I00953971034a7d00ca165accdab528d2b8ff27a7 --- engine/src/flutter/include/minikin/SparseBitSet.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/include/minikin/SparseBitSet.h b/engine/src/flutter/include/minikin/SparseBitSet.h index 4004606f1d..72b83057c6 100644 --- a/engine/src/flutter/include/minikin/SparseBitSet.h +++ b/engine/src/flutter/include/minikin/SparseBitSet.h @@ -19,7 +19,7 @@ #include #include -#include "utils/UniquePtr.h" +#include // --------------------------------------------------------------------------- From eee04fd1e59376f0383c5accf217cfe0b3d3653d Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 15 Jul 2013 14:19:59 -0700 Subject: [PATCH 008/364] A basket of features: itemization, bounds, refcount This patch improves script run itemization and also exposes metrics and bounds for layouts. In addition, there is a fair amount of internal cleanup, including ref counting, and making the MinikinFont abstraction strong enough to support both FreeType and Skia implementations. There is also a sample implementation using Skia, in the sample directory. As part of its functionality, his patch measures the bounds of the layout and gives access through Layout::GetBounds(). The corresponding method is not implemented in the FreeType-only implementation of MinikinFont, so that will probably have to be fixed. Change-Id: Ib1a3fe9d7c90519ac651fb4aa957848e4bb758ec --- engine/src/flutter/include/minikin/Layout.h | 26 ++- .../src/flutter/include/minikin/MinikinFont.h | 28 +++ engine/src/flutter/libs/minikin/Android.mk | 4 +- .../flutter/libs/minikin/FontCollection.cpp | 19 +- .../src/flutter/libs/minikin/FontFamily.cpp | 1 - engine/src/flutter/libs/minikin/Layout.cpp | 180 ++++++++++++++++-- engine/src/flutter/sample/Android.mk | 36 +++- engine/src/flutter/sample/MinikinSkia.cpp | 64 +++++++ engine/src/flutter/sample/MinikinSkia.h | 26 +++ engine/src/flutter/sample/example_skia.cpp | 152 +++++++++++++++ 10 files changed, 499 insertions(+), 37 deletions(-) create mode 100644 engine/src/flutter/sample/MinikinSkia.cpp create mode 100644 engine/src/flutter/sample/MinikinSkia.h create mode 100644 engine/src/flutter/sample/example_skia.cpp diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index fd0ed7545c..896478b219 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -57,32 +57,50 @@ struct LayoutGlyph { class Layout { public: + void dump() const; - void setFontCollection(const FontCollection *collection); + void setFontCollection(const FontCollection* collection); void doLayout(const uint16_t* buf, size_t nchars); void draw(Bitmap*, int x0, int y0) const; void setProperties(const std::string css); - float getAdvance() const; - // This must be called before any invocations. // TODO: probably have a factory instead static void init(); + + // public accessors + size_t nGlyphs() const; + // Does not bump reference; ownership is still layout + MinikinFont *getFont(int i) const; + unsigned int getGlyphId(int i) const; + float getX(int i) const; + float getY(int i) const; + + float getAdvance() const; + + // Get advances, copying into caller-provided buffer. The size of this + // buffer must match the length of the string (nchars arg to doLayout). + void getAdvances(float* advances); + + void getBounds(MinikinRect* rect); + private: // Find a face in the mFaces vector, or create a new entry int findFace(MinikinFont* face, MinikinPaint* paint); CssProperties mProps; // TODO: want spans std::vector mGlyphs; + std::vector mAdvances; // In future, this will be some kind of mapping from the // identifier used to represent font-family to a font collection. // But for the time being, it should be ok to have just one // per layout. - const FontCollection *mCollection; + const FontCollection* mCollection; std::vector mFaces; std::vector mHbFonts; float mAdvance; + MinikinRect mBounds; }; } // namespace android diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index c08e4fe22d..e84f5df63f 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -31,6 +31,29 @@ struct MinikinPaint { // todo: skew, stretch, hinting }; +struct MinikinRect { + float mLeft, mTop, mRight, mBottom; + bool isEmpty() const { + return mLeft == mRight || mTop == mBottom; + } + void set(const MinikinRect& r) { + mLeft = r.mLeft; + mTop = r.mTop; + mRight = r.mRight; + mBottom = r.mBottom; + } + void offset(float dx, float dy) { + mLeft += dx; + mTop += dy; + mRight += dx; + mBottom += dy; + } + void setEmpty() { + mLeft = mTop = mRight = mBottom = 0; + } + void join(const MinikinRect& r); +}; + class MinikinFontFreeType; class MinikinFont { @@ -38,6 +61,8 @@ public: void Ref() { mRefcount_++; } void Unref() { if (--mRefcount_ == 0) { delete this; } } + MinikinFont() : mRefcount_(1) { } + virtual ~MinikinFont() { }; virtual bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const = 0; @@ -45,6 +70,9 @@ public: virtual float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const = 0; + virtual void GetBounds(MinikinRect* bounds, uint32_t glyph_id, + const MinikinPaint &paint) const = 0; + // If buf is NULL, just update size virtual bool GetTable(uint32_t tag, uint8_t *buf, size_t *size) = 0; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index baac98c39d..5e134954a0 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -32,13 +32,15 @@ LOCAL_MODULE := libminikin LOCAL_C_INCLUDES += \ external/harfbuzz_ng/src \ external/freetype/include \ + external/icu4c/common \ frameworks/minikin/include LOCAL_SHARED_LIBRARIES := \ libharfbuzz_ng \ libft2 \ + liblog \ libpng \ libz \ libstlport -include $(BUILD_STATIC_LIBRARY) +include $(BUILD_SHARED_LIBRARY) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 702bd2097f..aa37825da6 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -14,9 +14,10 @@ * limitations under the License. */ -#ifdef VERBOSE_DEBUG -#include // for debugging - remove -#endif +// #define VERBOSE_DEBUG + +#define LOG_TAG "Minikin" +#include #include #include @@ -35,7 +36,7 @@ FontCollection::FontCollection(const vector& typefaces) : vector lastChar; size_t nTypefaces = typefaces.size(); #ifdef VERBOSE_DEBUG - printf("nTypefaces = %d\n", nTypefaces); + ALOGD("nTypefaces = %d\n", nTypefaces); #endif const FontStyle defaultStyle; for (size_t i = 0; i < nTypefaces; i++) { @@ -47,7 +48,7 @@ FontCollection::FontCollection(const vector& typefaces) : instance->mCoverage = new SparseBitSet; MinikinFont* typeface = family->getClosestMatch(defaultStyle); #ifdef VERBOSE_DEBUG - printf("closest match = %x, family size = %d\n", typeface, family->getNumFonts()); + ALOGD("closest match = %p, family size = %d\n", typeface, family->getNumFonts()); #endif const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); size_t cmapSize = 0; @@ -56,7 +57,7 @@ FontCollection::FontCollection(const vector& typefaces) : ok = typeface->GetTable(cmapTag, cmapData.get(), &cmapSize); CmapCoverage::getCoverage(*instance->mCoverage, cmapData.get(), cmapSize); #ifdef VERBOSE_DEBUG - printf("font coverage length=%d, first ch=%x\n", instance->mCoverage->length(), + ALOGD("font coverage length=%d, first ch=%x\n", instance->mCoverage->length(), instance->mCoverage->nextSetBit(0)); #endif mMaxChar = max(mMaxChar, instance->mCoverage->length()); @@ -70,7 +71,7 @@ FontCollection::FontCollection(const vector& typefaces) : mRanges.push_back(dummy); Range* range = &mRanges.back(); #ifdef VERBOSE_DEBUG - printf("i=%d: range start = %d\n", i, offset); + ALOGD("i=%d: range start = %d\n", i, offset); #endif range->start = offset; for (size_t j = 0; j < nTypefaces; j++) { @@ -80,7 +81,7 @@ FontCollection::FontCollection(const vector& typefaces) : offset++; uint32_t nextChar = instance->mCoverage->nextSetBit((i + 1) << kLogCharsPerPage); #ifdef VERBOSE_DEBUG - printf("nextChar = %d (j = %d)\n", nextChar, j); + ALOGD("nextChar = %d (j = %d)\n", nextChar, j); #endif lastChar[j] = nextChar; } @@ -102,7 +103,7 @@ const FontFamily* FontCollection::getFamilyForChar(uint32_t ch) const { } const Range& range = mRanges[ch >> kLogCharsPerPage]; #ifdef VERBOSE_DEBUG - printf("querying range %d:%d\n", range.start, range.end); + ALOGD("querying range %d:%d\n", range.start, range.end); #endif for (size_t i = range.start; i < range.end; i++) { const FontInstance* instance = mInstanceVec[i]; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 558fd77c16..16031cee38 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -51,7 +51,6 @@ bool FontFamily::addFont(MinikinFont* typeface) { void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { mFonts.push_back(Font(typeface, style)); - ALOGD("added font, mFonts.size() = %d", mFonts.size()); } // Compute a matching metric between two styles - 0 is an exact match diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index d4e09c5dfe..ffaa451813 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -14,12 +14,19 @@ * limitations under the License. */ +#define LOG_TAG "Minikin" +#include + #include #include #include #include // for debugging #include // ditto +#include + +#include + #include #include @@ -31,6 +38,8 @@ namespace android { // TODO: globals are not cool, move to a factory-ish object hb_buffer_t* buffer = 0; +Mutex gLock; + Bitmap::Bitmap(int width, int height) : width(width), height(height) { buf = new uint8_t[width * height](); } @@ -69,11 +78,23 @@ void Bitmap::drawGlyph(const GlyphBitmap& bitmap, int x, int y) { } } +void MinikinRect::join(const MinikinRect& r) { + if (isEmpty()) { + set(r); + } else if (!r.isEmpty()) { + mLeft = std::min(mLeft, r.mLeft); + mTop = std::min(mTop, r.mTop); + mRight = std::max(mRight, r.mRight); + mBottom = std::max(mBottom, r.mBottom); + } +} + +// TODO: the actual initialization is deferred, maybe make this explicit void Layout::init() { - buffer = hb_buffer_create(); } void Layout::setFontCollection(const FontCollection *collection) { + ALOGD("setFontCollection(%p)", collection); mCollection = collection; } @@ -193,8 +214,76 @@ static FontStyle styleFromCss(const CssProperties &props) { return FontStyle(weight, italic); } +static hb_script_t codePointToScript(hb_codepoint_t codepoint) { + static hb_unicode_funcs_t *u = 0; + if (!u) { + u = hb_icu_get_unicode_funcs(); + } + return hb_unicode_script(u, codepoint); +} + +static hb_codepoint_t decodeUtf16(const uint16_t *chars, size_t len, ssize_t *iter) { + const uint16_t v = chars[(*iter)++]; + // test whether v in (0xd800..0xdfff), lead or trail surrogate + if ((v & 0xf800) == 0xd800) { + // test whether v in (0xd800..0xdbff), lead surrogate + if (size_t(*iter) < len && (v & 0xfc00) == 0xd800) { + const uint16_t v2 = chars[(*iter)++]; + // test whether v2 in (0xdc00..0xdfff), trail surrogate + if ((v2 & 0xfc00) == 0xdc00) { + // (0xd800 0xdc00) in utf-16 maps to 0x10000 in ucs-32 + const hb_codepoint_t delta = (0xd800 << 10) + 0xdc00 - 0x10000; + return (((hb_codepoint_t)v) << 10) + v2 - delta; + } + (*iter) -= 2; + return ~0u; + } else { + (*iter)--; + return ~0u; + } + } else { + return v; + } +} + +static hb_script_t getScriptRun(const uint16_t *chars, size_t len, ssize_t *iter) { + if (size_t(*iter) == len) { + return HB_SCRIPT_UNKNOWN; + } + uint32_t cp = decodeUtf16(chars, len, iter); + hb_script_t current_script = codePointToScript(cp); + for (;;) { + if (size_t(*iter) == len) + break; + const ssize_t prev_iter = *iter; + cp = decodeUtf16(chars, len, iter); + const hb_script_t script = codePointToScript(cp); + if (script != current_script) { + if (current_script == HB_SCRIPT_INHERITED || + current_script == HB_SCRIPT_COMMON) { + current_script = script; + } else if (script == HB_SCRIPT_INHERITED || + script == HB_SCRIPT_COMMON) { + continue; + } else { + *iter = prev_iter; + break; + } + } + } + if (current_script == HB_SCRIPT_INHERITED) { + current_script = HB_SCRIPT_COMMON; + } + + return current_script; +} + // TODO: API should probably take context void Layout::doLayout(const uint16_t* buf, size_t nchars) { + AutoMutex _l(gLock); + if (buffer == 0) { + buffer = hb_buffer_create(); + } FT_Error error; vector items; @@ -208,6 +297,9 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { mGlyphs.clear(); mFaces.clear(); mHbFonts.clear(); + mBounds.setEmpty(); + mAdvances.clear(); + mAdvances.resize(nchars, 0); float x = 0; float y = 0; for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { @@ -215,6 +307,10 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { int font_ix = findFace(run.font, &paint); paint.font = mFaces[font_ix]; hb_font_t *hbFont = mHbFonts[font_ix]; + if (paint.font == NULL) { + // TODO: should log what went wrong + continue; + } #ifdef VERBOSE std::cout << "Run " << run_ix << ", font " << font_ix << " [" << run.start << ":" << run.end << "]" << std::endl; @@ -222,24 +318,38 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { hb_font_set_ppem(hbFont, size, size); hb_font_set_scale(hbFont, HBFloatToFixed(size), HBFloatToFixed(size)); - hb_buffer_reset(buffer); - hb_buffer_set_direction(buffer, HB_DIRECTION_LTR); - hb_buffer_add_utf16(buffer, buf, nchars, run.start, run.end - run.start); - hb_shape(hbFont, buffer, NULL, 0); - unsigned int numGlyphs; - hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); - hb_glyph_position_t *positions = hb_buffer_get_glyph_positions(buffer, NULL); - for (unsigned int i = 0; i < numGlyphs; i++) { -#ifdef VERBOSE - std::cout << positions[i].x_advance << " " << positions[i].y_advance << " " << positions[i].x_offset << " " << positions[i].y_offset << std::endl; std::cout << "DoLayout " << info[i].codepoint << - ": " << HBFixedToFloat(positions[i].x_advance) << "; " << positions[i].x_offset << ", " << positions[i].y_offset << std::endl; -#endif - hb_codepoint_t glyph_ix = info[i].codepoint; - float xoff = HBFixedToFloat(positions[i].x_offset); - float yoff = HBFixedToFloat(positions[i].y_offset); - LayoutGlyph glyph = {font_ix, glyph_ix, x + xoff, y + yoff}; - mGlyphs.push_back(glyph); - x += HBFixedToFloat(positions[i].x_advance); + int srunend; + for (int srunstart = run.start; srunstart < run.end; srunstart = srunend) { + srunend = srunstart; + hb_script_t script = getScriptRun(buf, run.end, &srunend); + + hb_buffer_reset(buffer); + hb_buffer_set_script(buffer, script); + hb_buffer_set_direction(buffer, HB_DIRECTION_LTR); + hb_buffer_add_utf16(buffer, buf, nchars, srunstart, srunend - srunstart); + hb_shape(hbFont, buffer, NULL, 0); + unsigned int numGlyphs; + hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); + hb_glyph_position_t *positions = hb_buffer_get_glyph_positions(buffer, NULL); + for (unsigned int i = 0; i < numGlyphs; i++) { + #ifdef VERBOSE + std::cout << positions[i].x_advance << " " << positions[i].y_advance << " " << positions[i].x_offset << " " << positions[i].y_offset << std::endl; std::cout << "DoLayout " << info[i].codepoint << + ": " << HBFixedToFloat(positions[i].x_advance) << "; " << positions[i].x_offset << ", " << positions[i].y_offset << std::endl; + #endif + hb_codepoint_t glyph_ix = info[i].codepoint; + float xoff = HBFixedToFloat(positions[i].x_offset); + float yoff = HBFixedToFloat(positions[i].y_offset); + LayoutGlyph glyph = {font_ix, glyph_ix, x + xoff, y + yoff}; + mGlyphs.push_back(glyph); + float xAdvance = HBFixedToFloat(positions[i].x_advance); + MinikinRect glyphBounds; + paint.font->GetBounds(&glyphBounds, glyph_ix, paint); + glyphBounds.offset(x + xoff, y + yoff); + mBounds.join(glyphBounds); + size_t cluster = info[i].cluster; + mAdvances[cluster] += xAdvance; + x += xAdvance; + } } } mAdvance = x; @@ -275,8 +385,40 @@ void Layout::setProperties(string css) { mProps.parse(css); } +size_t Layout::nGlyphs() const { + return mGlyphs.size(); +} + +MinikinFont *Layout::getFont(int i) const { + const LayoutGlyph& glyph = mGlyphs[i]; + return mFaces[glyph.font_ix]; +} + +unsigned int Layout::getGlyphId(int i) const { + const LayoutGlyph& glyph = mGlyphs[i]; + return glyph.glyph_id; +} + +float Layout::getX(int i) const { + const LayoutGlyph& glyph = mGlyphs[i]; + return glyph.x; +} + +float Layout::getY(int i) const { + const LayoutGlyph& glyph = mGlyphs[i]; + return glyph.y; +} + float Layout::getAdvance() const { return mAdvance; } +void Layout::getAdvances(float* advances) { + memcpy(advances, &mAdvances[0], mAdvances.size() * sizeof(float)); +} + +void Layout::getBounds(MinikinRect* bounds) { + bounds->set(mBounds); +} + } // namespace android diff --git a/engine/src/flutter/sample/Android.mk b/engine/src/flutter/sample/Android.mk index 939aca49f3..a19019ad82 100644 --- a/engine/src/flutter/sample/Android.mk +++ b/engine/src/flutter/sample/Android.mk @@ -36,10 +36,40 @@ LOCAL_SHARED_LIBRARIES += \ libicuuc \ libft2 \ libpng \ - libz - -LOCAL_STATIC_LIBRARIES += libminikin + libz \ + libminikin LOCAL_MODULE:= minikin_example include $(BUILD_EXECUTABLE) + + +include $(CLEAR_VARS) +include external/stlport/libstlport.mk + +LOCAL_MODULE_TAG := tests + +LOCAL_C_INCLUDES += \ + external/harfbuzz_ng/src \ + external/freetype/include \ + external/icu4c/common \ + frameworks/minikin/include \ + external/skia/src/core + +LOCAL_SRC_FILES:= example_skia.cpp \ + MinikinSkia.cpp + +LOCAL_SHARED_LIBRARIES += \ + libutils \ + liblog \ + libcutils \ + libstlport \ + libharfbuzz_ng \ + libicuuc \ + libskia \ + libminikin \ + libft2 + +LOCAL_MODULE:= minikin_skia_example + +include $(BUILD_EXECUTABLE) diff --git a/engine/src/flutter/sample/MinikinSkia.cpp b/engine/src/flutter/sample/MinikinSkia.cpp new file mode 100644 index 0000000000..d67e59fbbc --- /dev/null +++ b/engine/src/flutter/sample/MinikinSkia.cpp @@ -0,0 +1,64 @@ +#include +#include + +#include +#include "MinikinSkia.h" + +namespace android { + +MinikinFontSkia::MinikinFontSkia(SkTypeface *typeface) : + mTypeface(typeface) { +} + +MinikinFontSkia::~MinikinFontSkia() { + SkSafeUnref(mTypeface); +} + +bool MinikinFontSkia::GetGlyph(uint32_t codepoint, uint32_t *glyph) const { + SkPaint paint; + paint.setTypeface(mTypeface); + paint.setTextEncoding(SkPaint::kUTF32_TextEncoding); + uint16_t glyph16; + paint.textToGlyphs(&codepoint, sizeof(codepoint), &glyph16); + *glyph = glyph16; + //printf("glyph for U+%04x = %d\n", codepoint, glyph16); + return !!glyph; +} + +float MinikinFontSkia::GetHorizontalAdvance(uint32_t glyph_id, + const MinikinPaint &paint) const { + SkPaint skpaint; + skpaint.setTypeface(mTypeface); + skpaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); + // TODO: set paint from Minikin + skpaint.setTextSize(100); + uint16_t glyph16 = glyph_id; + SkScalar skWidth; + SkRect skBounds; + skpaint.getTextWidths(&glyph16, sizeof(glyph16), &skWidth, &skBounds); + // bounds? + //printf("advance for glyph %d = %f\n", glyph_id, SkScalarToFP(skWidth)); + return skWidth; +} + +bool MinikinFontSkia::GetTable(uint32_t tag, uint8_t *buf, size_t *size) { + if (buf == NULL) { + const size_t tableSize = mTypeface->getTableSize(tag); + *size = tableSize; + return tableSize != 0; + } else { + const size_t actualSize = mTypeface->getTableData(tag, 0, *size, buf); + *size = actualSize; + return actualSize != 0; + } +} + +SkTypeface *MinikinFontSkia::GetSkTypeface() { + return mTypeface; +} + +int32_t MinikinFontSkia::GetUniqueId() const { + return mTypeface->uniqueID(); +} + +} diff --git a/engine/src/flutter/sample/MinikinSkia.h b/engine/src/flutter/sample/MinikinSkia.h new file mode 100644 index 0000000000..8286a4c5c6 --- /dev/null +++ b/engine/src/flutter/sample/MinikinSkia.h @@ -0,0 +1,26 @@ +namespace android { + +class MinikinFontSkia : public MinikinFont { +public: + explicit MinikinFontSkia(SkTypeface *typeface); + + ~MinikinFontSkia(); + + bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const; + + float GetHorizontalAdvance(uint32_t glyph_id, + const MinikinPaint &paint) const; + + // If buf is NULL, just update size + bool GetTable(uint32_t tag, uint8_t *buf, size_t *size); + + int32_t GetUniqueId() const; + + SkTypeface *GetSkTypeface(); + +private: + SkTypeface *mTypeface; + +}; + +} // namespace android \ No newline at end of file diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp new file mode 100644 index 0000000000..ff13b5c187 --- /dev/null +++ b/engine/src/flutter/sample/example_skia.cpp @@ -0,0 +1,152 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// This is a test program that uses Minikin to layout and draw some text. +// At the moment, it just draws a string into /data/local/tmp/foo.pgm. + +#include +#include +#include + +#include +#include + +#include +#include + +#include +#include +#include +#include +#include + +#include "MinikinSkia.h" + +using std::vector; + +namespace android { + +FT_Library library; // TODO: this should not be a global + +FontCollection *makeFontCollection() { + vectortypefaces; + const char *fns[] = { + "/system/fonts/Roboto-Regular.ttf", + "/system/fonts/Roboto-Italic.ttf", + "/system/fonts/Roboto-BoldItalic.ttf", + "/system/fonts/Roboto-Light.ttf", + "/system/fonts/Roboto-Thin.ttf", + "/system/fonts/Roboto-Bold.ttf", + "/system/fonts/Roboto-ThinItalic.ttf", + "/system/fonts/Roboto-LightItalic.ttf" + }; + + FontFamily *family = new FontFamily(); + FT_Face face; + FT_Error error; + for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { + const char *fn = fns[i]; + SkTypeface *skFace = SkTypeface::CreateFromFile(fn); + MinikinFont *font = new MinikinFontSkia(skFace); + family->addFont(font); + } + typefaces.push_back(family); + +#if 1 + family = new FontFamily(); + const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; + SkTypeface *skFace = SkTypeface::CreateFromFile(fn); + MinikinFont *font = new MinikinFontSkia(skFace); + family->addFont(font); + typefaces.push_back(family); +#endif + + return new FontCollection(typefaces); +} + +// Maybe move to MinikinSkia (esp. instead of opening GetSkTypeface publicly)? + +void drawToSkia(SkCanvas *canvas, SkPaint *paint, Layout *layout, float x, float y) { + size_t nGlyphs = layout->nGlyphs(); + uint16_t *glyphs = new uint16_t[nGlyphs]; + SkPoint *pos = new SkPoint[nGlyphs]; + SkTypeface *lastFace = NULL; + SkTypeface *skFace = NULL; + size_t start = 0; + + paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); + for (size_t i = 0; i < nGlyphs; i++) { + MinikinFontSkia *mfs = static_cast(layout->getFont(i)); + skFace = mfs->GetSkTypeface(); + glyphs[i] = layout->getGlyphId(i); + pos[i].fX = SkFloatToScalar(x + layout->getX(i)); + pos[i].fY = SkFloatToScalar(y + layout->getY(i)); + if (i > 0 && skFace != lastFace) { + paint->setTypeface(lastFace); + canvas->drawPosText(glyphs + start, (i - start) << 1, pos + start, *paint); + start = i; + } + lastFace = skFace; + } + paint->setTypeface(skFace); + canvas->drawPosText(glyphs + start, (nGlyphs - start) << 1, pos + start, *paint); + delete[] glyphs; + delete[] pos; +} + +int runMinikinTest() { + FT_Error error = FT_Init_FreeType(&library); + if (error) { + return -1; + } + Layout::init(); + + FontCollection *collection = makeFontCollection(); + Layout layout; + layout.setFontCollection(collection); + layout.setProperties("font-size: 32; font-weight: 700;"); + const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87"; + icu::UnicodeString icuText = icu::UnicodeString::fromUTF8(text); + layout.doLayout(icuText.getBuffer(), icuText.length()); + layout.dump(); + + SkAutoGraphics ag; + + SkScalar width = 800; + SkScalar height = 600; + SkBitmap bitmap; + bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height); + bitmap.allocPixels(); + SkCanvas canvas(bitmap); + SkPaint paint; + paint.setARGB(255, 0, 0, 128); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(2); + paint.setTextSize(100); + paint.setAntiAlias(true); + canvas.drawLine(10, 300, 10 + layout.getAdvance(), 300, paint); + paint.setStyle(SkPaint::kFill_Style); + drawToSkia(&canvas, &paint, &layout, 10, 300); + + SkImageEncoder::EncodeFile("/data/local/tmp/foo.png", bitmap, SkImageEncoder::kPNG_Type, 100); + return 0; +} + +} + +int main(int argc, const char** argv) { + return android::runMinikinTest(); +} From 02b919bc17dce9d91a29a1d8faeb628bc8913fa9 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 5 May 2014 16:11:17 -0700 Subject: [PATCH 009/364] Better refcounting and locking All major externally accessible objects (especially FontFamily and FontCollection) are now reference counted. In addition, there is a global lock intended to make operations thread-safe. WIP notice: in this version of the patch, not all external API entry points are protected by the lock. That should be fixed. Change-Id: I14106196e99eb101e8bf1bcb4b81359759d2086c --- .../flutter/include/minikin/FontCollection.h | 11 ++--- .../src/flutter/include/minikin/FontFamily.h | 6 ++- .../src/flutter/include/minikin/MinikinFont.h | 19 ++------- .../include/minikin/MinikinRefCounted.h | 42 +++++++++++++++++++ engine/src/flutter/libs/minikin/Android.mk | 2 + .../flutter/libs/minikin/FontCollection.cpp | 6 +-- .../src/flutter/libs/minikin/FontFamily.cpp | 7 ++++ engine/src/flutter/libs/minikin/Layout.cpp | 7 +--- .../flutter/libs/minikin/MinikinInternal.cpp | 25 +++++++++++ .../flutter/libs/minikin/MinikinInternal.h | 34 +++++++++++++++ .../libs/minikin/MinikinRefCounted.cpp | 35 ++++++++++++++++ 11 files changed, 164 insertions(+), 30 deletions(-) create mode 100644 engine/src/flutter/include/minikin/MinikinRefCounted.h create mode 100644 engine/src/flutter/libs/minikin/MinikinInternal.cpp create mode 100644 engine/src/flutter/libs/minikin/MinikinInternal.h create mode 100644 engine/src/flutter/libs/minikin/MinikinRefCounted.cpp diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index a2a5391fc7..dc48f8e0a2 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -19,13 +19,14 @@ #include +#include #include #include #include namespace android { -class FontCollection { +class FontCollection : public MinikinRefCounted { public: explicit FontCollection(const std::vector& typefaces); @@ -37,17 +38,17 @@ public: // Do copy constructor, assignment, destructor so it can be used in vectors Run() : font(NULL) { } Run(const Run& other): font(other.font), start(other.start), end(other.end) { - if (font) font->Ref(); + if (font) font->RefLocked(); } Run& operator=(const Run& other) { - if (other.font) other.font->Ref(); - if (font) font->Unref(); + if (other.font) other.font->RefLocked(); + if (font) font->UnrefLocked(); font = other.font; start = other.start; end = other.end; return *this; } - ~Run() { if (font) font->Unref(); } + ~Run() { if (font) font->UnrefLocked(); } MinikinFont* font; int start; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 290220bbad..3b59017631 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -19,6 +19,8 @@ #include +#include + namespace android { // FontStyle represents all style information needed to select an actual font @@ -39,8 +41,10 @@ private: uint32_t bits; }; -class FontFamily { +class FontFamily : public MinikinRefCounted { public: + ~FontFamily(); + // Add font to family, extracting style information from the font bool addFont(MinikinFont* typeface); diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index e84f5df63f..568f19da7f 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -17,6 +17,8 @@ #ifndef MINIKIN_FONT_H #define MINIKIN_FONT_H +#include + // An abstraction for platform fonts, allowing Minikin to be used with // multiple actual implementations of fonts. @@ -56,15 +58,8 @@ struct MinikinRect { class MinikinFontFreeType; -class MinikinFont { +class MinikinFont : public MinikinRefCounted { public: - void Ref() { mRefcount_++; } - void Unref() { if (--mRefcount_ == 0) { delete this; } } - - MinikinFont() : mRefcount_(1) { } - - virtual ~MinikinFont() { }; - virtual bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const = 0; virtual float GetHorizontalAdvance(uint32_t glyph_id, @@ -82,14 +77,6 @@ public: return ((uint32_t)c1 << 24) | ((uint32_t)c2 << 16) | ((uint32_t)c3 << 8) | (uint32_t)c4; } - - // This is used to implement a downcast without RTTI - virtual MinikinFontFreeType* GetFreeType() { - return NULL; - } - -private: - int mRefcount_; }; } // namespace android diff --git a/engine/src/flutter/include/minikin/MinikinRefCounted.h b/engine/src/flutter/include/minikin/MinikinRefCounted.h new file mode 100644 index 0000000000..74d27fec7d --- /dev/null +++ b/engine/src/flutter/include/minikin/MinikinRefCounted.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2014 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. + */ + +// Base class for reference counted objects in Minikin + +#ifndef MINIKIN_REF_COUNTED_H +#define MINIKIN_REF_COUNTED_H + +namespace android { + +class MinikinRefCounted { +public: + void RefLocked() { mRefcount_++; } + void UnrefLocked() { if (--mRefcount_ == 0) { delete this; } } + + // These refcount operations take the global lock. + void Ref(); + void Unref(); + + MinikinRefCounted() : mRefcount_(1) { } + + virtual ~MinikinRefCounted() { }; +private: + int mRefcount_; +}; + +} + +#endif // MINIKIN_REF_COUNTED_H \ No newline at end of file diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 5e134954a0..c4412859c4 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -24,6 +24,8 @@ LOCAL_SRC_FILES := \ FontCollection.cpp \ FontFamily.cpp \ Layout.cpp \ + MinikinInternal.cpp \ + MinikinRefCounted.cpp \ MinikinFontFreeType.cpp \ SparseBitSet.cpp diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index aa37825da6..18e528efb0 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -41,6 +41,7 @@ FontCollection::FontCollection(const vector& typefaces) : const FontStyle defaultStyle; for (size_t i = 0; i < nTypefaces; i++) { FontFamily* family = typefaces[i]; + family->RefLocked(); FontInstance dummy; mInstances.push_back(dummy); // emplace_back would be better FontInstance* instance = &mInstances.back(); @@ -62,7 +63,6 @@ FontCollection::FontCollection(const vector& typefaces) : #endif mMaxChar = max(mMaxChar, instance->mCoverage->length()); lastChar.push_back(instance->mCoverage->nextSetBit(0)); - // TODO: should probably ref typeface here, hmm } size_t nPages = mMaxChar >> kLogCharsPerPage; size_t offset = 0; @@ -93,7 +93,7 @@ FontCollection::FontCollection(const vector& typefaces) : FontCollection::~FontCollection() { for (size_t i = 0; i < mInstances.size(); i++) { delete mInstances[i].mCoverage; - // probably unref the typeface here too + mInstances[i].mFamily->UnrefLocked(); } } @@ -138,7 +138,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty run->font = NULL; // maybe we should do something different here } else { run->font = family->getClosestMatch(style); - run->font->Ref(); + run->font->RefLocked(); } lastFamily = family; run->start = i; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 16031cee38..d8525ffa6d 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -28,6 +28,12 @@ using std::vector; namespace android { +FontFamily::~FontFamily() { + for (size_t i = 0; i < mFonts.size(); i++) { + mFonts[i].typeface->UnrefLocked(); + } +} + bool FontFamily::addFont(MinikinFont* typeface) { const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); size_t os2Size = 0; @@ -50,6 +56,7 @@ bool FontFamily::addFont(MinikinFont* typeface) { } void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { + typeface->RefLocked(); mFonts.push_back(Font(typeface, style)); } diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index ffaa451813..20e2d9e45b 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -25,8 +25,7 @@ #include -#include - +#include "MinikinInternal.h" #include #include @@ -38,8 +37,6 @@ namespace android { // TODO: globals are not cool, move to a factory-ish object hb_buffer_t* buffer = 0; -Mutex gLock; - Bitmap::Bitmap(int width, int height) : width(width), height(height) { buf = new uint8_t[width * height](); } @@ -280,7 +277,7 @@ static hb_script_t getScriptRun(const uint16_t *chars, size_t len, ssize_t *iter // TODO: API should probably take context void Layout::doLayout(const uint16_t* buf, size_t nchars) { - AutoMutex _l(gLock); + AutoMutex _l(gMinikinLock); if (buffer == 0) { buffer = hb_buffer_create(); } diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp new file mode 100644 index 0000000000..71c8649b1e --- /dev/null +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2014 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. + */ + +// Definitions internal to Minikin + +#include "MinikinInternal.h" + +namespace android { + +Mutex gMinikinLock; + +} diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h new file mode 100644 index 0000000000..b8430df550 --- /dev/null +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2014 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. + */ + +// Definitions internal to Minikin + +#ifndef MINIKIN_INTERNAL_H +#define MINIKIN_INTERNAL_H + +#include + +namespace android { + +// All external Minikin interfaces are designed to be thread-safe. +// Presently, that's implemented by through a global lock, and having +// all external interfaces take that lock. + +extern Mutex gMinikinLock; + +} + +#endif // MINIKIN_INTERNAL_H diff --git a/engine/src/flutter/libs/minikin/MinikinRefCounted.cpp b/engine/src/flutter/libs/minikin/MinikinRefCounted.cpp new file mode 100644 index 0000000000..9fa3ae4631 --- /dev/null +++ b/engine/src/flutter/libs/minikin/MinikinRefCounted.cpp @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2014 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. + */ + +// Base class for reference counted objects in Minikin + +#include "MinikinInternal.h" + +#include + +namespace android { + +void MinikinRefCounted::Ref() { + AutoMutex _l(gMinikinLock); + this->RefLocked(); +} + +void MinikinRefCounted::Unref() { + AutoMutex _l(gMinikinLock); + this->UnrefLocked(); +} + +} From 7b250767bc37242995b8faff6e497b1055465ac8 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 14 May 2014 11:01:32 -0700 Subject: [PATCH 010/364] Fix build breakage in sample code This updates the Skia sample implementation to implement GetBounds, but the FreeType implementation is NYI (to be fixed in future commit). Change-Id: I24eda14d5fb11c2a1e81394ad8c779de3292dd79 --- .../include/minikin/MinikinFontFreeType.h | 3 ++ .../libs/minikin/MinikinFontFreeType.cpp | 5 +++ engine/src/flutter/sample/MinikinSkia.cpp | 35 ++++++++++++++----- engine/src/flutter/sample/MinikinSkia.h | 3 ++ 4 files changed, 37 insertions(+), 9 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFontFreeType.h b/engine/src/flutter/include/minikin/MinikinFontFreeType.h index 70518319ac..13a513982b 100644 --- a/engine/src/flutter/include/minikin/MinikinFontFreeType.h +++ b/engine/src/flutter/include/minikin/MinikinFontFreeType.h @@ -47,6 +47,9 @@ public: float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const; + void GetBounds(MinikinRect* bounds, uint32_t glyph_id, + const MinikinPaint& paint) const; + // If buf is NULL, just update size bool GetTable(uint32_t tag, uint8_t *buf, size_t *size); diff --git a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp index be61345a9c..a251ddadbf 100644 --- a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp @@ -53,6 +53,11 @@ float MinikinFontFreeType::GetHorizontalAdvance(uint32_t glyph_id, return advance * (1.0 / 65536); } +void MinikinFontFreeType::GetBounds(MinikinRect* bounds, uint32_t glyph_id, + const MinikinPaint& paint) const { + // TODO: NYI +} + bool MinikinFontFreeType::GetTable(uint32_t tag, uint8_t *buf, size_t *size) { FT_ULong ftsize = *size; FT_Error error = FT_Load_Sfnt_Table(mTypeface, tag, 0, buf, &ftsize); diff --git a/engine/src/flutter/sample/MinikinSkia.cpp b/engine/src/flutter/sample/MinikinSkia.cpp index d67e59fbbc..8b499d8131 100644 --- a/engine/src/flutter/sample/MinikinSkia.cpp +++ b/engine/src/flutter/sample/MinikinSkia.cpp @@ -25,22 +25,39 @@ bool MinikinFontSkia::GetGlyph(uint32_t codepoint, uint32_t *glyph) const { return !!glyph; } +static void MinikinFontSkia_SetSkiaPaint(SkTypeface* typeface, SkPaint* skPaint, const MinikinPaint& paint) { + skPaint->setTypeface(typeface); + skPaint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); + // TODO: set more paint parameters from Minikin + skPaint->setTextSize(paint.size); +} + float MinikinFontSkia::GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const { - SkPaint skpaint; - skpaint.setTypeface(mTypeface); - skpaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); - // TODO: set paint from Minikin - skpaint.setTextSize(100); + SkPaint skPaint; uint16_t glyph16 = glyph_id; SkScalar skWidth; - SkRect skBounds; - skpaint.getTextWidths(&glyph16, sizeof(glyph16), &skWidth, &skBounds); - // bounds? - //printf("advance for glyph %d = %f\n", glyph_id, SkScalarToFP(skWidth)); + MinikinFontSkia_SetSkiaPaint(mTypeface, &skPaint, paint); + skPaint.getTextWidths(&glyph16, sizeof(glyph16), &skWidth, NULL); +#ifdef VERBOSE + ALOGD("width for typeface %d glyph %d = %f", mTypeface->uniqueID(), glyph_id +#endif return skWidth; } +void MinikinFontSkia::GetBounds(MinikinRect* bounds, uint32_t glyph_id, + const MinikinPaint& paint) const { + SkPaint skPaint; + uint16_t glyph16 = glyph_id; + SkRect skBounds; + MinikinFontSkia_SetSkiaPaint(mTypeface, &skPaint, paint); + skPaint.getTextWidths(&glyph16, sizeof(glyph16), NULL, &skBounds); + bounds->mLeft = skBounds.fLeft; + bounds->mTop = skBounds.fTop; + bounds->mRight = skBounds.fRight; + bounds->mBottom = skBounds.fBottom; +} + bool MinikinFontSkia::GetTable(uint32_t tag, uint8_t *buf, size_t *size) { if (buf == NULL) { const size_t tableSize = mTypeface->getTableSize(tag); diff --git a/engine/src/flutter/sample/MinikinSkia.h b/engine/src/flutter/sample/MinikinSkia.h index 8286a4c5c6..fca6ca2322 100644 --- a/engine/src/flutter/sample/MinikinSkia.h +++ b/engine/src/flutter/sample/MinikinSkia.h @@ -11,6 +11,9 @@ public: float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const; + void GetBounds(MinikinRect* bounds, uint32_t glyph_id, + const MinikinPaint& paint) const; + // If buf is NULL, just update size bool GetTable(uint32_t tag, uint8_t *buf, size_t *size); From df405e1da1439864d4596c97e4675ba582fbe45e Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 14 May 2014 12:33:09 -0700 Subject: [PATCH 011/364] Fix 64-bit cleanliness problem This patch fixes a problem where int and ssize_t were being conflated. Change-Id: I642a4ee1d59d81723034fdfe33bd8ca29a5dc322 --- engine/src/flutter/libs/minikin/Layout.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 20e2d9e45b..08365b354e 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -315,8 +315,8 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { hb_font_set_ppem(hbFont, size, size); hb_font_set_scale(hbFont, HBFloatToFixed(size), HBFloatToFixed(size)); - int srunend; - for (int srunstart = run.start; srunstart < run.end; srunstart = srunend) { + ssize_t srunend; + for (ssize_t srunstart = run.start; srunstart < run.end; srunstart = srunend) { srunend = srunstart; hb_script_t script = getScriptRun(buf, run.end, &srunend); From 686d245a0f231167240e156c010609275e571068 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 12 May 2014 15:10:30 -0700 Subject: [PATCH 012/364] Initial BiDi support This patch contains a very basic implementation of BiDi. It respects the BiDi flags passed in as an explicit parameter (through the "-minikin-bidi" pseudo-CSS property), but doesn't yet do its own BiDi run detection. It also takes some shortcuts (marked as TODO) that are based on reasonable assumptions of the current font stack, but not universally valid. Even with these shortcomings, it seems to display RTL text from TextView correctly. Change-Id: I223433923c4eb06f90c0327e86bfbe0aff71d4f5 --- engine/src/flutter/include/minikin/CssParse.h | 2 ++ engine/src/flutter/libs/minikin/CssParse.cpp | 1 + engine/src/flutter/libs/minikin/Layout.cpp | 13 +++++++++++-- 3 files changed, 14 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/include/minikin/CssParse.h b/engine/src/flutter/include/minikin/CssParse.h index f79ba1f61c..2dceb4ac26 100644 --- a/engine/src/flutter/include/minikin/CssParse.h +++ b/engine/src/flutter/include/minikin/CssParse.h @@ -28,6 +28,7 @@ enum CssTag { fontWeight, fontStyle, minikinHinting, + minikinBidi, }; const std::string cssTagNames[] = { @@ -36,6 +37,7 @@ const std::string cssTagNames[] = { "font-weight", "font-style", "-minikin-hinting", + "-minikin-bidi", }; class CssValue { diff --git a/engine/src/flutter/libs/minikin/CssParse.cpp b/engine/src/flutter/libs/minikin/CssParse.cpp index d4de23bee0..5bb6949b9a 100644 --- a/engine/src/flutter/libs/minikin/CssParse.cpp +++ b/engine/src/flutter/libs/minikin/CssParse.cpp @@ -41,6 +41,7 @@ CssTag parseTag(const string str, size_t off, size_t len) { if (strEqC(str, off, len, "font-style")) return fontStyle; } else if (c == '-') { if (strEqC(str, off, len, "-minikin-hinting")) return minikinHinting; + if (strEqC(str, off, len, "-minikin-bidi")) return minikinBidi; } return unknown; } diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 08365b354e..3a0be6abef 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -19,10 +19,12 @@ #include #include +#include #include #include // for debugging #include // ditto +#include #include #include "MinikinInternal.h" @@ -91,7 +93,6 @@ void Layout::init() { } void Layout::setFontCollection(const FontCollection *collection) { - ALOGD("setFontCollection(%p)", collection); mCollection = collection; } @@ -290,6 +291,11 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { MinikinPaint paint; double size = mProps.value(fontSize).getFloatValue(); paint.size = size; + int bidiFlags = mProps.hasTag(minikinBidi) ? mProps.value(minikinBidi).getIntValue() : 0; + bool isRtl = (bidiFlags & 1) != 0; // TODO: do real bidi algo + if (isRtl) { + std::reverse(items.begin(), items.end()); + } mGlyphs.clear(); mFaces.clear(); @@ -315,6 +321,9 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { hb_font_set_ppem(hbFont, size, size); hb_font_set_scale(hbFont, HBFloatToFixed(size), HBFloatToFixed(size)); + // 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. ssize_t srunend; for (ssize_t srunstart = run.start; srunstart < run.end; srunstart = srunend) { srunend = srunstart; @@ -322,7 +331,7 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { hb_buffer_reset(buffer); hb_buffer_set_script(buffer, script); - hb_buffer_set_direction(buffer, HB_DIRECTION_LTR); + hb_buffer_set_direction(buffer, isRtl? HB_DIRECTION_RTL : HB_DIRECTION_LTR); hb_buffer_add_utf16(buffer, buf, nchars, srunstart, srunend - srunstart); hb_shape(hbFont, buffer, NULL, 0); unsigned int numGlyphs; From 521c14790be4696a14b3b4a49d2c9846f4a90551 Mon Sep 17 00:00:00 2001 From: Leon Scroggins III Date: Thu, 15 May 2014 10:52:56 -0400 Subject: [PATCH 013/364] Remove references to SkFloatToScalar. The macro has been deprecated, now that SkScalar is never fixed point. Fixes minikin build. Change-Id: I02838a7fa167c5cf58ad225f3f2f52659495492c --- engine/src/flutter/sample/example_skia.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index ff13b5c187..e686621c34 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -92,8 +92,8 @@ void drawToSkia(SkCanvas *canvas, SkPaint *paint, Layout *layout, float x, float MinikinFontSkia *mfs = static_cast(layout->getFont(i)); skFace = mfs->GetSkTypeface(); glyphs[i] = layout->getGlyphId(i); - pos[i].fX = SkFloatToScalar(x + layout->getX(i)); - pos[i].fY = SkFloatToScalar(y + layout->getY(i)); + pos[i].fX = x + layout->getX(i); + pos[i].fY = y + layout->getY(i); if (i > 0 && skFace != lastFace) { paint->setTypeface(lastFace); canvas->drawPosText(glyphs + start, (i - start) << 1, pos + start, *paint); From 4841666ebe6aba70a957ee47ed26dbc3e63d189c Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 19 May 2014 13:21:21 -0700 Subject: [PATCH 014/364] Fix incomplete refcounting and locking These changes were supposed to be committed in the previous patch "Better refcounting and locking" but seem to have gotten lost in a rebase. It fixes a memory leak and some possible race conditions. Change-Id: I54ca1e37500ec49756fe317cc6d6d03da9911501 --- engine/src/flutter/include/minikin/FontFamily.h | 2 ++ engine/src/flutter/include/minikin/Layout.h | 6 ++++++ engine/src/flutter/libs/minikin/FontCollection.cpp | 2 ++ engine/src/flutter/libs/minikin/FontFamily.cpp | 11 +++++++++-- engine/src/flutter/libs/minikin/Layout.cpp | 7 +++++++ 5 files changed, 26 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 3b59017631..82fcfe9af8 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -56,6 +56,8 @@ public: MinikinFont* getFont(size_t index) const; FontStyle getStyle(size_t index) const; private: + void addFontLocked(MinikinFont* typeface, FontStyle style); + class Font { public: Font(MinikinFont* typeface, FontStyle style) : diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 896478b219..4fe9d8772f 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -55,8 +55,14 @@ struct LayoutGlyph { float y; }; +// Lifecycle and threading assumptions for Layout: +// The object is assumed to be owned by a single thread; multiple threads +// may not mutate it at the same time. +// The lifetime of the FontCollection set through setFontCollection must +// extend through the lifetime of the Layout object. class Layout { public: + ~Layout(); void dump() const; void setFontCollection(const FontCollection* collection); diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 18e528efb0..cd7b19e009 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -19,6 +19,7 @@ #define LOG_TAG "Minikin" #include +#include "MinikinInternal.h" #include #include @@ -33,6 +34,7 @@ static inline T max(T a, T b) { FontCollection::FontCollection(const vector& typefaces) : mMaxChar(0) { + AutoMutex _l(gMinikinLock); vector lastChar; size_t nTypefaces = typefaces.size(); #ifdef VERBOSE_DEBUG diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index d8525ffa6d..d818f77eec 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -19,6 +19,8 @@ #include #include #include + +#include "MinikinInternal.h" #include #include #include @@ -35,6 +37,7 @@ FontFamily::~FontFamily() { } bool FontFamily::addFont(MinikinFont* typeface) { + AutoMutex _l(gMinikinLock); const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); size_t os2Size = 0; bool ok = typeface->GetTable(os2Tag, NULL, &os2Size); @@ -47,7 +50,7 @@ bool FontFamily::addFont(MinikinFont* typeface) { if (analyzeStyle(os2Data.get(), os2Size, &weight, &italic)) { //ALOGD("analyzed weight = %d, italic = %s", weight, italic ? "true" : "false"); FontStyle style(weight, italic); - addFont(typeface, style); + addFontLocked(typeface, style); return true; } else { ALOGD("failed to analyze style"); @@ -56,7 +59,11 @@ bool FontFamily::addFont(MinikinFont* typeface) { } void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { - typeface->RefLocked(); + AutoMutex _l(gMinikinLock); + addFontLocked(typeface, style); +} + +void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { typeface->RefLocked(); mFonts.push_back(Font(typeface, style)); } diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 3a0be6abef..f32e9f4e4f 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -161,6 +161,7 @@ hb_font_funcs_t* getHbFontFuncs() { hb_font_t* create_hb_font(MinikinFont* minikinFont, MinikinPaint* minikinPaint) { hb_face_t* face = hb_face_create_for_tables(referenceTable, minikinFont, NULL); hb_font_t* font = hb_font_create(face); + hb_face_destroy(face); hb_font_set_funcs(font, getHbFontFuncs(), minikinPaint, 0); // TODO: manage ownership of face return font; @@ -176,6 +177,12 @@ static hb_position_t HBFloatToFixed(float v) return scalbnf (v, +8); } +Layout::~Layout() { + for (size_t ix = 0; ix < mHbFonts.size(); ix++) { + hb_font_destroy(mHbFonts[ix]); + } +} + void Layout::dump() const { for (size_t i = 0; i < mGlyphs.size(); i++) { const LayoutGlyph& glyph = mGlyphs[i]; From e9ee2563318ba73da8674526388888d0dee5aca5 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 19 May 2014 11:58:20 -0700 Subject: [PATCH 015/364] Do BiDi algorithm for text layout This patch extends the previous BiDi support (when the direction for the entire string was given by the caller) to run the BiDi algorithm (provided by ICU) over the string to break it into BiDi runs. Thus, it handles mixed LTR and RTL strings in a single layout, and also respects heuristics for inferring the paragraph direction from the string. Change-Id: Ia4b869de3c139c5a7d16b8ce7766870b98a815ea --- engine/src/flutter/include/minikin/Layout.h | 4 + engine/src/flutter/libs/minikin/Android.mk | 3 +- engine/src/flutter/libs/minikin/Layout.cpp | 88 ++++++++++++++++++--- 3 files changed, 85 insertions(+), 10 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 4fe9d8772f..6c338db280 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -94,6 +94,10 @@ private: // Find a face in the mFaces vector, or create a new entry int findFace(MinikinFont* face, MinikinPaint* paint); + // Lay out a single bidi run + void doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, FontStyle style, MinikinPaint& paint); + CssProperties mProps; // TODO: want spans std::vector mGlyphs; std::vector mAdvances; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index c4412859c4..f1f035497a 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -43,6 +43,7 @@ LOCAL_SHARED_LIBRARIES := \ liblog \ libpng \ libz \ - libstlport + libstlport \ + libicuuc include $(BUILD_SHARED_LIBRARY) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index f32e9f4e4f..918bc2e87d 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -39,6 +39,21 @@ namespace android { // TODO: globals are not cool, move to a factory-ish object hb_buffer_t* buffer = 0; +// TODO: these should move into the header file, but for now we don't want +// to cause namespace collisions with TextLayout.h +enum { + kBidi_LTR = 0, + kBidi_RTL = 1, + kBidi_Default_LTR = 2, + kBidi_Default_RTL = 3, + kBidi_Force_LTR = 4, + kBidi_Force_RTL = 5, + + kBidi_Mask = 0x7 +}; + +const int kDirection_Mask = 0x1; + Bitmap::Bitmap(int width, int height) : width(width), height(height) { buf = new uint8_t[width * height](); } @@ -291,18 +306,14 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { } FT_Error error; - vector items; FontStyle style = styleFromCss(mProps); - mCollection->itemize(buf, nchars, style, &items); MinikinPaint paint; double size = mProps.value(fontSize).getFloatValue(); paint.size = size; int bidiFlags = mProps.hasTag(minikinBidi) ? mProps.value(minikinBidi).getIntValue() : 0; - bool isRtl = (bidiFlags & 1) != 0; // TODO: do real bidi algo - if (isRtl) { - std::reverse(items.begin(), items.end()); - } + bool isRtl = (bidiFlags & kDirection_Mask) != 0; + bool doSingleRun = true; mGlyphs.clear(); mFaces.clear(); @@ -310,7 +321,65 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { mBounds.setEmpty(); mAdvances.clear(); mAdvances.resize(nchars, 0); - float x = 0; + mAdvance = 0; + if (!(bidiFlags == kBidi_Force_LTR || bidiFlags == kBidi_Force_RTL)) { + UBiDi* bidi = ubidi_open(); + if (bidi) { + UErrorCode status = U_ZERO_ERROR; + UBiDiLevel bidiReq = bidiFlags; + if (bidiFlags == kBidi_Default_LTR) { + bidiReq = UBIDI_DEFAULT_LTR; + } else if (bidiFlags == kBidi_Default_RTL) { + bidiReq = UBIDI_DEFAULT_RTL; + } + ubidi_setPara(bidi, buf, nchars, bidiReq, NULL, &status); + if (U_SUCCESS(status)) { + int paraDir = ubidi_getParaLevel(bidi) & kDirection_Mask; + ssize_t rc = ubidi_countRuns(bidi, &status); + if (!U_SUCCESS(status) || rc < 1) { + ALOGD("error counting bidi runs, status = %d", status); + } + if (!U_SUCCESS(status) || rc <= 1) { + isRtl = (paraDir == kBidi_RTL); + } else { + doSingleRun = false; + // iterate through runs + for (ssize_t i = 0; i < (ssize_t)rc; i++) { + int32_t startRun = -1; + int32_t lengthRun = -1; + UBiDiDirection runDir = ubidi_getVisualRun(bidi, i, &startRun, &lengthRun); + if (startRun == -1 || lengthRun == -1) { + ALOGE("invalid visual run"); + // Note: this case will lose text; can it ever actually happen? + break; + } + isRtl = (runDir == UBIDI_RTL); + // TODO: min/max with context + doLayoutRun(buf, startRun, lengthRun, nchars, isRtl, style, paint); + } + } + } else { + ALOGE("error calling ubidi_setPara, status = %d", status); + } + ubidi_close(bidi); + } else { + ALOGE("error creating bidi object"); + } + } + if (doSingleRun) { + doLayoutRun(buf, 0, nchars, nchars, isRtl, style, paint); + } +} + +void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, FontStyle style, MinikinPaint& paint) { + vector items; + mCollection->itemize(buf + start, count, style, &items); + if (isRtl) { + std::reverse(items.begin(), items.end()); + } + + float x = mAdvance; float y = 0; for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { FontCollection::Run &run = items[run_ix]; @@ -325,6 +394,7 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { std::cout << "Run " << run_ix << ", font " << font_ix << " [" << run.start << ":" << run.end << "]" << std::endl; #endif + double size = paint.size; hb_font_set_ppem(hbFont, size, size); hb_font_set_scale(hbFont, HBFloatToFixed(size), HBFloatToFixed(size)); @@ -334,12 +404,12 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { ssize_t srunend; for (ssize_t srunstart = run.start; srunstart < run.end; srunstart = srunend) { srunend = srunstart; - hb_script_t script = getScriptRun(buf, run.end, &srunend); + hb_script_t script = getScriptRun(buf + start, run.end, &srunend); hb_buffer_reset(buffer); hb_buffer_set_script(buffer, script); hb_buffer_set_direction(buffer, isRtl? HB_DIRECTION_RTL : HB_DIRECTION_LTR); - hb_buffer_add_utf16(buffer, buf, nchars, srunstart, srunend - srunstart); + hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); hb_shape(hbFont, buffer, NULL, 0); unsigned int numGlyphs; hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); From 8893e8692be3b069f1d9b40970979060b31ecfc4 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 19 May 2014 13:21:21 -0700 Subject: [PATCH 016/364] Fix incomplete refcounting and locking These changes were supposed to be committed in the previous patch "Better refcounting and locking" but seem to have gotten lost in a rebase. It fixes a memory leak and some possible race conditions. Change-Id: I54ca1e37500ec49756fe317cc6d6d03da9911501 --- engine/src/flutter/include/minikin/FontFamily.h | 2 ++ engine/src/flutter/include/minikin/Layout.h | 6 ++++++ engine/src/flutter/libs/minikin/FontCollection.cpp | 2 ++ engine/src/flutter/libs/minikin/FontFamily.cpp | 11 +++++++++-- engine/src/flutter/libs/minikin/Layout.cpp | 7 +++++++ 5 files changed, 26 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 3b59017631..82fcfe9af8 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -56,6 +56,8 @@ public: MinikinFont* getFont(size_t index) const; FontStyle getStyle(size_t index) const; private: + void addFontLocked(MinikinFont* typeface, FontStyle style); + class Font { public: Font(MinikinFont* typeface, FontStyle style) : diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 896478b219..4fe9d8772f 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -55,8 +55,14 @@ struct LayoutGlyph { float y; }; +// Lifecycle and threading assumptions for Layout: +// The object is assumed to be owned by a single thread; multiple threads +// may not mutate it at the same time. +// The lifetime of the FontCollection set through setFontCollection must +// extend through the lifetime of the Layout object. class Layout { public: + ~Layout(); void dump() const; void setFontCollection(const FontCollection* collection); diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 18e528efb0..cd7b19e009 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -19,6 +19,7 @@ #define LOG_TAG "Minikin" #include +#include "MinikinInternal.h" #include #include @@ -33,6 +34,7 @@ static inline T max(T a, T b) { FontCollection::FontCollection(const vector& typefaces) : mMaxChar(0) { + AutoMutex _l(gMinikinLock); vector lastChar; size_t nTypefaces = typefaces.size(); #ifdef VERBOSE_DEBUG diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index d8525ffa6d..d818f77eec 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -19,6 +19,8 @@ #include #include #include + +#include "MinikinInternal.h" #include #include #include @@ -35,6 +37,7 @@ FontFamily::~FontFamily() { } bool FontFamily::addFont(MinikinFont* typeface) { + AutoMutex _l(gMinikinLock); const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); size_t os2Size = 0; bool ok = typeface->GetTable(os2Tag, NULL, &os2Size); @@ -47,7 +50,7 @@ bool FontFamily::addFont(MinikinFont* typeface) { if (analyzeStyle(os2Data.get(), os2Size, &weight, &italic)) { //ALOGD("analyzed weight = %d, italic = %s", weight, italic ? "true" : "false"); FontStyle style(weight, italic); - addFont(typeface, style); + addFontLocked(typeface, style); return true; } else { ALOGD("failed to analyze style"); @@ -56,7 +59,11 @@ bool FontFamily::addFont(MinikinFont* typeface) { } void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { - typeface->RefLocked(); + AutoMutex _l(gMinikinLock); + addFontLocked(typeface, style); +} + +void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { typeface->RefLocked(); mFonts.push_back(Font(typeface, style)); } diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 3a0be6abef..f32e9f4e4f 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -161,6 +161,7 @@ hb_font_funcs_t* getHbFontFuncs() { hb_font_t* create_hb_font(MinikinFont* minikinFont, MinikinPaint* minikinPaint) { hb_face_t* face = hb_face_create_for_tables(referenceTable, minikinFont, NULL); hb_font_t* font = hb_font_create(face); + hb_face_destroy(face); hb_font_set_funcs(font, getHbFontFuncs(), minikinPaint, 0); // TODO: manage ownership of face return font; @@ -176,6 +177,12 @@ static hb_position_t HBFloatToFixed(float v) return scalbnf (v, +8); } +Layout::~Layout() { + for (size_t ix = 0; ix < mHbFonts.size(); ix++) { + hb_font_destroy(mHbFonts[ix]); + } +} + void Layout::dump() const { for (size_t i = 0; i < mGlyphs.size(); i++) { const LayoutGlyph& glyph = mGlyphs[i]; From 6bbcf44f6805bc5f913be9f4f7e04be020f685f3 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 21 May 2014 08:37:49 -0700 Subject: [PATCH 017/364] Caching for layouts and harfbuzz faces This patch adds caching for both layouts and for HarfBuzz face objects. The granularity of the cache for layouts is words, so it splits the input string at word boundaries (using a heuristic). There are is also some refactoring to reduce the amount of allocation and copying, and movement towards properly supporting contexts. The size of the caches is a fixed number of entries; thus, it is possible to consume a large amount of memory by filling the cache with lots of large strings. This should be refined towards a scheme that bounds the total memory used by the cache. Change-Id: Ie8176857e2d78656ce5479a7c04969819ef2718d --- .../flutter/include/minikin/FontCollection.h | 11 +- .../src/flutter/include/minikin/FontFamily.h | 14 +- engine/src/flutter/include/minikin/Layout.h | 41 +- .../src/flutter/include/minikin/MinikinFont.h | 1 + engine/src/flutter/libs/minikin/Android.mk | 3 +- .../flutter/libs/minikin/FontCollection.cpp | 13 + engine/src/flutter/libs/minikin/Layout.cpp | 388 +++++++++++++++--- engine/src/flutter/sample/example.cpp | 2 +- 8 files changed, 390 insertions(+), 83 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index dc48f8e0a2..c6c2ed05b0 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -54,9 +54,12 @@ public: int start; int end; }; + void itemize(const uint16_t *string, size_t string_length, FontStyle style, std::vector* result) const; - private: + + uint32_t getId() const; +private: static const int kLogCharsPerPage = 8; static const int kPageMask = (1 << kLogCharsPerPage) - 1; @@ -70,6 +73,12 @@ public: size_t end; }; + // static for allocating unique id's + static uint32_t sNextId; + + // unique id for this font collection (suitable for cache key) + uint32_t mId; + // Highest UTF-32 code point that can be mapped uint32_t mMaxChar; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 82fcfe9af8..a4fe9cb9e4 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -19,6 +19,8 @@ #include +#include + #include namespace android { @@ -31,16 +33,22 @@ public: FontStyle(int weight = 4, bool italic = false) { bits = (weight & kWeightMask) | (italic ? kItalicMask : 0); } - int getWeight() { return bits & kWeightMask; } - bool getItalic() { return (bits & kItalicMask) != 0; } - bool operator==(const FontStyle other) { return bits == other.bits; } + int getWeight() const { return bits & kWeightMask; } + bool getItalic() const { return (bits & kItalicMask) != 0; } + bool operator==(const FontStyle other) const { return bits == other.bits; } // TODO: language, variant + + hash_t hash() const { return bits; } private: static const int kWeightMask = 0xf; static const int kItalicMask = 16; uint32_t bits; }; +inline hash_t hash_type(const FontStyle &style) { + return style.hash(); +} + class FontFamily : public MinikinRefCounted { public: ~FontFamily(); diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 6c338db280..a1ef0c13b8 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -55,6 +55,9 @@ struct LayoutGlyph { float y; }; +// Internal state used during layout operation +class LayoutContext; + // Lifecycle and threading assumptions for Layout: // The object is assumed to be owned by a single thread; multiple threads // may not mutate it at the same time. @@ -62,13 +65,19 @@ struct LayoutGlyph { // extend through the lifetime of the Layout object. class Layout { public: - ~Layout(); - void dump() const; void setFontCollection(const FontCollection* collection); + + // deprecated - missing functionality void doLayout(const uint16_t* buf, size_t nchars); - void draw(Bitmap*, int x0, int y0) const; - void setProperties(const std::string css); + + void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + const std::string& css); + + void draw(Bitmap*, int x0, int y0, float size) const; + + // deprecated - pass as argument to doLayout instead + void setProperties(const std::string& css); // This must be called before any invocations. // TODO: probably have a factory instead @@ -92,23 +101,31 @@ public: private: // Find a face in the mFaces vector, or create a new entry - int findFace(MinikinFont* face, MinikinPaint* paint); + int findFace(MinikinFont* face, LayoutContext* ctx); + + // Lay out a single bidi run + void doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, LayoutContext* ctx); + + // Lay out a single word + void doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, LayoutContext* ctx, size_t bufStart); // Lay out a single bidi run void doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, FontStyle style, MinikinPaint& paint); + bool isRtl, LayoutContext* ctx); + + // Append another layout (for example, cached value) into this one + void appendLayout(Layout* src, size_t start); + + // deprecated - remove when setProperties is removed + std::string mCssString; - CssProperties mProps; // TODO: want spans std::vector mGlyphs; std::vector mAdvances; - // In future, this will be some kind of mapping from the - // identifier used to represent font-family to a font collection. - // But for the time being, it should be ok to have just one - // per layout. const FontCollection* mCollection; std::vector mFaces; - std::vector mHbFonts; float mAdvance; MinikinRect mBounds; }; diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 568f19da7f..dbb89f8331 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -27,6 +27,7 @@ namespace android { class MinikinFont; // Possibly move into own .h file? +// Note: if you add a field here, also update LayoutCacheKey struct MinikinPaint { MinikinFont *font; float size; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index f1f035497a..a1d88c29e5 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -44,6 +44,7 @@ LOCAL_SHARED_LIBRARIES := \ libpng \ libz \ libstlport \ - libicuuc + libicuuc \ + libutils include $(BUILD_SHARED_LIBRARY) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index cd7b19e009..67089dbe8b 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -32,9 +32,12 @@ static inline T max(T a, T b) { return a>b ? a : b; } +uint32_t FontCollection::sNextId = 0; + FontCollection::FontCollection(const vector& typefaces) : mMaxChar(0) { AutoMutex _l(gMinikinLock); + mId = sNextId++; vector lastChar; size_t nTypefaces = typefaces.size(); #ifdef VERBOSE_DEBUG @@ -50,6 +53,12 @@ FontCollection::FontCollection(const vector& typefaces) : instance->mFamily = family; instance->mCoverage = new SparseBitSet; MinikinFont* typeface = family->getClosestMatch(defaultStyle); + if (typeface == NULL) { + ALOGE("FontCollection: closest match was null"); + // TODO: we shouldn't hit this, as there should be more robust + // checks upstream to prevent empty/invalid FontFamily objects + continue; + } #ifdef VERBOSE_DEBUG ALOGD("closest match = %p, family size = %d\n", typeface, family->getNumFonts()); #endif @@ -149,4 +158,8 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } } +uint32_t FontCollection::getId() const { + return mId; +} + } // namespace android diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 918bc2e87d..886b7d1f1c 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -24,6 +24,11 @@ #include // for debugging #include // ditto +#include +#include +#include +#include + #include #include @@ -36,9 +41,6 @@ using std::vector; namespace android { -// TODO: globals are not cool, move to a factory-ish object -hb_buffer_t* buffer = 0; - // TODO: these should move into the header file, but for now we don't want // to cause namespace collisions with TextLayout.h enum { @@ -54,6 +56,114 @@ enum { const int kDirection_Mask = 0x1; +// Layout cache datatypes + +class LayoutCacheKey { +public: + LayoutCacheKey(const FontCollection* collection, const MinikinPaint& paint, FontStyle style, + const uint16_t* chars, size_t start, size_t count, size_t nchars, bool dir) + : mStart(start), mCount(count), mId(collection->getId()), mStyle(style), + mSize(paint.size), mIsRtl(dir) { + mText.setTo(chars, nchars); + } + bool operator==(const LayoutCacheKey &other) const; + hash_t hash() const; + + // This is present to avoid having to copy the text more than once. + const uint16_t* textBuf() { return mText.string(); } +private: + String16 mText; + size_t mStart; + size_t mCount; + uint32_t mId; // for the font collection + FontStyle mStyle; + float mSize; + bool mIsRtl; + // Note: any fields added to MinikinPaint must also be reflected here. + // TODO: language matching (possibly integrate into style) +}; + +class LayoutCache : private OnEntryRemoved { +public: + LayoutCache() : mCache(kMaxEntries) { + mCache.setOnEntryRemovedListener(this); + } + + // callback for OnEntryRemoved + void operator()(LayoutCacheKey& key, Layout*& value) { + delete value; + } + + LruCache mCache; +private: + //static const size_t kMaxEntries = LruCache::kUnlimitedCapacity; + + // TODO: eviction based on memory footprint; for now, we just use a constant + // number of strings + static const size_t kMaxEntries = 5000; +}; + +class HbFaceCache : private OnEntryRemoved { +public: + HbFaceCache() : mCache(kMaxEntries) { + mCache.setOnEntryRemovedListener(this); + } + + // callback for OnEntryRemoved + void operator()(int32_t& key, hb_face_t*& value) { + hb_face_destroy(value); + } + + LruCache mCache; +private: + static const size_t kMaxEntries = 100; +}; + +class LayoutEngine : public Singleton { +public: + LayoutEngine() { + hbBuffer = hb_buffer_create(); + } + + hb_buffer_t* hbBuffer; + LayoutCache layoutCache; + HbFaceCache hbFaceCache; +}; + +ANDROID_SINGLETON_STATIC_INSTANCE(LayoutEngine); + +bool LayoutCacheKey::operator==(const LayoutCacheKey& other) const { + return mId == other.mId && + mStart == other.mStart && + mCount == other.mCount && + mStyle == other.mStyle && + mSize == other.mSize && + mIsRtl == other.mIsRtl && + mText == other.mText; +} + +hash_t LayoutCacheKey::hash() const { + uint32_t hash = JenkinsHashMix(0, mId); + hash = JenkinsHashMix(hash, mStart); + hash = JenkinsHashMix(hash, mCount); + hash = JenkinsHashMix(hash, hash_type(mStyle)); + hash = JenkinsHashMix(hash, hash_type(mSize)); + hash = JenkinsHashMix(hash, hash_type(mIsRtl)); + hash = JenkinsHashMixShorts(hash, mText.string(), mText.size()); + return JenkinsHashWhiten(hash); +} + +struct LayoutContext { + MinikinPaint paint; + FontStyle style; + CssProperties props; + std::vector hbFonts; // parallel to mFaces +}; + +hash_t hash_type(const LayoutCacheKey& key) { + return key.hash(); +} + Bitmap::Bitmap(int width, int height) : width(width), height(height) { buf = new uint8_t[width * height](); } @@ -107,18 +217,18 @@ void MinikinRect::join(const MinikinRect& r) { void Layout::init() { } -void Layout::setFontCollection(const FontCollection *collection) { +void Layout::setFontCollection(const FontCollection* collection) { mCollection = collection; } hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { - MinikinFont* font = reinterpret_cast(userData); + MinikinFont* font = reinterpret_cast(userData); size_t length = 0; bool ok = font->GetTable(tag, NULL, &length); if (!ok) { return 0; } - char *buffer = reinterpret_cast(malloc(length)); + char* buffer = reinterpret_cast(malloc(length)); if (!buffer) { return 0; } @@ -135,7 +245,7 @@ hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { static hb_bool_t harfbuzzGetGlyph(hb_font_t* hbFont, void* fontData, hb_codepoint_t unicode, hb_codepoint_t variationSelector, hb_codepoint_t* glyph, void* userData) { - MinikinPaint* paint = reinterpret_cast(fontData); + MinikinPaint* paint = reinterpret_cast(fontData); MinikinFont* font = paint->font; uint32_t glyph_id; bool ok = font->GetGlyph(unicode, &glyph_id); @@ -147,7 +257,7 @@ static hb_bool_t harfbuzzGetGlyph(hb_font_t* hbFont, void* fontData, hb_codepoin static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, void* userData) { - MinikinPaint* paint = reinterpret_cast(fontData); + MinikinPaint* paint = reinterpret_cast(fontData); MinikinFont* font = paint->font; float advance = font->GetHorizontalAdvance(glyph, *paint); return 256 * advance + 0.5; @@ -173,12 +283,21 @@ hb_font_funcs_t* getHbFontFuncs() { return hbFontFuncs; } -hb_font_t* create_hb_font(MinikinFont* minikinFont, MinikinPaint* minikinPaint) { - hb_face_t* face = hb_face_create_for_tables(referenceTable, minikinFont, NULL); +static hb_face_t* getHbFace(MinikinFont* minikinFont) { + HbFaceCache& cache = LayoutEngine::getInstance().hbFaceCache; + int32_t fontId = minikinFont->GetUniqueId(); + hb_face_t* face = cache.mCache.get(fontId); + if (face == NULL) { + face = hb_face_create_for_tables(referenceTable, minikinFont, NULL); + cache.mCache.put(fontId, face); + } + return face; +} + +static hb_font_t* create_hb_font(MinikinFont* minikinFont, MinikinPaint* minikinPaint) { + hb_face_t* face = getHbFace(minikinFont); hb_font_t* font = hb_font_create(face); - hb_face_destroy(face); hb_font_set_funcs(font, getHbFontFuncs(), minikinPaint, 0); - // TODO: manage ownership of face return font; } @@ -192,12 +311,6 @@ static hb_position_t HBFloatToFixed(float v) return scalbnf (v, +8); } -Layout::~Layout() { - for (size_t ix = 0; ix < mHbFonts.size(); ix++) { - hb_font_destroy(mHbFonts[ix]); - } -} - void Layout::dump() const { for (size_t i = 0; i < mGlyphs.size(); i++) { const LayoutGlyph& glyph = mGlyphs[i]; @@ -205,11 +318,7 @@ void Layout::dump() const { } } -// A couple of things probably need to change: -// 1. Deal with multiple sizes in a layout -// 2. We'll probably store FT_Face as primary and then use a cache -// for the hb fonts -int Layout::findFace(MinikinFont* face, MinikinPaint* paint) { +int Layout::findFace(MinikinFont* face, LayoutContext* ctx) { unsigned int ix; for (ix = 0; ix < mFaces.size(); ix++) { if (mFaces[ix] == face) { @@ -217,8 +326,12 @@ int Layout::findFace(MinikinFont* face, MinikinPaint* paint) { } } mFaces.push_back(face); - hb_font_t *font = create_hb_font(face, paint); - mHbFonts.push_back(font); + // Note: ctx == NULL means we're copying from the cache, no need to create + // corresponding hb_font object. + if (ctx != NULL) { + hb_font_t* font = create_hb_font(face, &ctx->paint); + ctx->hbFonts.push_back(font); + } return ix; } @@ -235,14 +348,14 @@ static FontStyle styleFromCss(const CssProperties &props) { } static hb_script_t codePointToScript(hb_codepoint_t codepoint) { - static hb_unicode_funcs_t *u = 0; + static hb_unicode_funcs_t* u = 0; if (!u) { u = hb_icu_get_unicode_funcs(); } return hb_unicode_script(u, codepoint); } -static hb_codepoint_t decodeUtf16(const uint16_t *chars, size_t len, ssize_t *iter) { +static hb_codepoint_t decodeUtf16(const uint16_t* chars, size_t len, ssize_t* iter) { const uint16_t v = chars[(*iter)++]; // test whether v in (0xd800..0xdfff), lead or trail surrogate if ((v & 0xf800) == 0xd800) { @@ -266,7 +379,7 @@ static hb_codepoint_t decodeUtf16(const uint16_t *chars, size_t len, ssize_t *it } } -static hb_script_t getScriptRun(const uint16_t *chars, size_t len, ssize_t *iter) { +static hb_script_t getScriptRun(const uint16_t* chars, size_t len, ssize_t* iter) { if (size_t(*iter) == len) { return HB_SCRIPT_UNKNOWN; } @@ -298,29 +411,99 @@ static hb_script_t getScriptRun(const uint16_t *chars, size_t len, ssize_t *iter return current_script; } -// TODO: API should probably take context -void Layout::doLayout(const uint16_t* buf, size_t nchars) { - AutoMutex _l(gMinikinLock); - if (buffer == 0) { - buffer = hb_buffer_create(); +/** + * For the purpose of layout, a word break is a boundary with no + * kerning or complex script processing. This is necessarily a + * heuristic, but should be accurate most of the time. + */ +static bool isWordBreak(int c) { + if (c == ' ' || (c >= 0x2000 && c <= 0x200a) || c == 0x3000) { + // spaces + return true; } - FT_Error error; + if ((c >= 0x3400 && c <= 0x9fff)) { + // CJK ideographs (and yijing hexagram symbols) + return true; + } + // Note: kana is not included, as sophisticated fonts may kern kana + return false; +} - FontStyle style = styleFromCss(mProps); +/** + * Return offset of previous word break. It is either < offset or == 0. + */ +static size_t getPrevWordBreak(const uint16_t* chars, size_t offset) { + if (offset == 0) return 0; + if (isWordBreak(chars[offset - 1])) { + return offset - 1; + } + for (size_t i = offset - 1; i > 0; i--) { + if (isWordBreak(chars[i - 1])) { + return i; + } + } + return 0; +} - MinikinPaint paint; - double size = mProps.value(fontSize).getFloatValue(); - paint.size = size; - int bidiFlags = mProps.hasTag(minikinBidi) ? mProps.value(minikinBidi).getIntValue() : 0; +/** + * Return offset of next word break. It is either > offset or == len. + */ +static size_t getNextWordBreak(const uint16_t* chars, size_t offset, size_t len) { + if (offset >= len) return len; + if (isWordBreak(chars[offset])) { + return offset + 1; + } + for (size_t i = offset + 1; i < len; i++) { + if (isWordBreak(chars[i])) { + return i; + } + } + return len; +} + +// deprecated API, to avoid breaking client +void Layout::doLayout(const uint16_t* buf, size_t nchars) { + doLayout(buf, 0, nchars, nchars, mCssString); +} + +// TODO: use some standard implementation +template +static T mymin(const T& a, const T& b) { + return a < b ? a : b; +} + +template +static T mymax(const T& a, const T& b) { + return a > b ? a : b; +} + +static void clearHbFonts(LayoutContext* ctx) { + for (size_t i = 0; i < ctx->hbFonts.size(); i++) { + hb_font_destroy(ctx->hbFonts[i]); + } + ctx->hbFonts.clear(); +} + +// TODO: API should probably take context +void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + const std::string& css) { + AutoMutex _l(gMinikinLock); + LayoutContext ctx; + + ctx.props.parse(css); + ctx.style = styleFromCss(ctx.props); + + double size = ctx.props.value(fontSize).getFloatValue(); + ctx.paint.size = size; + int bidiFlags = ctx.props.hasTag(minikinBidi) ? ctx.props.value(minikinBidi).getIntValue() : 0; bool isRtl = (bidiFlags & kDirection_Mask) != 0; bool doSingleRun = true; mGlyphs.clear(); mFaces.clear(); - mHbFonts.clear(); mBounds.setEmpty(); mAdvances.clear(); - mAdvances.resize(nchars, 0); + mAdvances.resize(count, 0); mAdvance = 0; if (!(bidiFlags == kBidi_Force_LTR || bidiFlags == kBidi_Force_RTL)) { UBiDi* bidi = ubidi_open(); @@ -332,12 +515,12 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { } else if (bidiFlags == kBidi_Default_RTL) { bidiReq = UBIDI_DEFAULT_RTL; } - ubidi_setPara(bidi, buf, nchars, bidiReq, NULL, &status); + ubidi_setPara(bidi, buf, bufSize, bidiReq, NULL, &status); if (U_SUCCESS(status)) { int paraDir = ubidi_getParaLevel(bidi) & kDirection_Mask; ssize_t rc = ubidi_countRuns(bidi, &status); - if (!U_SUCCESS(status) || rc < 1) { - ALOGD("error counting bidi runs, status = %d", status); + if (!U_SUCCESS(status) || rc < 0) { + ALOGW("error counting bidi runs, status = %d", status); } if (!U_SUCCESS(status) || rc <= 1) { isRtl = (paraDir == kBidi_RTL); @@ -350,12 +533,12 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { UBiDiDirection runDir = ubidi_getVisualRun(bidi, i, &startRun, &lengthRun); if (startRun == -1 || lengthRun == -1) { ALOGE("invalid visual run"); - // Note: this case will lose text; can it ever actually happen? - break; + // skip the invalid run + continue; } isRtl = (runDir == UBIDI_RTL); // TODO: min/max with context - doLayoutRun(buf, startRun, lengthRun, nchars, isRtl, style, paint); + doLayoutRunCached(buf, startRun, lengthRun, bufSize, isRtl, &ctx); } } } else { @@ -367,14 +550,63 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { } } if (doSingleRun) { - doLayoutRun(buf, 0, nchars, nchars, isRtl, style, paint); + doLayoutRunCached(buf, start, count, bufSize, isRtl, &ctx); + } + clearHbFonts(&ctx); +} + +void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, LayoutContext* ctx) { + if (!isRtl) { + // left to right + size_t wordstart = start == bufSize ? start : getPrevWordBreak(buf, start + 1); + size_t wordend; + for (size_t iter = start; iter < start + count; iter = wordend) { + wordend = getNextWordBreak(buf, iter, bufSize); + size_t wordcount = mymin(start + count, wordend) - iter; + doLayoutWord(buf + wordstart, iter - wordstart, wordcount, wordend - wordstart, + isRtl, ctx, iter); + wordstart = wordend; + } + } else { + // right to left + size_t wordstart; + size_t end = start + count; + size_t wordend = end == 0 ? 0 : getNextWordBreak(buf, end - 1, bufSize); + for (size_t iter = end; iter > start; iter = wordstart) { + wordstart = getPrevWordBreak(buf, iter); + size_t bufStart = mymax(start, wordstart); + doLayoutWord(buf + wordstart, bufStart - wordstart, iter - bufStart, + wordend - wordstart, isRtl, ctx, bufStart); + wordend = wordstart; + } } } +void Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, LayoutContext* ctx, size_t bufStart) { + LayoutCache& cache = LayoutEngine::getInstance().layoutCache; + LayoutCacheKey key(mCollection, ctx->paint, ctx->style, buf, start, count, bufSize, isRtl); + Layout* value = cache.mCache.get(key); + if (value == NULL) { + value = new Layout(); + value->setFontCollection(mCollection); + value->mAdvances.resize(count, 0); + clearHbFonts(ctx); + // Note: we do the layout from the copy stored in the key, in case a + // badly-behaved client is mutating the buffer in a separate thread. + value->doLayoutRun(key.textBuf(), start, count, bufSize, isRtl, ctx); + } + appendLayout(value, bufStart); + cache.mCache.put(key, value); + +} + void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, FontStyle style, MinikinPaint& paint) { + bool isRtl, LayoutContext* ctx) { + hb_buffer_t* buffer = LayoutEngine::getInstance().hbBuffer; vector items; - mCollection->itemize(buf + start, count, style, &items); + mCollection->itemize(buf + start, count, ctx->style, &items); if (isRtl) { std::reverse(items.begin(), items.end()); } @@ -383,10 +615,10 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t float y = 0; for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { FontCollection::Run &run = items[run_ix]; - int font_ix = findFace(run.font, &paint); - paint.font = mFaces[font_ix]; - hb_font_t *hbFont = mHbFonts[font_ix]; - if (paint.font == NULL) { + int font_ix = findFace(run.font, ctx); + ctx->paint.font = mFaces[font_ix]; + hb_font_t* hbFont = ctx->hbFonts[font_ix]; + if (ctx->paint.font == NULL) { // TODO: should log what went wrong continue; } @@ -394,7 +626,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t std::cout << "Run " << run_ix << ", font " << font_ix << " [" << run.start << ":" << run.end << "]" << std::endl; #endif - double size = paint.size; + double size = ctx->paint.size; hb_font_set_ppem(hbFont, size, size); hb_font_set_scale(hbFont, HBFloatToFixed(size), HBFloatToFixed(size)); @@ -412,8 +644,8 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); hb_shape(hbFont, buffer, NULL, 0); unsigned int numGlyphs; - hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); - hb_glyph_position_t *positions = hb_buffer_get_glyph_positions(buffer, NULL); + hb_glyph_info_t* info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); + hb_glyph_position_t* positions = hb_buffer_get_glyph_positions(buffer, NULL); for (unsigned int i = 0; i < numGlyphs; i++) { #ifdef VERBOSE std::cout << positions[i].x_advance << " " << positions[i].y_advance << " " << positions[i].x_offset << " " << positions[i].y_offset << std::endl; std::cout << "DoLayout " << info[i].codepoint << @@ -426,7 +658,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t mGlyphs.push_back(glyph); float xAdvance = HBFixedToFloat(positions[i].x_advance); MinikinRect glyphBounds; - paint.font->GetBounds(&glyphBounds, glyph_ix, paint); + ctx->paint.font->GetBounds(&glyphBounds, glyph_ix, ctx->paint); glyphBounds.offset(x + xoff, y + yoff); mBounds.join(glyphBounds); size_t cluster = info[i].cluster; @@ -438,7 +670,33 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t mAdvance = x; } -void Layout::draw(Bitmap* surface, int x0, int y0) const { +void Layout::appendLayout(Layout* src, size_t start) { + // Note: size==1 is by far most common, should have specialized vector for this + std::vector fontMap; + for (size_t i = 0; i < src->mFaces.size(); i++) { + int font_ix = findFace(src->mFaces[i], NULL); + fontMap.push_back(font_ix); + } + int x0 = mAdvance; + for (size_t i = 0; i < src->mGlyphs.size(); i++) { + LayoutGlyph& srcGlyph = src->mGlyphs[i]; + int font_ix = fontMap[srcGlyph.font_ix]; + unsigned int glyph_id = srcGlyph.glyph_id; + float x = x0 + srcGlyph.x; + float y = srcGlyph.y; + LayoutGlyph glyph = {font_ix, glyph_id, x, y}; + mGlyphs.push_back(glyph); + } + for (size_t i = 0; i < src->mAdvances.size(); i++) { + mAdvances[i + start] = src->mAdvances[i]; + } + MinikinRect srcBounds(src->mBounds); + srcBounds.offset(x0, 0); + mBounds.join(srcBounds); + mAdvance += src->mAdvance; +} + +void Layout::draw(Bitmap* surface, int x0, int y0, float size) const { /* TODO: redo as MinikinPaint settings if (mProps.hasTag(minikinHinting)) { @@ -449,11 +707,11 @@ void Layout::draw(Bitmap* surface, int x0, int y0) const { */ for (size_t i = 0; i < mGlyphs.size(); i++) { const LayoutGlyph& glyph = mGlyphs[i]; - MinikinFont *mf = mFaces[glyph.font_ix]; - MinikinFontFreeType *face = static_cast(mf); + MinikinFont* mf = mFaces[glyph.font_ix]; + MinikinFontFreeType* face = static_cast(mf); GlyphBitmap glyphBitmap; MinikinPaint paint; - paint.size = mProps.value(fontSize).getFloatValue(); + paint.size = size; bool ok = face->Render(glyph.glyph_id, paint, &glyphBitmap); printf("glyphBitmap.width=%d, glyphBitmap.height=%d (%d, %d) x=%f, y=%f, ok=%d\n", glyphBitmap.width, glyphBitmap.height, glyphBitmap.left, glyphBitmap.top, glyph.x, glyph.y, ok); @@ -464,15 +722,15 @@ void Layout::draw(Bitmap* surface, int x0, int y0) const { } } -void Layout::setProperties(string css) { - mProps.parse(css); +void Layout::setProperties(const string& css) { + mCssString = css; } size_t Layout::nGlyphs() const { return mGlyphs.size(); } -MinikinFont *Layout::getFont(int i) const { +MinikinFont* Layout::getFont(int i) const { const LayoutGlyph& glyph = mGlyphs[i]; return mFaces[glyph.font_ix]; } diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index 9b012ef086..b8bd66f4be 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -89,7 +89,7 @@ int runMinikinTest() { layout.doLayout(icuText.getBuffer(), icuText.length()); layout.dump(); Bitmap bitmap(250, 50); - layout.draw(&bitmap, 10, 40); + layout.draw(&bitmap, 10, 40, 32); std::ofstream o; o.open("/data/local/tmp/foo.pgm", std::ios::out | std::ios::binary); bitmap.writePnm(o); From b1f16e880b39439054918774f8e53da2d4d0a133 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Fri, 23 May 2014 22:44:35 -0700 Subject: [PATCH 018/364] Fix native crash in Latin-1 typefaces This is a fix for bug 15171911 Timely crashes (native crash in libminikin) when I go to add a new alarm This patch fixes an off-by-one error that caused typefaces with only one page of Unicode coverage (ASCII or Latin-1) to have nPages = 0 instead of the correct value of 1 in the corresponding FontCollection. Change-Id: Id8be0c9e5713b8af22d863992921ee6382416a34 --- engine/src/flutter/libs/minikin/FontCollection.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index cd7b19e009..8919dc1a5e 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -66,7 +66,7 @@ FontCollection::FontCollection(const vector& typefaces) : mMaxChar = max(mMaxChar, instance->mCoverage->length()); lastChar.push_back(instance->mCoverage->nextSetBit(0)); } - size_t nPages = mMaxChar >> kLogCharsPerPage; + size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage; size_t offset = 0; for (size_t i = 0; i < nPages; i++) { Range dummy; From 5261296f2aa237df758c0491ec3acc373132b83b Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 19 May 2014 11:58:20 -0700 Subject: [PATCH 019/364] Do BiDi algorithm for text layout This is a fix for bug 15130102 "Language name for Hebrew displayed the wrong way around on keyboard". This patch extends the previous BiDi support (when the direction for the entire string was given by the caller) to run the BiDi algorithm (provided by ICU) over the string to break it into BiDi runs. Thus, it handles mixed LTR and RTL strings in a single layout, and also respects heuristics for inferring the paragraph direction from the string. Change-Id: Ia4b869de3c139c5a7d16b8ce7766870b98a815ea (cherry picked from commit 4b3a941128454e55893d65433a835e78a9e9781d) --- engine/src/flutter/include/minikin/Layout.h | 4 + engine/src/flutter/libs/minikin/Android.mk | 3 +- engine/src/flutter/libs/minikin/Layout.cpp | 88 ++++++++++++++++++--- 3 files changed, 85 insertions(+), 10 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 4fe9d8772f..6c338db280 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -94,6 +94,10 @@ private: // Find a face in the mFaces vector, or create a new entry int findFace(MinikinFont* face, MinikinPaint* paint); + // Lay out a single bidi run + void doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, FontStyle style, MinikinPaint& paint); + CssProperties mProps; // TODO: want spans std::vector mGlyphs; std::vector mAdvances; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index c4412859c4..f1f035497a 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -43,6 +43,7 @@ LOCAL_SHARED_LIBRARIES := \ liblog \ libpng \ libz \ - libstlport + libstlport \ + libicuuc include $(BUILD_SHARED_LIBRARY) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index f32e9f4e4f..918bc2e87d 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -39,6 +39,21 @@ namespace android { // TODO: globals are not cool, move to a factory-ish object hb_buffer_t* buffer = 0; +// TODO: these should move into the header file, but for now we don't want +// to cause namespace collisions with TextLayout.h +enum { + kBidi_LTR = 0, + kBidi_RTL = 1, + kBidi_Default_LTR = 2, + kBidi_Default_RTL = 3, + kBidi_Force_LTR = 4, + kBidi_Force_RTL = 5, + + kBidi_Mask = 0x7 +}; + +const int kDirection_Mask = 0x1; + Bitmap::Bitmap(int width, int height) : width(width), height(height) { buf = new uint8_t[width * height](); } @@ -291,18 +306,14 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { } FT_Error error; - vector items; FontStyle style = styleFromCss(mProps); - mCollection->itemize(buf, nchars, style, &items); MinikinPaint paint; double size = mProps.value(fontSize).getFloatValue(); paint.size = size; int bidiFlags = mProps.hasTag(minikinBidi) ? mProps.value(minikinBidi).getIntValue() : 0; - bool isRtl = (bidiFlags & 1) != 0; // TODO: do real bidi algo - if (isRtl) { - std::reverse(items.begin(), items.end()); - } + bool isRtl = (bidiFlags & kDirection_Mask) != 0; + bool doSingleRun = true; mGlyphs.clear(); mFaces.clear(); @@ -310,7 +321,65 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { mBounds.setEmpty(); mAdvances.clear(); mAdvances.resize(nchars, 0); - float x = 0; + mAdvance = 0; + if (!(bidiFlags == kBidi_Force_LTR || bidiFlags == kBidi_Force_RTL)) { + UBiDi* bidi = ubidi_open(); + if (bidi) { + UErrorCode status = U_ZERO_ERROR; + UBiDiLevel bidiReq = bidiFlags; + if (bidiFlags == kBidi_Default_LTR) { + bidiReq = UBIDI_DEFAULT_LTR; + } else if (bidiFlags == kBidi_Default_RTL) { + bidiReq = UBIDI_DEFAULT_RTL; + } + ubidi_setPara(bidi, buf, nchars, bidiReq, NULL, &status); + if (U_SUCCESS(status)) { + int paraDir = ubidi_getParaLevel(bidi) & kDirection_Mask; + ssize_t rc = ubidi_countRuns(bidi, &status); + if (!U_SUCCESS(status) || rc < 1) { + ALOGD("error counting bidi runs, status = %d", status); + } + if (!U_SUCCESS(status) || rc <= 1) { + isRtl = (paraDir == kBidi_RTL); + } else { + doSingleRun = false; + // iterate through runs + for (ssize_t i = 0; i < (ssize_t)rc; i++) { + int32_t startRun = -1; + int32_t lengthRun = -1; + UBiDiDirection runDir = ubidi_getVisualRun(bidi, i, &startRun, &lengthRun); + if (startRun == -1 || lengthRun == -1) { + ALOGE("invalid visual run"); + // Note: this case will lose text; can it ever actually happen? + break; + } + isRtl = (runDir == UBIDI_RTL); + // TODO: min/max with context + doLayoutRun(buf, startRun, lengthRun, nchars, isRtl, style, paint); + } + } + } else { + ALOGE("error calling ubidi_setPara, status = %d", status); + } + ubidi_close(bidi); + } else { + ALOGE("error creating bidi object"); + } + } + if (doSingleRun) { + doLayoutRun(buf, 0, nchars, nchars, isRtl, style, paint); + } +} + +void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, FontStyle style, MinikinPaint& paint) { + vector items; + mCollection->itemize(buf + start, count, style, &items); + if (isRtl) { + std::reverse(items.begin(), items.end()); + } + + float x = mAdvance; float y = 0; for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { FontCollection::Run &run = items[run_ix]; @@ -325,6 +394,7 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { std::cout << "Run " << run_ix << ", font " << font_ix << " [" << run.start << ":" << run.end << "]" << std::endl; #endif + double size = paint.size; hb_font_set_ppem(hbFont, size, size); hb_font_set_scale(hbFont, HBFloatToFixed(size), HBFloatToFixed(size)); @@ -334,12 +404,12 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { ssize_t srunend; for (ssize_t srunstart = run.start; srunstart < run.end; srunstart = srunend) { srunend = srunstart; - hb_script_t script = getScriptRun(buf, run.end, &srunend); + hb_script_t script = getScriptRun(buf + start, run.end, &srunend); hb_buffer_reset(buffer); hb_buffer_set_script(buffer, script); hb_buffer_set_direction(buffer, isRtl? HB_DIRECTION_RTL : HB_DIRECTION_LTR); - hb_buffer_add_utf16(buffer, buf, nchars, srunstart, srunend - srunstart); + hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); hb_shape(hbFont, buffer, NULL, 0); unsigned int numGlyphs; hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); From ddfa014d55c11da8e73580b639917f2e2a441add Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 21 May 2014 08:37:49 -0700 Subject: [PATCH 020/364] Caching for layouts and harfbuzz faces This patch adds caching for both layouts and for HarfBuzz face objects. The granularity of the cache for layouts is words, so it splits the input string at word boundaries (using a heuristic). There are is also some refactoring to reduce the amount of allocation and copying, and movement towards properly supporting contexts. The size of the caches is a fixed number of entries; thus, it is possible to consume a large amount of memory by filling the cache with lots of large strings. This should be refined towards a scheme that bounds the total memory used by the cache. This patch fixes bug 15237293 "Regression: Measure performance is significantly slower with minikin". Change-Id: Ie8176857e2d78656ce5479a7c04969819ef2718d --- .../flutter/include/minikin/FontCollection.h | 11 +- .../src/flutter/include/minikin/FontFamily.h | 14 +- engine/src/flutter/include/minikin/Layout.h | 41 +- .../src/flutter/include/minikin/MinikinFont.h | 1 + engine/src/flutter/libs/minikin/Android.mk | 3 +- .../flutter/libs/minikin/FontCollection.cpp | 13 + engine/src/flutter/libs/minikin/Layout.cpp | 388 +++++++++++++++--- engine/src/flutter/sample/example.cpp | 2 +- 8 files changed, 390 insertions(+), 83 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index dc48f8e0a2..c6c2ed05b0 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -54,9 +54,12 @@ public: int start; int end; }; + void itemize(const uint16_t *string, size_t string_length, FontStyle style, std::vector* result) const; - private: + + uint32_t getId() const; +private: static const int kLogCharsPerPage = 8; static const int kPageMask = (1 << kLogCharsPerPage) - 1; @@ -70,6 +73,12 @@ public: size_t end; }; + // static for allocating unique id's + static uint32_t sNextId; + + // unique id for this font collection (suitable for cache key) + uint32_t mId; + // Highest UTF-32 code point that can be mapped uint32_t mMaxChar; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 82fcfe9af8..a4fe9cb9e4 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -19,6 +19,8 @@ #include +#include + #include namespace android { @@ -31,16 +33,22 @@ public: FontStyle(int weight = 4, bool italic = false) { bits = (weight & kWeightMask) | (italic ? kItalicMask : 0); } - int getWeight() { return bits & kWeightMask; } - bool getItalic() { return (bits & kItalicMask) != 0; } - bool operator==(const FontStyle other) { return bits == other.bits; } + int getWeight() const { return bits & kWeightMask; } + bool getItalic() const { return (bits & kItalicMask) != 0; } + bool operator==(const FontStyle other) const { return bits == other.bits; } // TODO: language, variant + + hash_t hash() const { return bits; } private: static const int kWeightMask = 0xf; static const int kItalicMask = 16; uint32_t bits; }; +inline hash_t hash_type(const FontStyle &style) { + return style.hash(); +} + class FontFamily : public MinikinRefCounted { public: ~FontFamily(); diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 6c338db280..a1ef0c13b8 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -55,6 +55,9 @@ struct LayoutGlyph { float y; }; +// Internal state used during layout operation +class LayoutContext; + // Lifecycle and threading assumptions for Layout: // The object is assumed to be owned by a single thread; multiple threads // may not mutate it at the same time. @@ -62,13 +65,19 @@ struct LayoutGlyph { // extend through the lifetime of the Layout object. class Layout { public: - ~Layout(); - void dump() const; void setFontCollection(const FontCollection* collection); + + // deprecated - missing functionality void doLayout(const uint16_t* buf, size_t nchars); - void draw(Bitmap*, int x0, int y0) const; - void setProperties(const std::string css); + + void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + const std::string& css); + + void draw(Bitmap*, int x0, int y0, float size) const; + + // deprecated - pass as argument to doLayout instead + void setProperties(const std::string& css); // This must be called before any invocations. // TODO: probably have a factory instead @@ -92,23 +101,31 @@ public: private: // Find a face in the mFaces vector, or create a new entry - int findFace(MinikinFont* face, MinikinPaint* paint); + int findFace(MinikinFont* face, LayoutContext* ctx); + + // Lay out a single bidi run + void doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, LayoutContext* ctx); + + // Lay out a single word + void doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, LayoutContext* ctx, size_t bufStart); // Lay out a single bidi run void doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, FontStyle style, MinikinPaint& paint); + bool isRtl, LayoutContext* ctx); + + // Append another layout (for example, cached value) into this one + void appendLayout(Layout* src, size_t start); + + // deprecated - remove when setProperties is removed + std::string mCssString; - CssProperties mProps; // TODO: want spans std::vector mGlyphs; std::vector mAdvances; - // In future, this will be some kind of mapping from the - // identifier used to represent font-family to a font collection. - // But for the time being, it should be ok to have just one - // per layout. const FontCollection* mCollection; std::vector mFaces; - std::vector mHbFonts; float mAdvance; MinikinRect mBounds; }; diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 568f19da7f..dbb89f8331 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -27,6 +27,7 @@ namespace android { class MinikinFont; // Possibly move into own .h file? +// Note: if you add a field here, also update LayoutCacheKey struct MinikinPaint { MinikinFont *font; float size; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index f1f035497a..a1d88c29e5 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -44,6 +44,7 @@ LOCAL_SHARED_LIBRARIES := \ libpng \ libz \ libstlport \ - libicuuc + libicuuc \ + libutils include $(BUILD_SHARED_LIBRARY) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 8919dc1a5e..e6ff117ad7 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -32,9 +32,12 @@ static inline T max(T a, T b) { return a>b ? a : b; } +uint32_t FontCollection::sNextId = 0; + FontCollection::FontCollection(const vector& typefaces) : mMaxChar(0) { AutoMutex _l(gMinikinLock); + mId = sNextId++; vector lastChar; size_t nTypefaces = typefaces.size(); #ifdef VERBOSE_DEBUG @@ -50,6 +53,12 @@ FontCollection::FontCollection(const vector& typefaces) : instance->mFamily = family; instance->mCoverage = new SparseBitSet; MinikinFont* typeface = family->getClosestMatch(defaultStyle); + if (typeface == NULL) { + ALOGE("FontCollection: closest match was null"); + // TODO: we shouldn't hit this, as there should be more robust + // checks upstream to prevent empty/invalid FontFamily objects + continue; + } #ifdef VERBOSE_DEBUG ALOGD("closest match = %p, family size = %d\n", typeface, family->getNumFonts()); #endif @@ -149,4 +158,8 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } } +uint32_t FontCollection::getId() const { + return mId; +} + } // namespace android diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 918bc2e87d..886b7d1f1c 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -24,6 +24,11 @@ #include // for debugging #include // ditto +#include +#include +#include +#include + #include #include @@ -36,9 +41,6 @@ using std::vector; namespace android { -// TODO: globals are not cool, move to a factory-ish object -hb_buffer_t* buffer = 0; - // TODO: these should move into the header file, but for now we don't want // to cause namespace collisions with TextLayout.h enum { @@ -54,6 +56,114 @@ enum { const int kDirection_Mask = 0x1; +// Layout cache datatypes + +class LayoutCacheKey { +public: + LayoutCacheKey(const FontCollection* collection, const MinikinPaint& paint, FontStyle style, + const uint16_t* chars, size_t start, size_t count, size_t nchars, bool dir) + : mStart(start), mCount(count), mId(collection->getId()), mStyle(style), + mSize(paint.size), mIsRtl(dir) { + mText.setTo(chars, nchars); + } + bool operator==(const LayoutCacheKey &other) const; + hash_t hash() const; + + // This is present to avoid having to copy the text more than once. + const uint16_t* textBuf() { return mText.string(); } +private: + String16 mText; + size_t mStart; + size_t mCount; + uint32_t mId; // for the font collection + FontStyle mStyle; + float mSize; + bool mIsRtl; + // Note: any fields added to MinikinPaint must also be reflected here. + // TODO: language matching (possibly integrate into style) +}; + +class LayoutCache : private OnEntryRemoved { +public: + LayoutCache() : mCache(kMaxEntries) { + mCache.setOnEntryRemovedListener(this); + } + + // callback for OnEntryRemoved + void operator()(LayoutCacheKey& key, Layout*& value) { + delete value; + } + + LruCache mCache; +private: + //static const size_t kMaxEntries = LruCache::kUnlimitedCapacity; + + // TODO: eviction based on memory footprint; for now, we just use a constant + // number of strings + static const size_t kMaxEntries = 5000; +}; + +class HbFaceCache : private OnEntryRemoved { +public: + HbFaceCache() : mCache(kMaxEntries) { + mCache.setOnEntryRemovedListener(this); + } + + // callback for OnEntryRemoved + void operator()(int32_t& key, hb_face_t*& value) { + hb_face_destroy(value); + } + + LruCache mCache; +private: + static const size_t kMaxEntries = 100; +}; + +class LayoutEngine : public Singleton { +public: + LayoutEngine() { + hbBuffer = hb_buffer_create(); + } + + hb_buffer_t* hbBuffer; + LayoutCache layoutCache; + HbFaceCache hbFaceCache; +}; + +ANDROID_SINGLETON_STATIC_INSTANCE(LayoutEngine); + +bool LayoutCacheKey::operator==(const LayoutCacheKey& other) const { + return mId == other.mId && + mStart == other.mStart && + mCount == other.mCount && + mStyle == other.mStyle && + mSize == other.mSize && + mIsRtl == other.mIsRtl && + mText == other.mText; +} + +hash_t LayoutCacheKey::hash() const { + uint32_t hash = JenkinsHashMix(0, mId); + hash = JenkinsHashMix(hash, mStart); + hash = JenkinsHashMix(hash, mCount); + hash = JenkinsHashMix(hash, hash_type(mStyle)); + hash = JenkinsHashMix(hash, hash_type(mSize)); + hash = JenkinsHashMix(hash, hash_type(mIsRtl)); + hash = JenkinsHashMixShorts(hash, mText.string(), mText.size()); + return JenkinsHashWhiten(hash); +} + +struct LayoutContext { + MinikinPaint paint; + FontStyle style; + CssProperties props; + std::vector hbFonts; // parallel to mFaces +}; + +hash_t hash_type(const LayoutCacheKey& key) { + return key.hash(); +} + Bitmap::Bitmap(int width, int height) : width(width), height(height) { buf = new uint8_t[width * height](); } @@ -107,18 +217,18 @@ void MinikinRect::join(const MinikinRect& r) { void Layout::init() { } -void Layout::setFontCollection(const FontCollection *collection) { +void Layout::setFontCollection(const FontCollection* collection) { mCollection = collection; } hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { - MinikinFont* font = reinterpret_cast(userData); + MinikinFont* font = reinterpret_cast(userData); size_t length = 0; bool ok = font->GetTable(tag, NULL, &length); if (!ok) { return 0; } - char *buffer = reinterpret_cast(malloc(length)); + char* buffer = reinterpret_cast(malloc(length)); if (!buffer) { return 0; } @@ -135,7 +245,7 @@ hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { static hb_bool_t harfbuzzGetGlyph(hb_font_t* hbFont, void* fontData, hb_codepoint_t unicode, hb_codepoint_t variationSelector, hb_codepoint_t* glyph, void* userData) { - MinikinPaint* paint = reinterpret_cast(fontData); + MinikinPaint* paint = reinterpret_cast(fontData); MinikinFont* font = paint->font; uint32_t glyph_id; bool ok = font->GetGlyph(unicode, &glyph_id); @@ -147,7 +257,7 @@ static hb_bool_t harfbuzzGetGlyph(hb_font_t* hbFont, void* fontData, hb_codepoin static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, void* userData) { - MinikinPaint* paint = reinterpret_cast(fontData); + MinikinPaint* paint = reinterpret_cast(fontData); MinikinFont* font = paint->font; float advance = font->GetHorizontalAdvance(glyph, *paint); return 256 * advance + 0.5; @@ -173,12 +283,21 @@ hb_font_funcs_t* getHbFontFuncs() { return hbFontFuncs; } -hb_font_t* create_hb_font(MinikinFont* minikinFont, MinikinPaint* minikinPaint) { - hb_face_t* face = hb_face_create_for_tables(referenceTable, minikinFont, NULL); +static hb_face_t* getHbFace(MinikinFont* minikinFont) { + HbFaceCache& cache = LayoutEngine::getInstance().hbFaceCache; + int32_t fontId = minikinFont->GetUniqueId(); + hb_face_t* face = cache.mCache.get(fontId); + if (face == NULL) { + face = hb_face_create_for_tables(referenceTable, minikinFont, NULL); + cache.mCache.put(fontId, face); + } + return face; +} + +static hb_font_t* create_hb_font(MinikinFont* minikinFont, MinikinPaint* minikinPaint) { + hb_face_t* face = getHbFace(minikinFont); hb_font_t* font = hb_font_create(face); - hb_face_destroy(face); hb_font_set_funcs(font, getHbFontFuncs(), minikinPaint, 0); - // TODO: manage ownership of face return font; } @@ -192,12 +311,6 @@ static hb_position_t HBFloatToFixed(float v) return scalbnf (v, +8); } -Layout::~Layout() { - for (size_t ix = 0; ix < mHbFonts.size(); ix++) { - hb_font_destroy(mHbFonts[ix]); - } -} - void Layout::dump() const { for (size_t i = 0; i < mGlyphs.size(); i++) { const LayoutGlyph& glyph = mGlyphs[i]; @@ -205,11 +318,7 @@ void Layout::dump() const { } } -// A couple of things probably need to change: -// 1. Deal with multiple sizes in a layout -// 2. We'll probably store FT_Face as primary and then use a cache -// for the hb fonts -int Layout::findFace(MinikinFont* face, MinikinPaint* paint) { +int Layout::findFace(MinikinFont* face, LayoutContext* ctx) { unsigned int ix; for (ix = 0; ix < mFaces.size(); ix++) { if (mFaces[ix] == face) { @@ -217,8 +326,12 @@ int Layout::findFace(MinikinFont* face, MinikinPaint* paint) { } } mFaces.push_back(face); - hb_font_t *font = create_hb_font(face, paint); - mHbFonts.push_back(font); + // Note: ctx == NULL means we're copying from the cache, no need to create + // corresponding hb_font object. + if (ctx != NULL) { + hb_font_t* font = create_hb_font(face, &ctx->paint); + ctx->hbFonts.push_back(font); + } return ix; } @@ -235,14 +348,14 @@ static FontStyle styleFromCss(const CssProperties &props) { } static hb_script_t codePointToScript(hb_codepoint_t codepoint) { - static hb_unicode_funcs_t *u = 0; + static hb_unicode_funcs_t* u = 0; if (!u) { u = hb_icu_get_unicode_funcs(); } return hb_unicode_script(u, codepoint); } -static hb_codepoint_t decodeUtf16(const uint16_t *chars, size_t len, ssize_t *iter) { +static hb_codepoint_t decodeUtf16(const uint16_t* chars, size_t len, ssize_t* iter) { const uint16_t v = chars[(*iter)++]; // test whether v in (0xd800..0xdfff), lead or trail surrogate if ((v & 0xf800) == 0xd800) { @@ -266,7 +379,7 @@ static hb_codepoint_t decodeUtf16(const uint16_t *chars, size_t len, ssize_t *it } } -static hb_script_t getScriptRun(const uint16_t *chars, size_t len, ssize_t *iter) { +static hb_script_t getScriptRun(const uint16_t* chars, size_t len, ssize_t* iter) { if (size_t(*iter) == len) { return HB_SCRIPT_UNKNOWN; } @@ -298,29 +411,99 @@ static hb_script_t getScriptRun(const uint16_t *chars, size_t len, ssize_t *iter return current_script; } -// TODO: API should probably take context -void Layout::doLayout(const uint16_t* buf, size_t nchars) { - AutoMutex _l(gMinikinLock); - if (buffer == 0) { - buffer = hb_buffer_create(); +/** + * For the purpose of layout, a word break is a boundary with no + * kerning or complex script processing. This is necessarily a + * heuristic, but should be accurate most of the time. + */ +static bool isWordBreak(int c) { + if (c == ' ' || (c >= 0x2000 && c <= 0x200a) || c == 0x3000) { + // spaces + return true; } - FT_Error error; + if ((c >= 0x3400 && c <= 0x9fff)) { + // CJK ideographs (and yijing hexagram symbols) + return true; + } + // Note: kana is not included, as sophisticated fonts may kern kana + return false; +} - FontStyle style = styleFromCss(mProps); +/** + * Return offset of previous word break. It is either < offset or == 0. + */ +static size_t getPrevWordBreak(const uint16_t* chars, size_t offset) { + if (offset == 0) return 0; + if (isWordBreak(chars[offset - 1])) { + return offset - 1; + } + for (size_t i = offset - 1; i > 0; i--) { + if (isWordBreak(chars[i - 1])) { + return i; + } + } + return 0; +} - MinikinPaint paint; - double size = mProps.value(fontSize).getFloatValue(); - paint.size = size; - int bidiFlags = mProps.hasTag(minikinBidi) ? mProps.value(minikinBidi).getIntValue() : 0; +/** + * Return offset of next word break. It is either > offset or == len. + */ +static size_t getNextWordBreak(const uint16_t* chars, size_t offset, size_t len) { + if (offset >= len) return len; + if (isWordBreak(chars[offset])) { + return offset + 1; + } + for (size_t i = offset + 1; i < len; i++) { + if (isWordBreak(chars[i])) { + return i; + } + } + return len; +} + +// deprecated API, to avoid breaking client +void Layout::doLayout(const uint16_t* buf, size_t nchars) { + doLayout(buf, 0, nchars, nchars, mCssString); +} + +// TODO: use some standard implementation +template +static T mymin(const T& a, const T& b) { + return a < b ? a : b; +} + +template +static T mymax(const T& a, const T& b) { + return a > b ? a : b; +} + +static void clearHbFonts(LayoutContext* ctx) { + for (size_t i = 0; i < ctx->hbFonts.size(); i++) { + hb_font_destroy(ctx->hbFonts[i]); + } + ctx->hbFonts.clear(); +} + +// TODO: API should probably take context +void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + const std::string& css) { + AutoMutex _l(gMinikinLock); + LayoutContext ctx; + + ctx.props.parse(css); + ctx.style = styleFromCss(ctx.props); + + double size = ctx.props.value(fontSize).getFloatValue(); + ctx.paint.size = size; + int bidiFlags = ctx.props.hasTag(minikinBidi) ? ctx.props.value(minikinBidi).getIntValue() : 0; bool isRtl = (bidiFlags & kDirection_Mask) != 0; bool doSingleRun = true; mGlyphs.clear(); mFaces.clear(); - mHbFonts.clear(); mBounds.setEmpty(); mAdvances.clear(); - mAdvances.resize(nchars, 0); + mAdvances.resize(count, 0); mAdvance = 0; if (!(bidiFlags == kBidi_Force_LTR || bidiFlags == kBidi_Force_RTL)) { UBiDi* bidi = ubidi_open(); @@ -332,12 +515,12 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { } else if (bidiFlags == kBidi_Default_RTL) { bidiReq = UBIDI_DEFAULT_RTL; } - ubidi_setPara(bidi, buf, nchars, bidiReq, NULL, &status); + ubidi_setPara(bidi, buf, bufSize, bidiReq, NULL, &status); if (U_SUCCESS(status)) { int paraDir = ubidi_getParaLevel(bidi) & kDirection_Mask; ssize_t rc = ubidi_countRuns(bidi, &status); - if (!U_SUCCESS(status) || rc < 1) { - ALOGD("error counting bidi runs, status = %d", status); + if (!U_SUCCESS(status) || rc < 0) { + ALOGW("error counting bidi runs, status = %d", status); } if (!U_SUCCESS(status) || rc <= 1) { isRtl = (paraDir == kBidi_RTL); @@ -350,12 +533,12 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { UBiDiDirection runDir = ubidi_getVisualRun(bidi, i, &startRun, &lengthRun); if (startRun == -1 || lengthRun == -1) { ALOGE("invalid visual run"); - // Note: this case will lose text; can it ever actually happen? - break; + // skip the invalid run + continue; } isRtl = (runDir == UBIDI_RTL); // TODO: min/max with context - doLayoutRun(buf, startRun, lengthRun, nchars, isRtl, style, paint); + doLayoutRunCached(buf, startRun, lengthRun, bufSize, isRtl, &ctx); } } } else { @@ -367,14 +550,63 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { } } if (doSingleRun) { - doLayoutRun(buf, 0, nchars, nchars, isRtl, style, paint); + doLayoutRunCached(buf, start, count, bufSize, isRtl, &ctx); + } + clearHbFonts(&ctx); +} + +void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, LayoutContext* ctx) { + if (!isRtl) { + // left to right + size_t wordstart = start == bufSize ? start : getPrevWordBreak(buf, start + 1); + size_t wordend; + for (size_t iter = start; iter < start + count; iter = wordend) { + wordend = getNextWordBreak(buf, iter, bufSize); + size_t wordcount = mymin(start + count, wordend) - iter; + doLayoutWord(buf + wordstart, iter - wordstart, wordcount, wordend - wordstart, + isRtl, ctx, iter); + wordstart = wordend; + } + } else { + // right to left + size_t wordstart; + size_t end = start + count; + size_t wordend = end == 0 ? 0 : getNextWordBreak(buf, end - 1, bufSize); + for (size_t iter = end; iter > start; iter = wordstart) { + wordstart = getPrevWordBreak(buf, iter); + size_t bufStart = mymax(start, wordstart); + doLayoutWord(buf + wordstart, bufStart - wordstart, iter - bufStart, + wordend - wordstart, isRtl, ctx, bufStart); + wordend = wordstart; + } } } +void Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, LayoutContext* ctx, size_t bufStart) { + LayoutCache& cache = LayoutEngine::getInstance().layoutCache; + LayoutCacheKey key(mCollection, ctx->paint, ctx->style, buf, start, count, bufSize, isRtl); + Layout* value = cache.mCache.get(key); + if (value == NULL) { + value = new Layout(); + value->setFontCollection(mCollection); + value->mAdvances.resize(count, 0); + clearHbFonts(ctx); + // Note: we do the layout from the copy stored in the key, in case a + // badly-behaved client is mutating the buffer in a separate thread. + value->doLayoutRun(key.textBuf(), start, count, bufSize, isRtl, ctx); + } + appendLayout(value, bufStart); + cache.mCache.put(key, value); + +} + void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, FontStyle style, MinikinPaint& paint) { + bool isRtl, LayoutContext* ctx) { + hb_buffer_t* buffer = LayoutEngine::getInstance().hbBuffer; vector items; - mCollection->itemize(buf + start, count, style, &items); + mCollection->itemize(buf + start, count, ctx->style, &items); if (isRtl) { std::reverse(items.begin(), items.end()); } @@ -383,10 +615,10 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t float y = 0; for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { FontCollection::Run &run = items[run_ix]; - int font_ix = findFace(run.font, &paint); - paint.font = mFaces[font_ix]; - hb_font_t *hbFont = mHbFonts[font_ix]; - if (paint.font == NULL) { + int font_ix = findFace(run.font, ctx); + ctx->paint.font = mFaces[font_ix]; + hb_font_t* hbFont = ctx->hbFonts[font_ix]; + if (ctx->paint.font == NULL) { // TODO: should log what went wrong continue; } @@ -394,7 +626,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t std::cout << "Run " << run_ix << ", font " << font_ix << " [" << run.start << ":" << run.end << "]" << std::endl; #endif - double size = paint.size; + double size = ctx->paint.size; hb_font_set_ppem(hbFont, size, size); hb_font_set_scale(hbFont, HBFloatToFixed(size), HBFloatToFixed(size)); @@ -412,8 +644,8 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); hb_shape(hbFont, buffer, NULL, 0); unsigned int numGlyphs; - hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); - hb_glyph_position_t *positions = hb_buffer_get_glyph_positions(buffer, NULL); + hb_glyph_info_t* info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); + hb_glyph_position_t* positions = hb_buffer_get_glyph_positions(buffer, NULL); for (unsigned int i = 0; i < numGlyphs; i++) { #ifdef VERBOSE std::cout << positions[i].x_advance << " " << positions[i].y_advance << " " << positions[i].x_offset << " " << positions[i].y_offset << std::endl; std::cout << "DoLayout " << info[i].codepoint << @@ -426,7 +658,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t mGlyphs.push_back(glyph); float xAdvance = HBFixedToFloat(positions[i].x_advance); MinikinRect glyphBounds; - paint.font->GetBounds(&glyphBounds, glyph_ix, paint); + ctx->paint.font->GetBounds(&glyphBounds, glyph_ix, ctx->paint); glyphBounds.offset(x + xoff, y + yoff); mBounds.join(glyphBounds); size_t cluster = info[i].cluster; @@ -438,7 +670,33 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t mAdvance = x; } -void Layout::draw(Bitmap* surface, int x0, int y0) const { +void Layout::appendLayout(Layout* src, size_t start) { + // Note: size==1 is by far most common, should have specialized vector for this + std::vector fontMap; + for (size_t i = 0; i < src->mFaces.size(); i++) { + int font_ix = findFace(src->mFaces[i], NULL); + fontMap.push_back(font_ix); + } + int x0 = mAdvance; + for (size_t i = 0; i < src->mGlyphs.size(); i++) { + LayoutGlyph& srcGlyph = src->mGlyphs[i]; + int font_ix = fontMap[srcGlyph.font_ix]; + unsigned int glyph_id = srcGlyph.glyph_id; + float x = x0 + srcGlyph.x; + float y = srcGlyph.y; + LayoutGlyph glyph = {font_ix, glyph_id, x, y}; + mGlyphs.push_back(glyph); + } + for (size_t i = 0; i < src->mAdvances.size(); i++) { + mAdvances[i + start] = src->mAdvances[i]; + } + MinikinRect srcBounds(src->mBounds); + srcBounds.offset(x0, 0); + mBounds.join(srcBounds); + mAdvance += src->mAdvance; +} + +void Layout::draw(Bitmap* surface, int x0, int y0, float size) const { /* TODO: redo as MinikinPaint settings if (mProps.hasTag(minikinHinting)) { @@ -449,11 +707,11 @@ void Layout::draw(Bitmap* surface, int x0, int y0) const { */ for (size_t i = 0; i < mGlyphs.size(); i++) { const LayoutGlyph& glyph = mGlyphs[i]; - MinikinFont *mf = mFaces[glyph.font_ix]; - MinikinFontFreeType *face = static_cast(mf); + MinikinFont* mf = mFaces[glyph.font_ix]; + MinikinFontFreeType* face = static_cast(mf); GlyphBitmap glyphBitmap; MinikinPaint paint; - paint.size = mProps.value(fontSize).getFloatValue(); + paint.size = size; bool ok = face->Render(glyph.glyph_id, paint, &glyphBitmap); printf("glyphBitmap.width=%d, glyphBitmap.height=%d (%d, %d) x=%f, y=%f, ok=%d\n", glyphBitmap.width, glyphBitmap.height, glyphBitmap.left, glyphBitmap.top, glyph.x, glyph.y, ok); @@ -464,15 +722,15 @@ void Layout::draw(Bitmap* surface, int x0, int y0) const { } } -void Layout::setProperties(string css) { - mProps.parse(css); +void Layout::setProperties(const string& css) { + mCssString = css; } size_t Layout::nGlyphs() const { return mGlyphs.size(); } -MinikinFont *Layout::getFont(int i) const { +MinikinFont* Layout::getFont(int i) const { const LayoutGlyph& glyph = mGlyphs[i]; return mFaces[glyph.font_ix]; } diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index 9b012ef086..b8bd66f4be 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -89,7 +89,7 @@ int runMinikinTest() { layout.doLayout(icuText.getBuffer(), icuText.length()); layout.dump(); Bitmap bitmap(250, 50); - layout.draw(&bitmap, 10, 40); + layout.draw(&bitmap, 10, 40, 32); std::ofstream o; o.open("/data/local/tmp/foo.pgm", std::ios::out | std::ios::binary); bitmap.writePnm(o); From 9c5d659d5fdfb149f786335f39b20e55c71d949b Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 26 May 2014 08:24:36 -0700 Subject: [PATCH 021/364] Fix for bug 15252902 native crash in Minikin This is a fix for bug 15252902 "Crash observed on keep launch or existing youtube app after playing video". It was doing the test for a null font after trying to resolve the font in a cache, which caused a crash when there was no font for the run. This patch just tests before cache lookup. Change-Id: Iee41f7ce6b69cb09438462b6aaa916f242da7b77 --- engine/src/flutter/libs/minikin/Layout.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 886b7d1f1c..3935eb761c 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -615,13 +615,13 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t float y = 0; for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { FontCollection::Run &run = items[run_ix]; + if (run.font == NULL) { + ALOGE("no font for run starting u+%04x length %d", buf[run.start], run.end - run.start); + continue; + } int font_ix = findFace(run.font, ctx); ctx->paint.font = mFaces[font_ix]; hb_font_t* hbFont = ctx->hbFonts[font_ix]; - if (ctx->paint.font == NULL) { - // TODO: should log what went wrong - continue; - } #ifdef VERBOSE std::cout << "Run " << run_ix << ", font " << font_ix << " [" << run.start << ":" << run.end << "]" << std::endl; From e1a0422aae785f6ed213ba0bb0139edc30502d7a Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 29 May 2014 14:01:18 -0700 Subject: [PATCH 022/364] Fix for Minikin native crash The context start offset wasn't being taken into account for accumulating the advance values, leading in some cases to array index overflow. This is a fix for bug 15327918 "SIGSEGV in android::MinikinFontSkia::GetSkTypeface()" Change-Id: I9b646785724c9b72d862b822cd84661c106fbe52 --- engine/src/flutter/libs/minikin/Layout.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 3935eb761c..aba8a1c7ab 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -661,7 +661,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t ctx->paint.font->GetBounds(&glyphBounds, glyph_ix, ctx->paint); glyphBounds.offset(x + xoff, y + yoff); mBounds.join(glyphBounds); - size_t cluster = info[i].cluster; + size_t cluster = info[i].cluster - start; mAdvances[cluster] += xAdvance; x += xAdvance; } From 7d4090fbe937014d79bb996c03e763d2557d238d Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Tue, 27 May 2014 08:05:51 -0700 Subject: [PATCH 023/364] Language and variant selection This patch adds a "lang" pseudo-CSS property and uses it both to select an appropriate font and control the "locl" OpenType feature to get the most appropriate rendering for the langauge and script. In addition, the "-minikin-variant" property selects between "compact" and "elegant" variants of a font, as the former is needed for vertically cramped spaces. This is part of the fix for bug 15179652 "Japanese font isn't shown on LMP". Change-Id: I7fab23c12d4c797a6d339a16e497b79a3afe9df1 --- engine/src/flutter/include/minikin/CssParse.h | 23 +++++-- .../flutter/include/minikin/FontCollection.h | 3 +- .../src/flutter/include/minikin/FontFamily.h | 61 ++++++++++++++++++- engine/src/flutter/libs/minikin/CssParse.cpp | 53 ++++++++++++++-- .../flutter/libs/minikin/FontCollection.cpp | 37 +++++++++-- .../src/flutter/libs/minikin/FontFamily.cpp | 41 +++++++++++++ engine/src/flutter/libs/minikin/Layout.cpp | 18 +++++- 7 files changed, 214 insertions(+), 22 deletions(-) diff --git a/engine/src/flutter/include/minikin/CssParse.h b/engine/src/flutter/include/minikin/CssParse.h index 2dceb4ac26..519056df57 100644 --- a/engine/src/flutter/include/minikin/CssParse.h +++ b/engine/src/flutter/include/minikin/CssParse.h @@ -25,26 +25,31 @@ namespace android { enum CssTag { unknown, fontSize, - fontWeight, fontStyle, - minikinHinting, + fontWeight, + cssLang, minikinBidi, + minikinHinting, + minikinVariant, }; const std::string cssTagNames[] = { "unknown", "font-size", - "font-weight", "font-style", - "-minikin-hinting", + "font-weight", + "lang", "-minikin-bidi", + "-minikin-hinting", + "-minikin-variant", }; class CssValue { public: enum Type { UNKNOWN, - FLOAT + FLOAT, + STRING }; enum Units { SCALAR, @@ -58,14 +63,20 @@ public: Type getType() const { return mType; } double getFloatValue() const { return floatValue; } int getIntValue() const { return floatValue; } + std::string getStringValue() const { return stringValue; } std::string toString(CssTag tag) const; void setFloatValue(double v) { mType = FLOAT; floatValue = v; } + void setStringValue(const std::string& v) { + mType = STRING; + stringValue = v; + } private: Type mType; double floatValue; + std::string stringValue; Units mUnits; }; @@ -85,4 +96,4 @@ private: } // namespace android -#endif // MINIKIN_CSS_PARSE_H \ No newline at end of file +#endif // MINIKIN_CSS_PARSE_H diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index c6c2ed05b0..a350237a3e 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -32,7 +32,8 @@ public: ~FontCollection(); - const FontFamily* getFamilyForChar(uint32_t ch) const; + const FontFamily* getFamilyForChar(uint32_t ch, FontLanguage lang, int variant) const; + class Run { public: // Do copy constructor, assignment, destructor so it can be used in vectors diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index a4fe9cb9e4..6bdf5d6376 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -25,6 +25,36 @@ namespace android { +class MinikinFont; + +// FontLanguage is a compact representation of a bcp-47 language tag. It +// does not capture all possible information, only what directly affects +// font rendering. +class FontLanguage { + friend class FontStyle; +public: + FontLanguage() : mBits(0) { } + + // Parse from string + FontLanguage(const char* buf, size_t size); + + bool operator==(const FontLanguage other) const { return mBits == other.mBits; } + + // 0 = no match, 1 = language matches, 2 = language and script match + int match(const FontLanguage other) const; + +private: + explicit FontLanguage(uint32_t bits) : mBits(bits) { } + + uint32_t bits() const { return mBits; } + + static const uint32_t kBaseLangMask = 0xffff; + static const uint32_t kScriptMask = (1 << 18) - (1 << 16); + static const uint32_t kHansFlag = 1 << 16; + static const uint32_t kHantFlag = 1 << 17; + uint32_t mBits; +}; + // FontStyle represents all style information needed to select an actual font // from a collection. The implementation is packed into a single 32-bit word // so it can be efficiently copied, embedded in other objects, etc. @@ -33,24 +63,44 @@ public: FontStyle(int weight = 4, bool italic = false) { bits = (weight & kWeightMask) | (italic ? kItalicMask : 0); } + FontStyle(FontLanguage lang, int variant = 0, int weight = 4, bool italic = false) { + bits = (weight & kWeightMask) | (italic ? kItalicMask : 0) + | (variant << kVariantShift) | (lang.bits() << kLangShift); + } int getWeight() const { return bits & kWeightMask; } bool getItalic() const { return (bits & kItalicMask) != 0; } + int getVariant() const { return (bits >> kVariantShift) & kVariantMask; } + FontLanguage getLanguage() const { return FontLanguage(bits >> kLangShift); } + bool operator==(const FontStyle other) const { return bits == other.bits; } - // TODO: language, variant hash_t hash() const { return bits; } private: - static const int kWeightMask = 0xf; - static const int kItalicMask = 16; + static const uint32_t kWeightMask = (1 << 4) - 1; + static const uint32_t kItalicMask = 1 << 4; + static const int kVariantShift = 5; + static const uint32_t kVariantMask = (1 << 2) - 1; + static const int kLangShift = 7; uint32_t bits; }; +enum FontVariant { + VARIANT_DEFAULT = 0, + VARIANT_COMPACT = 1, + VARIANT_ELEGANT = 2, +}; + inline hash_t hash_type(const FontStyle &style) { return style.hash(); } class FontFamily : public MinikinRefCounted { public: + FontFamily() { } + + FontFamily(FontLanguage lang, int variant) : mLang(lang), mVariant(variant) { + } + ~FontFamily(); // Add font to family, extracting style information from the font @@ -59,6 +109,9 @@ public: void addFont(MinikinFont* typeface, FontStyle style); MinikinFont* getClosestMatch(FontStyle style) const; + FontLanguage lang() const { return mLang; } + int variant() const { return mVariant; } + // API's for enumerating the fonts in a family. These don't guarantee any particular order size_t getNumFonts() const; MinikinFont* getFont(size_t index) const; @@ -73,6 +126,8 @@ private: MinikinFont* typeface; FontStyle style; }; + FontLanguage mLang; + int mVariant; std::vector mFonts; }; diff --git a/engine/src/flutter/libs/minikin/CssParse.cpp b/engine/src/flutter/libs/minikin/CssParse.cpp index 5bb6949b9a..5e96007c4e 100644 --- a/engine/src/flutter/libs/minikin/CssParse.cpp +++ b/engine/src/flutter/libs/minikin/CssParse.cpp @@ -20,6 +20,7 @@ #include // for sprintf - for debugging #include +#include using std::map; using std::pair; @@ -27,27 +28,58 @@ using std::string; namespace android { -bool strEqC(const string str, size_t off, size_t len, const char* str2) { +static bool strEqC(const string str, size_t off, size_t len, const char* str2) { if (len != strlen(str2)) return false; return !memcmp(str.data() + off, str2, len); } -CssTag parseTag(const string str, size_t off, size_t len) { +static CssTag parseTag(const string str, size_t off, size_t len) { if (len == 0) return unknown; char c = str[off]; if (c == 'f') { if (strEqC(str, off, len, "font-size")) return fontSize; if (strEqC(str, off, len, "font-weight")) return fontWeight; if (strEqC(str, off, len, "font-style")) return fontStyle; + } else if (c == 'l') { + if (strEqC(str, off, len, "lang")) return cssLang; } else if (c == '-') { - if (strEqC(str, off, len, "-minikin-hinting")) return minikinHinting; if (strEqC(str, off, len, "-minikin-bidi")) return minikinBidi; + if (strEqC(str, off, len, "-minikin-hinting")) return minikinHinting; + if (strEqC(str, off, len, "-minikin-variant")) return minikinVariant; } return unknown; } -bool parseValue(const string str, size_t *off, size_t len, CssTag tag, - CssValue* v) { +static bool parseStringValue(const string& str, size_t* off, size_t len, CssTag tag, CssValue* v) { + const char* data = str.data(); + size_t beg = *off; + if (beg == len) return false; + char first = data[beg]; + bool quoted = false; + if (first == '\'' || first == '\"') { + quoted = true; + beg++; + } + size_t end; + for (end = beg; end < len; end++) { + char c = data[end]; + if (quoted && c == first) { + v->setStringValue(std::string(str, beg, end - beg)); + *off = end + 1; + return true; + } else if (!quoted && (c == ';' || c == ' ')) { + break; + } // TODO: deal with backslash escape, but only important for real strings + } + v->setStringValue(std::string(str, beg, end - beg)); + *off = end; + return true; +} + +static bool parseValue(const string& str, size_t* off, size_t len, CssTag tag, CssValue* v) { + if (tag == cssLang) { + return parseStringValue(str, off, len, tag, v); + } const char* data = str.data(); char* endptr; double fv = strtod(data + *off, &endptr); @@ -78,6 +110,12 @@ bool parseValue(const string str, size_t *off, size_t len, CssTag tag, } else { return false; } + } else if (tag == minikinVariant) { + if (strEqC(str, *off, taglen, "compact")) { + fv = VARIANT_COMPACT; + } else if (strEqC(str, *off, taglen, "elegant")) { + fv = VARIANT_ELEGANT; + } } else { return false; } @@ -91,10 +129,15 @@ string CssValue::toString(CssTag tag) const { if (mType == FLOAT) { if (tag == fontStyle) { return floatValue ? "italic" : "normal"; + } else if (tag == minikinVariant) { + if (floatValue == VARIANT_COMPACT) return "compact"; + if (floatValue == VARIANT_ELEGANT) return "elegant"; } char buf[64]; sprintf(buf, "%g", floatValue); return string(buf); + } else if (mType == STRING) { + return stringValue; // should probably quote } return ""; } diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index e6ff117ad7..89086ee41c 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -108,7 +108,19 @@ FontCollection::~FontCollection() { } } -const FontFamily* FontCollection::getFamilyForChar(uint32_t ch) const { +// Implement heuristic for choosing best-match font. Here are the rules: +// 1. If first font in the collection has the character, it wins. +// 2. If a font matches both language and script, it gets a score of 4. +// 3. If a font matches just language, it gets a score of 2. +// 4. Matching the "compact" or "elegant" variant adds one to the score. +// 5. Highest score wins, with ties resolved to the first font. + +// Note that we may want to make the selection more dependent on +// context, so for example a sequence of Devanagari, ZWJ, Devanagari +// would get itemized as one run, even though by the rules the ZWJ +// would go to the Latin font. +const FontFamily* FontCollection::getFamilyForChar(uint32_t ch, FontLanguage lang, + int variant) const { if (ch >= mMaxChar) { return NULL; } @@ -116,17 +128,33 @@ const FontFamily* FontCollection::getFamilyForChar(uint32_t ch) const { #ifdef VERBOSE_DEBUG ALOGD("querying range %d:%d\n", range.start, range.end); #endif + FontFamily* bestFamily = NULL; + int bestScore = -1; for (size_t i = range.start; i < range.end; i++) { const FontInstance* instance = mInstanceVec[i]; if (instance->mCoverage->get(ch)) { - return instance->mFamily; + FontFamily* family = instance->mFamily; + // First font family in collection always matches + if (mInstances[0].mFamily == family) { + return family; + } + int score = lang.match(family->lang()) * 2; + if (variant != 0 && variant == family->variant()) { + score++; + } + if (score > bestScore) { + bestScore = score; + bestFamily = family; + } } } - return NULL; + return bestFamily; } void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style, vector* result) const { + FontLanguage lang = style.getLanguage(); + int variant = style.getVariant(); const FontFamily* lastFamily = NULL; Run* run = NULL; int nShorts; @@ -140,7 +168,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty nShorts = 2; } } - const FontFamily* family = getFamilyForChar(ch); + const FontFamily* family = getFamilyForChar(ch, lang, variant); if (i == 0 || family != lastFamily) { Run dummy; result->push_back(dummy); @@ -149,6 +177,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty run->font = NULL; // maybe we should do something different here } else { run->font = family->getClosestMatch(style); + // TODO: simplify refcounting (FontCollection lifetime dominates) run->font->RefLocked(); } lastFamily = family; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index d818f77eec..0fb98ae4e7 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -30,6 +30,47 @@ using std::vector; namespace android { +// Parse bcp-47 language identifier into internal structure +FontLanguage::FontLanguage(const char* buf, size_t size) { + uint32_t bits = 0; + size_t i; + for (i = 0; i < size && buf[i] != '-' && buf[i] != '_'; i++) { + uint16_t c = buf[i]; + if (c == '-' || c == '_') break; + } + if (i == 2) { + bits = (uint8_t(buf[0]) << 8) | uint8_t(buf[1]); + } + size_t next; + for (i++; i < size; i = next + 1) { + for (next = i; next < size; next++) { + uint16_t c = buf[next]; + if (c == '-' || c == '_') break; + } + if (next - i == 4 && buf[i] == 'H' && buf[i+1] == 'a' && buf[i+2] == 'n') { + if (buf[i+3] == 's') { + bits |= kHansFlag; + } else if (buf[i+3] == 't') { + bits |= kHantFlag; + } + } + // TODO: this might be a good place to infer script from country (zh_TW -> Hant), + // but perhaps it's up to the client to do that, before passing a string. + } + mBits = bits; +} + +int FontLanguage::match(const FontLanguage other) const { + int result = 0; + if ((mBits & kBaseLangMask) == (other.mBits & kBaseLangMask)) { + result++; + if ((mBits & kScriptMask) != 0 && (mBits & kScriptMask) == (other.mBits & kScriptMask)) { + result++; + } + } + return result; +} + FontFamily::~FontFamily() { for (size_t i = 0; i < mFonts.size(); i++) { mFonts[i].typeface->UnrefLocked(); diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index aba8a1c7ab..4028d9e420 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -344,7 +344,16 @@ static FontStyle styleFromCss(const CssProperties &props) { if (props.hasTag(fontStyle)) { italic = props.value(fontStyle).getIntValue() != 0; } - return FontStyle(weight, italic); + FontLanguage lang; + if (props.hasTag(cssLang)) { + string langStr = props.value(cssLang).getStringValue(); + lang = FontLanguage(langStr.c_str(), langStr.size()); + } + int variant = 0; + if (props.hasTag(minikinVariant)) { + variant = props.value(minikinVariant).getIntValue(); + } + return FontStyle(lang, variant, weight, italic); } static hb_script_t codePointToScript(hb_codepoint_t codepoint) { @@ -486,7 +495,7 @@ static void clearHbFonts(LayoutContext* ctx) { // TODO: API should probably take context void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - const std::string& css) { + const string& css) { AutoMutex _l(gMinikinLock); LayoutContext ctx; @@ -599,7 +608,6 @@ void Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_ } appendLayout(value, bufStart); cache.mCache.put(key, value); - } void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, @@ -641,6 +649,10 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_buffer_reset(buffer); hb_buffer_set_script(buffer, script); hb_buffer_set_direction(buffer, isRtl? HB_DIRECTION_RTL : HB_DIRECTION_LTR); + if (ctx->props.hasTag(cssLang)) { + string lang = ctx->props.value(cssLang).getStringValue(); + hb_buffer_set_language(buffer, hb_language_from_string(lang.c_str(), -1)); + } hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); hb_shape(hbFont, buffer, NULL, 0); unsigned int numGlyphs; From 1391c37ea908bff79222109f4351d361c2910372 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 28 May 2014 15:38:35 -0700 Subject: [PATCH 024/364] Fix ZWJ not working for Indic fonts This is a fix for bug 15185229 ZWJ not working in Sinhala and Kannada. Indic fonts (unlike Arabic) require the entire string, including ZWJ, to be passed to Harfbuzz; it's not enough for the ZWJ to be present in the context. The solution is to be "sticky" in font itemization, continuing to use the same font as long as it has Unicode coverage. Change-Id: I7673bc56fbda09f1e1a4582e8d88342343b706f1 --- .../flutter/include/minikin/FontCollection.h | 4 +- .../flutter/libs/minikin/FontCollection.cpp | 48 +++++++++---------- 2 files changed, 25 insertions(+), 27 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index a350237a3e..78ab2aae7b 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -32,8 +32,6 @@ public: ~FontCollection(); - const FontFamily* getFamilyForChar(uint32_t ch, FontLanguage lang, int variant) const; - class Run { public: // Do copy constructor, assignment, destructor so it can be used in vectors @@ -74,6 +72,8 @@ private: size_t end; }; + const FontInstance* getInstanceForChar(uint32_t ch, FontLanguage lang, int variant) const; + // static for allocating unique id's static uint32_t sNextId; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 89086ee41c..1713b476e0 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -114,13 +114,8 @@ FontCollection::~FontCollection() { // 3. If a font matches just language, it gets a score of 2. // 4. Matching the "compact" or "elegant" variant adds one to the score. // 5. Highest score wins, with ties resolved to the first font. - -// Note that we may want to make the selection more dependent on -// context, so for example a sequence of Devanagari, ZWJ, Devanagari -// would get itemized as one run, even though by the rules the ZWJ -// would go to the Latin font. -const FontFamily* FontCollection::getFamilyForChar(uint32_t ch, FontLanguage lang, - int variant) const { +const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t ch, + FontLanguage lang, int variant) const { if (ch >= mMaxChar) { return NULL; } @@ -128,7 +123,7 @@ const FontFamily* FontCollection::getFamilyForChar(uint32_t ch, FontLanguage lan #ifdef VERBOSE_DEBUG ALOGD("querying range %d:%d\n", range.start, range.end); #endif - FontFamily* bestFamily = NULL; + const FontInstance* bestInstance = NULL; int bestScore = -1; for (size_t i = range.start; i < range.end; i++) { const FontInstance* instance = mInstanceVec[i]; @@ -136,7 +131,7 @@ const FontFamily* FontCollection::getFamilyForChar(uint32_t ch, FontLanguage lan FontFamily* family = instance->mFamily; // First font family in collection always matches if (mInstances[0].mFamily == family) { - return family; + return instance; } int score = lang.match(family->lang()) * 2; if (variant != 0 && variant == family->variant()) { @@ -144,18 +139,18 @@ const FontFamily* FontCollection::getFamilyForChar(uint32_t ch, FontLanguage lan } if (score > bestScore) { bestScore = score; - bestFamily = family; + bestInstance = instance; } } } - return bestFamily; + return bestInstance; } void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style, vector* result) const { FontLanguage lang = style.getLanguage(); int variant = style.getVariant(); - const FontFamily* lastFamily = NULL; + const FontInstance* lastInstance = NULL; Run* run = NULL; int nShorts; for (size_t i = 0; i < string_size; i += nShorts) { @@ -168,20 +163,23 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty nShorts = 2; } } - const FontFamily* family = getFamilyForChar(ch, lang, variant); - if (i == 0 || family != lastFamily) { - Run dummy; - result->push_back(dummy); - run = &result->back(); - if (family == NULL) { - run->font = NULL; // maybe we should do something different here - } else { - run->font = family->getClosestMatch(style); - // TODO: simplify refcounting (FontCollection lifetime dominates) - run->font->RefLocked(); + // Continue using existing font as long as it has coverage. + if (lastInstance == NULL || !lastInstance->mCoverage->get(ch)) { + const FontInstance* instance = getInstanceForChar(ch, lang, variant); + if (i == 0 || instance != lastInstance) { + Run dummy; + result->push_back(dummy); + run = &result->back(); + if (instance == NULL) { + run->font = NULL; // maybe we should do something different here + } else { + run->font = instance->mFamily->getClosestMatch(style); + // TODO: simplify refcounting (FontCollection lifetime dominates) + run->font->RefLocked(); + } + lastInstance = instance; + run->start = i; } - lastFamily = family; - run->start = i; } run->end = i + nShorts; } From 23801bf449e5bfa467729b1a61af324a7afbee19 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Fri, 30 May 2014 23:38:56 -0700 Subject: [PATCH 025/364] Support for scaleX and skewX Adds pseudo-css properties for scaleX and skewX, as well as paint flags, and plumb them through to the MinikinPaint abstraction and to Harfbuzz, to support nontrivial scale and stretch of text. This is the Minikin part of the fix for bug 15186705 "Usability of the suggestion strip in recent OTA's is severely reduced" Change-Id: Ifa60355e086e4691ff92c5d50d84eb7cea0fea95 --- engine/src/flutter/include/minikin/CssParse.h | 8 +++- .../src/flutter/include/minikin/MinikinFont.h | 4 +- engine/src/flutter/libs/minikin/CssParse.cpp | 3 ++ engine/src/flutter/libs/minikin/Layout.cpp | 43 +++++++++++++------ 4 files changed, 43 insertions(+), 15 deletions(-) diff --git a/engine/src/flutter/include/minikin/CssParse.h b/engine/src/flutter/include/minikin/CssParse.h index 519056df57..ae2aac607a 100644 --- a/engine/src/flutter/include/minikin/CssParse.h +++ b/engine/src/flutter/include/minikin/CssParse.h @@ -24,24 +24,30 @@ namespace android { enum CssTag { unknown, + fontScaleX, fontSize, + fontSkewX, fontStyle, fontWeight, cssLang, minikinBidi, minikinHinting, minikinVariant, + paintFlags, }; const std::string cssTagNames[] = { "unknown", + "font-scale-x", "font-size", + "font-skew-x", "font-style", "font-weight", "lang", "-minikin-bidi", "-minikin-hinting", "-minikin-variant", + "-paint-flags", }; class CssValue { @@ -62,7 +68,7 @@ public: mType(FLOAT), floatValue(v), mUnits(SCALAR) { } Type getType() const { return mType; } double getFloatValue() const { return floatValue; } - int getIntValue() const { return floatValue; } + int32_t getIntValue() const { return floatValue; } std::string getStringValue() const { return stringValue; } std::string toString(CssTag tag) const; void setFloatValue(double v) { diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index dbb89f8331..1f6894cb64 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -31,7 +31,9 @@ class MinikinFont; struct MinikinPaint { MinikinFont *font; float size; - // todo: skew, stretch, hinting + float scaleX; + float skewX; + int32_t paintFlags; }; struct MinikinRect { diff --git a/engine/src/flutter/libs/minikin/CssParse.cpp b/engine/src/flutter/libs/minikin/CssParse.cpp index 5e96007c4e..147f3304bb 100644 --- a/engine/src/flutter/libs/minikin/CssParse.cpp +++ b/engine/src/flutter/libs/minikin/CssParse.cpp @@ -37,7 +37,9 @@ static CssTag parseTag(const string str, size_t off, size_t len) { if (len == 0) return unknown; char c = str[off]; if (c == 'f') { + if (strEqC(str, off, len, "font-scale-x")) return fontScaleX; if (strEqC(str, off, len, "font-size")) return fontSize; + if (strEqC(str, off, len, "font-skew-x")) return fontSkewX; if (strEqC(str, off, len, "font-weight")) return fontWeight; if (strEqC(str, off, len, "font-style")) return fontStyle; } else if (c == 'l') { @@ -46,6 +48,7 @@ static CssTag parseTag(const string str, size_t off, size_t len) { if (strEqC(str, off, len, "-minikin-bidi")) return minikinBidi; if (strEqC(str, off, len, "-minikin-hinting")) return minikinHinting; if (strEqC(str, off, len, "-minikin-variant")) return minikinVariant; + if (strEqC(str, off, len, "-paint-flags")) return paintFlags; } return unknown; } diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 4028d9e420..c13aed8ef2 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -63,7 +63,8 @@ public: LayoutCacheKey(const FontCollection* collection, const MinikinPaint& paint, FontStyle style, const uint16_t* chars, size_t start, size_t count, size_t nchars, bool dir) : mStart(start), mCount(count), mId(collection->getId()), mStyle(style), - mSize(paint.size), mIsRtl(dir) { + mSize(paint.size), mScaleX(paint.scaleX), mSkewX(paint.skewX), + mPaintFlags(paint.paintFlags), mIsRtl(dir) { mText.setTo(chars, nchars); } bool operator==(const LayoutCacheKey &other) const; @@ -78,6 +79,9 @@ private: uint32_t mId; // for the font collection FontStyle mStyle; float mSize; + float mScaleX; + float mSkewX; + int mPaintFlags; bool mIsRtl; // Note: any fields added to MinikinPaint must also be reflected here. // TODO: language matching (possibly integrate into style) @@ -133,13 +137,16 @@ public: ANDROID_SINGLETON_STATIC_INSTANCE(LayoutEngine); bool LayoutCacheKey::operator==(const LayoutCacheKey& other) const { - return mId == other.mId && - mStart == other.mStart && - mCount == other.mCount && - mStyle == other.mStyle && - mSize == other.mSize && - mIsRtl == other.mIsRtl && - mText == other.mText; + return mId == other.mId + && mStart == other.mStart + && mCount == other.mCount + && mStyle == other.mStyle + && mSize == other.mSize + && mScaleX == other.mScaleX + && mSkewX == other.mSkewX + && mPaintFlags == other.mPaintFlags + && mIsRtl == other.mIsRtl + && mText == other.mText; } hash_t LayoutCacheKey::hash() const { @@ -148,6 +155,9 @@ hash_t LayoutCacheKey::hash() const { hash = JenkinsHashMix(hash, mCount); hash = JenkinsHashMix(hash, hash_type(mStyle)); hash = JenkinsHashMix(hash, hash_type(mSize)); + hash = JenkinsHashMix(hash, hash_type(mScaleX)); + hash = JenkinsHashMix(hash, hash_type(mSkewX)); + hash = JenkinsHashMix(hash, hash_type(mPaintFlags)); hash = JenkinsHashMix(hash, hash_type(mIsRtl)); hash = JenkinsHashMixShorts(hash, mText.string(), mText.size()); return JenkinsHashWhiten(hash); @@ -502,8 +512,13 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu ctx.props.parse(css); ctx.style = styleFromCss(ctx.props); - double size = ctx.props.value(fontSize).getFloatValue(); - ctx.paint.size = size; + ctx.paint.size = ctx.props.value(fontSize).getFloatValue(); + ctx.paint.scaleX = ctx.props.hasTag(fontScaleX) + ? ctx.props.value(fontScaleX).getFloatValue() : 1; + ctx.paint.skewX = ctx.props.hasTag(fontSkewX) + ? ctx.props.value(fontSkewX).getFloatValue() : 0; + ctx.paint.paintFlags = ctx.props.hasTag(paintFlags) + ?ctx.props.value(paintFlags).getIntValue() : 0; int bidiFlags = ctx.props.hasTag(minikinBidi) ? ctx.props.value(minikinBidi).getIntValue() : 0; bool isRtl = (bidiFlags & kDirection_Mask) != 0; bool doSingleRun = true; @@ -635,8 +650,9 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t " [" << run.start << ":" << run.end << "]" << std::endl; #endif double size = ctx->paint.size; - hb_font_set_ppem(hbFont, size, size); - hb_font_set_scale(hbFont, HBFloatToFixed(size), HBFloatToFixed(size)); + double scaleX = ctx->paint.scaleX; + hb_font_set_ppem(hbFont, size * scaleX, size); + hb_font_set_scale(hbFont, HBFloatToFixed(size * scaleX), HBFloatToFixed(size)); // 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 @@ -665,7 +681,8 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t #endif hb_codepoint_t glyph_ix = info[i].codepoint; float xoff = HBFixedToFloat(positions[i].x_offset); - float yoff = HBFixedToFloat(positions[i].y_offset); + float yoff = -HBFixedToFloat(positions[i].y_offset); + xoff += yoff * ctx->paint.skewX; LayoutGlyph glyph = {font_ix, glyph_ix, x + xoff, y + yoff}; mGlyphs.push_back(glyph); float xAdvance = HBFixedToFloat(positions[i].x_advance); From 014498ae2ab29399a632c548b8dc94cbf215b861 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 4 Jun 2014 11:15:28 -0700 Subject: [PATCH 026/364] Fix unmatching type Missed a slightly mismatched type (int vs int32_t) from a previous code review. Change-Id: Ib56775a3a1a6ec3763da7f7432186954251cc048 --- engine/src/flutter/libs/minikin/Layout.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index c13aed8ef2..5471b38bdf 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -81,7 +81,7 @@ private: float mSize; float mScaleX; float mSkewX; - int mPaintFlags; + int32_t mPaintFlags; bool mIsRtl; // Note: any fields added to MinikinPaint must also be reflected here. // TODO: language matching (possibly integrate into style) From ddcdc08c7c14059df0494776161c7887967965e4 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 4 Jun 2014 15:25:30 -0700 Subject: [PATCH 027/364] Make paint flags consistently uint32_t Change internal plumbing of paint flags (including CssParse) to uint32_t consistently, to match the type used in the client. This will probably prevent compiler warnings. Also renames "float" to "double" to avoid confusion about precision. Change-Id: I80374712c4067ca9e7711cc2d4ec33c440ab9c7c --- engine/src/flutter/include/minikin/CssParse.h | 17 +++++++++-------- .../src/flutter/include/minikin/MinikinFont.h | 2 +- engine/src/flutter/libs/minikin/CssParse.cpp | 12 ++++++------ engine/src/flutter/libs/minikin/Layout.cpp | 8 ++++---- 4 files changed, 20 insertions(+), 19 deletions(-) diff --git a/engine/src/flutter/include/minikin/CssParse.h b/engine/src/flutter/include/minikin/CssParse.h index ae2aac607a..ea28b81ad9 100644 --- a/engine/src/flutter/include/minikin/CssParse.h +++ b/engine/src/flutter/include/minikin/CssParse.h @@ -54,7 +54,7 @@ class CssValue { public: enum Type { UNKNOWN, - FLOAT, + DOUBLE, STRING }; enum Units { @@ -65,15 +65,16 @@ public: }; CssValue() : mType(UNKNOWN) { } explicit CssValue(double v) : - mType(FLOAT), floatValue(v), mUnits(SCALAR) { } + mType(DOUBLE), doubleValue(v), mUnits(SCALAR) { } Type getType() const { return mType; } - double getFloatValue() const { return floatValue; } - int32_t getIntValue() const { return floatValue; } + double getDoubleValue() const { return doubleValue; } + int32_t getIntValue() const { return doubleValue; } + uint32_t getUintValue() const { return doubleValue; } std::string getStringValue() const { return stringValue; } std::string toString(CssTag tag) const; - void setFloatValue(double v) { - mType = FLOAT; - floatValue = v; + void setDoubleValue(double v) { + mType = DOUBLE; + doubleValue = v; } void setStringValue(const std::string& v) { mType = STRING; @@ -81,7 +82,7 @@ public: } private: Type mType; - double floatValue; + double doubleValue; std::string stringValue; Units mUnits; }; diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 1f6894cb64..9ff08a95f0 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -33,7 +33,7 @@ struct MinikinPaint { float size; float scaleX; float skewX; - int32_t paintFlags; + uint32_t paintFlags; }; struct MinikinRect { diff --git a/engine/src/flutter/libs/minikin/CssParse.cpp b/engine/src/flutter/libs/minikin/CssParse.cpp index 147f3304bb..8168a748d2 100644 --- a/engine/src/flutter/libs/minikin/CssParse.cpp +++ b/engine/src/flutter/libs/minikin/CssParse.cpp @@ -123,21 +123,21 @@ static bool parseValue(const string& str, size_t* off, size_t len, CssTag tag, C return false; } } - v->setFloatValue(fv); + v->setDoubleValue(fv); *off = endptr - data; return true; } string CssValue::toString(CssTag tag) const { - if (mType == FLOAT) { + if (mType == DOUBLE) { if (tag == fontStyle) { - return floatValue ? "italic" : "normal"; + return doubleValue ? "italic" : "normal"; } else if (tag == minikinVariant) { - if (floatValue == VARIANT_COMPACT) return "compact"; - if (floatValue == VARIANT_ELEGANT) return "elegant"; + if (doubleValue == VARIANT_COMPACT) return "compact"; + if (doubleValue == VARIANT_ELEGANT) return "elegant"; } char buf[64]; - sprintf(buf, "%g", floatValue); + sprintf(buf, "%g", doubleValue); return string(buf); } else if (mType == STRING) { return stringValue; // should probably quote diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 5471b38bdf..c66559ac5b 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -512,13 +512,13 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu ctx.props.parse(css); ctx.style = styleFromCss(ctx.props); - ctx.paint.size = ctx.props.value(fontSize).getFloatValue(); + ctx.paint.size = ctx.props.value(fontSize).getDoubleValue(); ctx.paint.scaleX = ctx.props.hasTag(fontScaleX) - ? ctx.props.value(fontScaleX).getFloatValue() : 1; + ? ctx.props.value(fontScaleX).getDoubleValue() : 1; ctx.paint.skewX = ctx.props.hasTag(fontSkewX) - ? ctx.props.value(fontSkewX).getFloatValue() : 0; + ? ctx.props.value(fontSkewX).getDoubleValue() : 0; ctx.paint.paintFlags = ctx.props.hasTag(paintFlags) - ?ctx.props.value(paintFlags).getIntValue() : 0; + ? ctx.props.value(paintFlags).getUintValue() : 0; int bidiFlags = ctx.props.hasTag(minikinBidi) ? ctx.props.value(minikinBidi).getIntValue() : 0; bool isRtl = (bidiFlags & kDirection_Mask) != 0; bool doSingleRun = true; From 06dec08ca290f24b4e85e6c2108371045602d4ff Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 4 Jun 2014 15:20:37 -0700 Subject: [PATCH 028/364] Support for context in API This patch completes support for adding context for complex script layout, for example when a string with joins straddles two spans. Part of the fix for 15431028: "Properly support context for joining scripts (Minikin)" Change-Id: I65b0833be92eb477aa531bbef0ac6eddeb3a962a --- engine/src/flutter/include/minikin/Layout.h | 2 +- engine/src/flutter/libs/minikin/Layout.cpp | 35 +++++++++------------ 2 files changed, 15 insertions(+), 22 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index a1ef0c13b8..91b8ef6fd1 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -105,7 +105,7 @@ private: // Lay out a single bidi run void doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, LayoutContext* ctx); + bool isRtl, LayoutContext* ctx, size_t dstStart); // Lay out a single word void doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index c66559ac5b..3cab673577 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -485,17 +485,6 @@ void Layout::doLayout(const uint16_t* buf, size_t nchars) { doLayout(buf, 0, nchars, nchars, mCssString); } -// TODO: use some standard implementation -template -static T mymin(const T& a, const T& b) { - return a < b ? a : b; -} - -template -static T mymax(const T& a, const T& b) { - return a > b ? a : b; -} - static void clearHbFonts(LayoutContext* ctx) { for (size_t i = 0; i < ctx->hbFonts.size(); i++) { hb_font_destroy(ctx->hbFonts[i]); @@ -503,7 +492,6 @@ static void clearHbFonts(LayoutContext* ctx) { ctx->hbFonts.clear(); } -// TODO: API should probably take context void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, const string& css) { AutoMutex _l(gMinikinLock); @@ -560,9 +548,14 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu // skip the invalid run continue; } - isRtl = (runDir == UBIDI_RTL); - // TODO: min/max with context - doLayoutRunCached(buf, startRun, lengthRun, bufSize, isRtl, &ctx); + int32_t endRun = std::min(startRun + lengthRun, int32_t(start + count)); + startRun = std::max(startRun, int32_t(start)); + lengthRun = endRun - startRun; + if (lengthRun > 0) { + isRtl = (runDir == UBIDI_RTL); + doLayoutRunCached(buf, startRun, lengthRun, bufSize, isRtl, &ctx, + start); + } } } } else { @@ -574,22 +567,22 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu } } if (doSingleRun) { - doLayoutRunCached(buf, start, count, bufSize, isRtl, &ctx); + doLayoutRunCached(buf, start, count, bufSize, isRtl, &ctx, start); } clearHbFonts(&ctx); } void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, LayoutContext* ctx) { + bool isRtl, LayoutContext* ctx, size_t dstStart) { if (!isRtl) { // left to right size_t wordstart = start == bufSize ? start : getPrevWordBreak(buf, start + 1); size_t wordend; for (size_t iter = start; iter < start + count; iter = wordend) { wordend = getNextWordBreak(buf, iter, bufSize); - size_t wordcount = mymin(start + count, wordend) - iter; + size_t wordcount = std::min(start + count, wordend) - iter; doLayoutWord(buf + wordstart, iter - wordstart, wordcount, wordend - wordstart, - isRtl, ctx, iter); + isRtl, ctx, iter - dstStart); wordstart = wordend; } } else { @@ -599,9 +592,9 @@ void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t wordend = end == 0 ? 0 : getNextWordBreak(buf, end - 1, bufSize); for (size_t iter = end; iter > start; iter = wordstart) { wordstart = getPrevWordBreak(buf, iter); - size_t bufStart = mymax(start, wordstart); + size_t bufStart = std::max(start, wordstart); doLayoutWord(buf + wordstart, bufStart - wordstart, iter - bufStart, - wordend - wordstart, isRtl, ctx, bufStart); + wordend - wordstart, isRtl, ctx, bufStart - dstStart); wordend = wordstart; } } From 13b22fd2434e3b7f5d707de20617812c5dbc2b5b Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 5 Jun 2014 22:40:15 -0700 Subject: [PATCH 029/364] Add baseFont method to FontCollection This patch adds a method to retrieve the base font from a FontCollection, which is useful when querying global font metrics. Part of the fix for bug 15467288 "Inconsistent line heights on Minikin builds" Change-Id: I268ae5128d0852a020d746bc22af81fc1a623228 --- engine/src/flutter/include/minikin/FontCollection.h | 3 +++ engine/src/flutter/libs/minikin/FontCollection.cpp | 8 ++++++++ 2 files changed, 11 insertions(+) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 78ab2aae7b..508a129a99 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -57,6 +57,9 @@ public: void itemize(const uint16_t *string, size_t string_length, FontStyle style, std::vector* result) const; + // Get the base font for the given style, useful for font-wide metrics. + MinikinFont* baseFont(FontStyle style); + uint32_t getId() const; private: static const int kLogCharsPerPage = 8; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 1713b476e0..c13670e74a 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -185,6 +185,14 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } } +MinikinFont* FontCollection::baseFont(FontStyle style) { + if (mInstances.empty()) { + return NULL; + } + return mInstances[0].mFamily->getClosestMatch(style); +} + + uint32_t FontCollection::getId() const { return mId; } From faadb4243eef234e41d8ab21a7e80a5794d76579 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Sat, 7 Jun 2014 08:14:07 -0700 Subject: [PATCH 030/364] Provisionally enable "palt" OpenType feature We want to test configurations where the Noto Japanese font will have its "palt" feature (to select tighter spacing in kana) will be enabled for framework but not WebView or Chrome rendering of Japanese text. This patch simply hardcodes this feature on. This is also a first step towards more general setting of OpenType features. The hardcoded feature list will grow into one set by parameters which will eventually be plumbed up to Java. Change-Id: Ie284e0487a1434155c8ac1cb68ddc4fc4b3c018a --- engine/src/flutter/libs/minikin/Layout.cpp | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 3cab673577..2fdf853696 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -618,6 +618,12 @@ void Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_ cache.mCache.put(key, value); } +static void addFeatures(vector* features) { + // hardcoded features, to be repaced with more flexible configuration + static hb_feature_t palt = { HB_TAG('p', 'a', 'l', 't'), 1, 0, ~0u }; + features->push_back(palt); +} + void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, bool isRtl, LayoutContext* ctx) { hb_buffer_t* buffer = LayoutEngine::getInstance().hbBuffer; @@ -627,6 +633,9 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t std::reverse(items.begin(), items.end()); } + vector features; + addFeatures(&features); + float x = mAdvance; float y = 0; for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { @@ -663,7 +672,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_buffer_set_language(buffer, hb_language_from_string(lang.c_str(), -1)); } hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); - hb_shape(hbFont, buffer, NULL, 0); + hb_shape(hbFont, buffer, features.empty() ? NULL : &features[0], features.size()); unsigned int numGlyphs; hb_glyph_info_t* info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); hb_glyph_position_t* positions = hb_buffer_get_glyph_positions(buffer, NULL); From 2b7da7bc2b8db79664cfe3855fe1c8d8b6f31f74 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Fri, 6 Jun 2014 17:56:41 -0700 Subject: [PATCH 031/364] Support for fake bold and italics This patch adds support for computing when fake bold and fake italics are needed (because the styles are requested but not provided by the matching FontFamily), and providing them as part of the layout result. Part of the fix for bug 15436379 Fake bold doesn't fully work (Minikin) Change-Id: I180c034b559837943673b5c272c8e890178dff0d --- .../flutter/include/minikin/FontCollection.h | 23 ++++--------------- .../src/flutter/include/minikin/FontFamily.h | 21 ++++++++++++++++- engine/src/flutter/include/minikin/Layout.h | 5 ++-- .../src/flutter/include/minikin/MinikinFont.h | 2 ++ .../flutter/libs/minikin/FontCollection.cpp | 15 ++++++------ .../src/flutter/libs/minikin/FontFamily.cpp | 21 ++++++++++++++--- engine/src/flutter/libs/minikin/Layout.cpp | 22 +++++++++++------- 7 files changed, 70 insertions(+), 39 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 508a129a99..12700c6ebe 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -32,24 +32,8 @@ public: ~FontCollection(); - class Run { - public: - // Do copy constructor, assignment, destructor so it can be used in vectors - Run() : font(NULL) { } - Run(const Run& other): font(other.font), start(other.start), end(other.end) { - if (font) font->RefLocked(); - } - Run& operator=(const Run& other) { - if (other.font) other.font->RefLocked(); - if (font) font->UnrefLocked(); - font = other.font; - start = other.start; - end = other.end; - return *this; - } - ~Run() { if (font) font->UnrefLocked(); } - - MinikinFont* font; + struct Run { + FakedFont fakedFont; int start; int end; }; @@ -60,6 +44,9 @@ public: // Get the base font for the given style, useful for font-wide metrics. MinikinFont* baseFont(FontStyle style); + // Get base font with fakery information (fake bold could affect metrics) + FakedFont baseFontFaked(FontStyle style); + uint32_t getId() const; private: static const int kLogCharsPerPage = 8; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 6bdf5d6376..060d1678c3 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -94,6 +94,25 @@ inline hash_t hash_type(const FontStyle &style) { return style.hash(); } +// attributes representing transforms (fake bold, fake italic) to match styles +class FontFakery { +public: + FontFakery() : mFakeBold(false), mFakeItalic(false) { } + FontFakery(bool fakeBold, bool fakeItalic) : mFakeBold(fakeBold), mFakeItalic(fakeItalic) { } + // TODO: want to support graded fake bolding + bool isFakeBold() { return mFakeBold; } + bool isFakeItalic() { return mFakeItalic; } +private: + bool mFakeBold; + bool mFakeItalic; +}; + +struct FakedFont { + // ownership is the enclosing FontCollection + MinikinFont* font; + FontFakery fakery; +}; + class FontFamily : public MinikinRefCounted { public: FontFamily() { } @@ -107,7 +126,7 @@ public: bool addFont(MinikinFont* typeface); void addFont(MinikinFont* typeface, FontStyle style); - MinikinFont* getClosestMatch(FontStyle style) const; + FakedFont getClosestMatch(FontStyle style) const; FontLanguage lang() const { return mLang; } int variant() const { return mVariant; } diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 91b8ef6fd1..1b91ad87fe 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -87,6 +87,7 @@ public: size_t nGlyphs() const; // Does not bump reference; ownership is still layout MinikinFont *getFont(int i) const; + FontFakery getFakery(int i) const; unsigned int getGlyphId(int i) const; float getX(int i) const; float getY(int i) const; @@ -101,7 +102,7 @@ public: private: // Find a face in the mFaces vector, or create a new entry - int findFace(MinikinFont* face, LayoutContext* ctx); + int findFace(FakedFont face, LayoutContext* ctx); // Lay out a single bidi run void doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, @@ -125,7 +126,7 @@ private: std::vector mAdvances; const FontCollection* mCollection; - std::vector mFaces; + std::vector mFaces; float mAdvance; MinikinRect mBounds; }; diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 9ff08a95f0..7915ef2e0a 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -18,6 +18,7 @@ #define MINIKIN_FONT_H #include +#include // An abstraction for platform fonts, allowing Minikin to be used with // multiple actual implementations of fonts. @@ -34,6 +35,7 @@ struct MinikinPaint { float scaleX; float skewX; uint32_t paintFlags; + FontFakery fakery; }; struct MinikinRect { diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index c13670e74a..6115ecc3b4 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -52,7 +52,7 @@ FontCollection::FontCollection(const vector& typefaces) : FontInstance* instance = &mInstances.back(); instance->mFamily = family; instance->mCoverage = new SparseBitSet; - MinikinFont* typeface = family->getClosestMatch(defaultStyle); + MinikinFont* typeface = family->getClosestMatch(defaultStyle).font; if (typeface == NULL) { ALOGE("FontCollection: closest match was null"); // TODO: we shouldn't hit this, as there should be more robust @@ -171,11 +171,9 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty result->push_back(dummy); run = &result->back(); if (instance == NULL) { - run->font = NULL; // maybe we should do something different here + run->fakedFont.font = NULL; } else { - run->font = instance->mFamily->getClosestMatch(style); - // TODO: simplify refcounting (FontCollection lifetime dominates) - run->font->RefLocked(); + run->fakedFont = instance->mFamily->getClosestMatch(style); } lastInstance = instance; run->start = i; @@ -186,13 +184,16 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } MinikinFont* FontCollection::baseFont(FontStyle style) { + return baseFontFaked(style).font; +} + +FakedFont FontCollection::baseFontFaked(FontStyle style) { if (mInstances.empty()) { - return NULL; + return FakedFont(); } return mInstances[0].mFamily->getClosestMatch(style); } - uint32_t FontCollection::getId() const { return mId; } diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 0fb98ae4e7..9106f63c3e 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -109,7 +109,7 @@ void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { type } // Compute a matching metric between two styles - 0 is an exact match -int computeMatch(FontStyle style1, FontStyle style2) { +static int computeMatch(FontStyle style1, FontStyle style2) { if (style1 == style2) return 0; int score = abs(style1.getWeight() - style2.getWeight()); if (style1.getItalic() != style2.getItalic()) { @@ -118,7 +118,15 @@ int computeMatch(FontStyle style1, FontStyle style2) { return score; } -MinikinFont* FontFamily::getClosestMatch(FontStyle style) const { +static FontFakery computeFakery(FontStyle wanted, FontStyle actual) { + // If desired weight is 2 or more grades higher than actual + // (for example, medium 500 -> bold 700), then select fake bold. + bool isFakeBold = (wanted.getWeight() - actual.getWeight()) >= 2; + bool isFakeItalic = wanted.getItalic() && !actual.getItalic(); + return FontFakery(isFakeBold, isFakeItalic); +} + +FakedFont FontFamily::getClosestMatch(FontStyle style) const { const Font* bestFont = NULL; int bestMatch = 0; for (size_t i = 0; i < mFonts.size(); i++) { @@ -129,7 +137,14 @@ MinikinFont* FontFamily::getClosestMatch(FontStyle style) const { bestMatch = match; } } - return bestFont == NULL ? NULL : bestFont->typeface; + FakedFont result; + if (bestFont == NULL) { + result.font = NULL; + } else { + result.font = bestFont->typeface; + result.fakery = computeFakery(style, bestFont->style); + } + return result; } size_t FontFamily::getNumFonts() const { diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 3cab673577..709393dc31 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -328,10 +328,10 @@ void Layout::dump() const { } } -int Layout::findFace(MinikinFont* face, LayoutContext* ctx) { +int Layout::findFace(FakedFont face, LayoutContext* ctx) { unsigned int ix; for (ix = 0; ix < mFaces.size(); ix++) { - if (mFaces[ix] == face) { + if (mFaces[ix].font == face.font) { return ix; } } @@ -339,7 +339,7 @@ int Layout::findFace(MinikinFont* face, LayoutContext* ctx) { // Note: ctx == NULL means we're copying from the cache, no need to create // corresponding hb_font object. if (ctx != NULL) { - hb_font_t* font = create_hb_font(face, &ctx->paint); + hb_font_t* font = create_hb_font(face.font, &ctx->paint); ctx->hbFonts.push_back(font); } return ix; @@ -631,12 +631,13 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t float y = 0; for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { FontCollection::Run &run = items[run_ix]; - if (run.font == NULL) { + if (run.fakedFont.font == NULL) { ALOGE("no font for run starting u+%04x length %d", buf[run.start], run.end - run.start); continue; } - int font_ix = findFace(run.font, ctx); - ctx->paint.font = mFaces[font_ix]; + int font_ix = findFace(run.fakedFont, ctx); + ctx->paint.font = mFaces[font_ix].font; + ctx->paint.fakery = mFaces[font_ix].fakery; hb_font_t* hbFont = ctx->hbFonts[font_ix]; #ifdef VERBOSE std::cout << "Run " << run_ix << ", font " << font_ix << @@ -729,7 +730,7 @@ void Layout::draw(Bitmap* surface, int x0, int y0, float size) const { */ for (size_t i = 0; i < mGlyphs.size(); i++) { const LayoutGlyph& glyph = mGlyphs[i]; - MinikinFont* mf = mFaces[glyph.font_ix]; + MinikinFont* mf = mFaces[glyph.font_ix].font; MinikinFontFreeType* face = static_cast(mf); GlyphBitmap glyphBitmap; MinikinPaint paint; @@ -754,7 +755,12 @@ size_t Layout::nGlyphs() const { MinikinFont* Layout::getFont(int i) const { const LayoutGlyph& glyph = mGlyphs[i]; - return mFaces[glyph.font_ix]; + return mFaces[glyph.font_ix].font; +} + +FontFakery Layout::getFakery(int i) const { + const LayoutGlyph& glyph = mGlyphs[i]; + return mFaces[glyph.font_ix].fakery; } unsigned int Layout::getGlyphId(int i) const { From 1e35d09df19bbb9bef5c29673106975d96aeb74d Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 5 Jun 2014 22:40:15 -0700 Subject: [PATCH 032/364] Add baseFont method to FontCollection This patch adds a method to retrieve the base font from a FontCollection, which is useful when querying global font metrics. Part of the fix for bug 15467288 "Inconsistent line heights on Minikin builds" Change-Id: I268ae5128d0852a020d746bc22af81fc1a623228 --- engine/src/flutter/include/minikin/FontCollection.h | 3 +++ engine/src/flutter/libs/minikin/FontCollection.cpp | 8 ++++++++ 2 files changed, 11 insertions(+) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 78ab2aae7b..508a129a99 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -57,6 +57,9 @@ public: void itemize(const uint16_t *string, size_t string_length, FontStyle style, std::vector* result) const; + // Get the base font for the given style, useful for font-wide metrics. + MinikinFont* baseFont(FontStyle style); + uint32_t getId() const; private: static const int kLogCharsPerPage = 8; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 1713b476e0..c13670e74a 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -185,6 +185,14 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } } +MinikinFont* FontCollection::baseFont(FontStyle style) { + if (mInstances.empty()) { + return NULL; + } + return mInstances[0].mFamily->getClosestMatch(style); +} + + uint32_t FontCollection::getId() const { return mId; } From 1f8de3019ded454358e56a9f0f9b233e372acba8 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Fri, 6 Jun 2014 17:56:41 -0700 Subject: [PATCH 033/364] Support for fake bold and italics This patch adds support for computing when fake bold and fake italics are needed (because the styles are requested but not provided by the matching FontFamily), and providing them as part of the layout result. Part of the fix for bug 15436379 Fake bold doesn't fully work (Minikin) Change-Id: I180c034b559837943673b5c272c8e890178dff0d --- .../flutter/include/minikin/FontCollection.h | 23 ++++--------------- .../src/flutter/include/minikin/FontFamily.h | 21 ++++++++++++++++- engine/src/flutter/include/minikin/Layout.h | 5 ++-- .../src/flutter/include/minikin/MinikinFont.h | 2 ++ .../flutter/libs/minikin/FontCollection.cpp | 15 ++++++------ .../src/flutter/libs/minikin/FontFamily.cpp | 21 ++++++++++++++--- engine/src/flutter/libs/minikin/Layout.cpp | 22 +++++++++++------- 7 files changed, 70 insertions(+), 39 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 508a129a99..12700c6ebe 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -32,24 +32,8 @@ public: ~FontCollection(); - class Run { - public: - // Do copy constructor, assignment, destructor so it can be used in vectors - Run() : font(NULL) { } - Run(const Run& other): font(other.font), start(other.start), end(other.end) { - if (font) font->RefLocked(); - } - Run& operator=(const Run& other) { - if (other.font) other.font->RefLocked(); - if (font) font->UnrefLocked(); - font = other.font; - start = other.start; - end = other.end; - return *this; - } - ~Run() { if (font) font->UnrefLocked(); } - - MinikinFont* font; + struct Run { + FakedFont fakedFont; int start; int end; }; @@ -60,6 +44,9 @@ public: // Get the base font for the given style, useful for font-wide metrics. MinikinFont* baseFont(FontStyle style); + // Get base font with fakery information (fake bold could affect metrics) + FakedFont baseFontFaked(FontStyle style); + uint32_t getId() const; private: static const int kLogCharsPerPage = 8; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 6bdf5d6376..060d1678c3 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -94,6 +94,25 @@ inline hash_t hash_type(const FontStyle &style) { return style.hash(); } +// attributes representing transforms (fake bold, fake italic) to match styles +class FontFakery { +public: + FontFakery() : mFakeBold(false), mFakeItalic(false) { } + FontFakery(bool fakeBold, bool fakeItalic) : mFakeBold(fakeBold), mFakeItalic(fakeItalic) { } + // TODO: want to support graded fake bolding + bool isFakeBold() { return mFakeBold; } + bool isFakeItalic() { return mFakeItalic; } +private: + bool mFakeBold; + bool mFakeItalic; +}; + +struct FakedFont { + // ownership is the enclosing FontCollection + MinikinFont* font; + FontFakery fakery; +}; + class FontFamily : public MinikinRefCounted { public: FontFamily() { } @@ -107,7 +126,7 @@ public: bool addFont(MinikinFont* typeface); void addFont(MinikinFont* typeface, FontStyle style); - MinikinFont* getClosestMatch(FontStyle style) const; + FakedFont getClosestMatch(FontStyle style) const; FontLanguage lang() const { return mLang; } int variant() const { return mVariant; } diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 91b8ef6fd1..1b91ad87fe 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -87,6 +87,7 @@ public: size_t nGlyphs() const; // Does not bump reference; ownership is still layout MinikinFont *getFont(int i) const; + FontFakery getFakery(int i) const; unsigned int getGlyphId(int i) const; float getX(int i) const; float getY(int i) const; @@ -101,7 +102,7 @@ public: private: // Find a face in the mFaces vector, or create a new entry - int findFace(MinikinFont* face, LayoutContext* ctx); + int findFace(FakedFont face, LayoutContext* ctx); // Lay out a single bidi run void doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, @@ -125,7 +126,7 @@ private: std::vector mAdvances; const FontCollection* mCollection; - std::vector mFaces; + std::vector mFaces; float mAdvance; MinikinRect mBounds; }; diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 9ff08a95f0..7915ef2e0a 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -18,6 +18,7 @@ #define MINIKIN_FONT_H #include +#include // An abstraction for platform fonts, allowing Minikin to be used with // multiple actual implementations of fonts. @@ -34,6 +35,7 @@ struct MinikinPaint { float scaleX; float skewX; uint32_t paintFlags; + FontFakery fakery; }; struct MinikinRect { diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index c13670e74a..6115ecc3b4 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -52,7 +52,7 @@ FontCollection::FontCollection(const vector& typefaces) : FontInstance* instance = &mInstances.back(); instance->mFamily = family; instance->mCoverage = new SparseBitSet; - MinikinFont* typeface = family->getClosestMatch(defaultStyle); + MinikinFont* typeface = family->getClosestMatch(defaultStyle).font; if (typeface == NULL) { ALOGE("FontCollection: closest match was null"); // TODO: we shouldn't hit this, as there should be more robust @@ -171,11 +171,9 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty result->push_back(dummy); run = &result->back(); if (instance == NULL) { - run->font = NULL; // maybe we should do something different here + run->fakedFont.font = NULL; } else { - run->font = instance->mFamily->getClosestMatch(style); - // TODO: simplify refcounting (FontCollection lifetime dominates) - run->font->RefLocked(); + run->fakedFont = instance->mFamily->getClosestMatch(style); } lastInstance = instance; run->start = i; @@ -186,13 +184,16 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } MinikinFont* FontCollection::baseFont(FontStyle style) { + return baseFontFaked(style).font; +} + +FakedFont FontCollection::baseFontFaked(FontStyle style) { if (mInstances.empty()) { - return NULL; + return FakedFont(); } return mInstances[0].mFamily->getClosestMatch(style); } - uint32_t FontCollection::getId() const { return mId; } diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 0fb98ae4e7..9106f63c3e 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -109,7 +109,7 @@ void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { type } // Compute a matching metric between two styles - 0 is an exact match -int computeMatch(FontStyle style1, FontStyle style2) { +static int computeMatch(FontStyle style1, FontStyle style2) { if (style1 == style2) return 0; int score = abs(style1.getWeight() - style2.getWeight()); if (style1.getItalic() != style2.getItalic()) { @@ -118,7 +118,15 @@ int computeMatch(FontStyle style1, FontStyle style2) { return score; } -MinikinFont* FontFamily::getClosestMatch(FontStyle style) const { +static FontFakery computeFakery(FontStyle wanted, FontStyle actual) { + // If desired weight is 2 or more grades higher than actual + // (for example, medium 500 -> bold 700), then select fake bold. + bool isFakeBold = (wanted.getWeight() - actual.getWeight()) >= 2; + bool isFakeItalic = wanted.getItalic() && !actual.getItalic(); + return FontFakery(isFakeBold, isFakeItalic); +} + +FakedFont FontFamily::getClosestMatch(FontStyle style) const { const Font* bestFont = NULL; int bestMatch = 0; for (size_t i = 0; i < mFonts.size(); i++) { @@ -129,7 +137,14 @@ MinikinFont* FontFamily::getClosestMatch(FontStyle style) const { bestMatch = match; } } - return bestFont == NULL ? NULL : bestFont->typeface; + FakedFont result; + if (bestFont == NULL) { + result.font = NULL; + } else { + result.font = bestFont->typeface; + result.fakery = computeFakery(style, bestFont->style); + } + return result; } size_t FontFamily::getNumFonts() const { diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 3cab673577..709393dc31 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -328,10 +328,10 @@ void Layout::dump() const { } } -int Layout::findFace(MinikinFont* face, LayoutContext* ctx) { +int Layout::findFace(FakedFont face, LayoutContext* ctx) { unsigned int ix; for (ix = 0; ix < mFaces.size(); ix++) { - if (mFaces[ix] == face) { + if (mFaces[ix].font == face.font) { return ix; } } @@ -339,7 +339,7 @@ int Layout::findFace(MinikinFont* face, LayoutContext* ctx) { // Note: ctx == NULL means we're copying from the cache, no need to create // corresponding hb_font object. if (ctx != NULL) { - hb_font_t* font = create_hb_font(face, &ctx->paint); + hb_font_t* font = create_hb_font(face.font, &ctx->paint); ctx->hbFonts.push_back(font); } return ix; @@ -631,12 +631,13 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t float y = 0; for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { FontCollection::Run &run = items[run_ix]; - if (run.font == NULL) { + if (run.fakedFont.font == NULL) { ALOGE("no font for run starting u+%04x length %d", buf[run.start], run.end - run.start); continue; } - int font_ix = findFace(run.font, ctx); - ctx->paint.font = mFaces[font_ix]; + int font_ix = findFace(run.fakedFont, ctx); + ctx->paint.font = mFaces[font_ix].font; + ctx->paint.fakery = mFaces[font_ix].fakery; hb_font_t* hbFont = ctx->hbFonts[font_ix]; #ifdef VERBOSE std::cout << "Run " << run_ix << ", font " << font_ix << @@ -729,7 +730,7 @@ void Layout::draw(Bitmap* surface, int x0, int y0, float size) const { */ for (size_t i = 0; i < mGlyphs.size(); i++) { const LayoutGlyph& glyph = mGlyphs[i]; - MinikinFont* mf = mFaces[glyph.font_ix]; + MinikinFont* mf = mFaces[glyph.font_ix].font; MinikinFontFreeType* face = static_cast(mf); GlyphBitmap glyphBitmap; MinikinPaint paint; @@ -754,7 +755,12 @@ size_t Layout::nGlyphs() const { MinikinFont* Layout::getFont(int i) const { const LayoutGlyph& glyph = mGlyphs[i]; - return mFaces[glyph.font_ix]; + return mFaces[glyph.font_ix].font; +} + +FontFakery Layout::getFakery(int i) const { + const LayoutGlyph& glyph = mGlyphs[i]; + return mFaces[glyph.font_ix].fakery; } unsigned int Layout::getGlyphId(int i) const { From 43e8943dfd9812fdf1f62e05f61ef85a2a0868f6 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 11 Jun 2014 15:02:11 -0700 Subject: [PATCH 034/364] Fix missing text on nonexistent font file Fix for bug 15570313 "Missing text on nonexistent font file" This patch makes sure that the lastChar and mInstances arrays are in sync with each other even when a FontFamily being added has no valid fonts in it. Previously, when they got out of sync, unicode coverage calculation would be wrong, resulting in missing text. Change-Id: I69c727ef69e2c61e2b2d6b81d5a28c806327f865 --- engine/src/flutter/libs/minikin/FontCollection.cpp | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 6115ecc3b4..45e5d06032 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -46,12 +46,6 @@ FontCollection::FontCollection(const vector& typefaces) : const FontStyle defaultStyle; for (size_t i = 0; i < nTypefaces; i++) { FontFamily* family = typefaces[i]; - family->RefLocked(); - FontInstance dummy; - mInstances.push_back(dummy); // emplace_back would be better - FontInstance* instance = &mInstances.back(); - instance->mFamily = family; - instance->mCoverage = new SparseBitSet; MinikinFont* typeface = family->getClosestMatch(defaultStyle).font; if (typeface == NULL) { ALOGE("FontCollection: closest match was null"); @@ -59,6 +53,12 @@ FontCollection::FontCollection(const vector& typefaces) : // checks upstream to prevent empty/invalid FontFamily objects continue; } + family->RefLocked(); + FontInstance dummy; + mInstances.push_back(dummy); // emplace_back would be better + FontInstance* instance = &mInstances.back(); + instance->mFamily = family; + instance->mCoverage = new SparseBitSet; #ifdef VERBOSE_DEBUG ALOGD("closest match = %p, family size = %d\n", typeface, family->getNumFonts()); #endif @@ -75,6 +75,7 @@ FontCollection::FontCollection(const vector& typefaces) : mMaxChar = max(mMaxChar, instance->mCoverage->length()); lastChar.push_back(instance->mCoverage->nextSetBit(0)); } + nTypefaces = mInstances.size(); size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage; size_t offset = 0; for (size_t i = 0; i < nPages; i++) { From 0f8e4702a5aa8c43f3efa3643680dca9f45a1edd Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 12 Jun 2014 09:19:03 -0700 Subject: [PATCH 035/364] Tighten requirements for fake bold The simple predicate for fake bold (2 or more grades darker than requested) was applying it to thin (100 weight) when normal was requested. This patch tightens the predicate to also require that the requested weight be in the bold range. Fix for bug 15588352 "sans-serif-thin doesn't work on lockscreen" Change-Id: Id9988bd149a9c8a7c943e3b221f7fb4b37fb6ddb --- engine/src/flutter/libs/minikin/FontFamily.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 9106f63c3e..ad8120f752 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -119,9 +119,11 @@ static int computeMatch(FontStyle style1, FontStyle style2) { } static FontFakery computeFakery(FontStyle wanted, FontStyle actual) { - // If desired weight is 2 or more grades higher than actual - // (for example, medium 500 -> bold 700), then select fake bold. - bool isFakeBold = (wanted.getWeight() - actual.getWeight()) >= 2; + // If desired weight is bold or darker, and 2 or more grades higher + // than actual (for example, medium 500 -> bold 700), then select + // fake bold. + int wantedWeight = wanted.getWeight(); + bool isFakeBold = wantedWeight >= 7 && (wantedWeight - actual.getWeight()) >= 2; bool isFakeItalic = wanted.getItalic() && !actual.getItalic(); return FontFakery(isFakeBold, isFakeItalic); } From e88f8c37c740a317f11d407d48aaacdfdad56395 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 12 Jun 2014 09:19:03 -0700 Subject: [PATCH 036/364] Tighten requirements for fake bold The simple predicate for fake bold (2 or more grades darker than requested) was applying it to thin (100 weight) when normal was requested. This patch tightens the predicate to also require that the requested weight be in the bold range. Fix for bug 15588352 "sans-serif-thin doesn't work on lockscreen" Change-Id: Id9988bd149a9c8a7c943e3b221f7fb4b37fb6ddb (cherry picked from commit 0f8e4702a5aa8c43f3efa3643680dca9f45a1edd) --- engine/src/flutter/libs/minikin/FontFamily.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 9106f63c3e..ad8120f752 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -119,9 +119,11 @@ static int computeMatch(FontStyle style1, FontStyle style2) { } static FontFakery computeFakery(FontStyle wanted, FontStyle actual) { - // If desired weight is 2 or more grades higher than actual - // (for example, medium 500 -> bold 700), then select fake bold. - bool isFakeBold = (wanted.getWeight() - actual.getWeight()) >= 2; + // If desired weight is bold or darker, and 2 or more grades higher + // than actual (for example, medium 500 -> bold 700), then select + // fake bold. + int wantedWeight = wanted.getWeight(); + bool isFakeBold = wantedWeight >= 7 && (wantedWeight - actual.getWeight()) >= 2; bool isFakeItalic = wanted.getItalic() && !actual.getItalic(); return FontFakery(isFakeBold, isFakeItalic); } From ba5dbb6f240993b6dd957d7ecfe9a6f984665c9a Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 19 Jun 2014 01:51:47 -0700 Subject: [PATCH 037/364] Make font runs less sticky Fixes b/15734816 In the text "Wi-Fi", "-Fi" appears bolder than "Wi" The problem was caused by "stickiness" in choosing fonts, where layout would prefer using a font used for preceding characters as long as it mapped the following characters in a run, in favor of the "best match" rules. This patch adds a whitelist for making the stickiness more conservative, only applying it for characters necessary for correct shaping (ZWJ and ZWNJ in particular) and basic punctuation, where it is desirable to match the style of the preceding text. Change-Id: I1cf116879f074a5a71c351846707bfdd07b0d320 --- .../flutter/libs/minikin/FontCollection.cpp | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 45e5d06032..348c5dc273 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -147,6 +147,20 @@ const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t return bestInstance; } +const uint32_t NBSP = 0xa0; +const uint32_t ZWJ = 0x200c; +const uint32_t ZWNJ = 0x200d; +// Characters where we want to continue using existing font run instead of +// recomputing the best match in the fallback list. +static const uint32_t stickyWhitelist[] = { '!', ',', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ }; + +static bool isStickyWhitelisted(uint32_t c) { + for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) { + if (stickyWhitelist[i] == c) return true; + } + return false; +} + void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style, vector* result) const { FontLanguage lang = style.getLanguage(); @@ -164,8 +178,9 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty nShorts = 2; } } - // Continue using existing font as long as it has coverage. - if (lastInstance == NULL || !lastInstance->mCoverage->get(ch)) { + // Continue using existing font as long as it has coverage and is whitelisted + if (lastInstance == NULL + || !(isStickyWhitelisted(ch) && lastInstance->mCoverage->get(ch))) { const FontInstance* instance = getInstanceForChar(ch, lang, variant); if (i == 0 || instance != lastInstance) { Run dummy; From e8bed5d3cc78d61cbbdf63b6439cee68613a908b Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Sun, 15 Jun 2014 17:33:29 -0700 Subject: [PATCH 038/364] Implement grapheme cluster breaking This patch includes an implementation of grapheme cluster breaking, which is especially useful for repositioning the cursor for left and right arrow key presses. The implementation is closely based on Unicode TR29, and uses the ICU grapheme cluster break property, but is tailored to more closely match the existing implementation and expected behavior. Part of a fix for b/15653110 Improve behavior of arrow keys in EditText Change-Id: I8eb742f77039c9ab7b2838285018cf8a8fc88343 --- .../flutter/include/minikin/GraphemeBreak.h | 47 +++++++ engine/src/flutter/libs/minikin/Android.mk | 1 + .../flutter/libs/minikin/GraphemeBreak.cpp | 132 ++++++++++++++++++ 3 files changed, 180 insertions(+) create mode 100644 engine/src/flutter/include/minikin/GraphemeBreak.h create mode 100644 engine/src/flutter/libs/minikin/GraphemeBreak.cpp diff --git a/engine/src/flutter/include/minikin/GraphemeBreak.h b/engine/src/flutter/include/minikin/GraphemeBreak.h new file mode 100644 index 0000000000..3120101585 --- /dev/null +++ b/engine/src/flutter/include/minikin/GraphemeBreak.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2014 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_GRAPHEME_BREAK_H +#define MINIKIN_GRAPHEME_BREAK_H + +namespace android { + +class GraphemeBreak { +public: + // These values must be kept in sync with CURSOR_AFTER etc in Paint.java + enum MoveOpt { + AFTER = 0, + AT_OR_AFTER = 1, + BEFORE = 2, + AT_OR_BEFORE = 3, + AT = 4 + }; + + // Determine whether the given offset is a grapheme break. + // This implementation generally follows Unicode TR29 extended + // grapheme break, but with some tweaks to more closely match + // existing implementations. + static bool isGraphemeBreak(const uint16_t* buf, size_t start, size_t count, size_t offset); + + // Matches Android's Java API. Note, return (size_t)-1 for AT to + // signal non-break because unsigned return type. + static size_t getTextRunCursor(const uint16_t* buf, size_t start, size_t count, + size_t offset, MoveOpt opt); +}; + +} // namespace android + +#endif // MINIKIN_GRAPHEME_BREAK_H \ No newline at end of file diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index a1d88c29e5..fd949c2a90 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -23,6 +23,7 @@ LOCAL_SRC_FILES := \ CssParse.cpp \ FontCollection.cpp \ FontFamily.cpp \ + GraphemeBreak.cpp \ Layout.cpp \ MinikinInternal.cpp \ MinikinRefCounted.cpp \ diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp new file mode 100644 index 0000000000..5d8978d66f --- /dev/null +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -0,0 +1,132 @@ +/* + * Copyright (C) 2014 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 +#include +#include + +#include + +namespace android { + +bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t count, + size_t offset) { + // This implementation closely follows Unicode Standard Annex #29 on + // Unicode Text Segmentation (http://www.unicode.org/reports/tr29/), + // implementing a tailored version of extended grapheme clusters. + // The GB rules refer to section 3.1.1, Grapheme Cluster Boundary Rules. + + // Rule GB1, sot /; Rule GB2, / eot + if (offset <= start || offset >= start + count) { + return true; + } + if (U16_IS_TRAIL(buf[offset])) { + // Don't break a surrogate pair + return false; + } + uint32_t c1 = 0; + uint32_t c2 = 0; + size_t offset_back = offset; + U16_PREV(buf, start, offset_back, c1); + U16_NEXT(buf, offset, count, c2); + int32_t p1 = u_getIntPropertyValue(c1, UCHAR_GRAPHEME_CLUSTER_BREAK); + int32_t p2 = u_getIntPropertyValue(c2, UCHAR_GRAPHEME_CLUSTER_BREAK); + // Rule GB3, CR x LF + if (p1 == U_GCB_CR && p2 == U_GCB_LF) { + return false; + } + // Rule GB4, (Control | CR | LF) / + if (p1 == U_GCB_CONTROL || p1 == U_GCB_CR || p1 == U_GCB_LF) { + return true; + } + // Rule GB5, / (Control | CR | LF) + if (p2 == U_GCB_CONTROL || p2 == U_GCB_CR || p2 == U_GCB_LF) { + // exclude zero-width control characters from breaking (tailoring of TR29) + if (c2 == 0x00ad + || (c2 >= 0x200b && c2 <= 0x200f) + || (c2 >= 0x2028 && c2 <= 0x202e) + || (c2 >= 0x2060 && c2 <= 0x206f)) { + return false; + } + return true; + } + // Rule GB6, L x ( L | V | LV | LVT ) + if (p1 == U_GCB_L && (p2 == U_GCB_L || p2 == U_GCB_V || p2 == U_GCB_LV || p2 == U_GCB_LVT)) { + return false; + } + // Rule GB7, ( LV | V ) x ( V | T ) + if ((p1 == U_GCB_LV || p1 == U_GCB_V) && (p2 == U_GCB_V || p2 == U_GCB_T)) { + return false; + } + // Rule GB8, ( LVT | T ) x T + if ((p1 == U_GCB_L || p1 == U_GCB_T) && p2 == U_GCB_T) { + return false; + } + // Rule GB8a, Regional_Indicator x Regional_Indicator + if (p1 == U_GCB_REGIONAL_INDICATOR && p2 == U_GCB_REGIONAL_INDICATOR) { + return false; + } + // Rule GB9, x Extend; Rule GB9a, x SpacingMark + if (p2 == U_GCB_EXTEND || p2 == U_GCB_SPACING_MARK) { + if (c2 == 0xe33) { + // most other implementations break THAI CHARACTER SARA AM + // (tailoring of TR29) + return true; + } + return false; + } + // Cluster indic syllables togeter (tailoring of TR29) + if (u_getIntPropertyValue(c1, UCHAR_CANONICAL_COMBINING_CLASS) == 9 // virama + && u_getIntPropertyValue(c2, UCHAR_GENERAL_CATEGORY) == U_OTHER_LETTER) { + return false; + } + // Rule GB10, Any / Any + return true; +} + +size_t GraphemeBreak::getTextRunCursor(const uint16_t* buf, size_t start, size_t count, + size_t offset, MoveOpt opt) { + switch (opt) { + case AFTER: + if (offset < start + count) { + offset++; + } + // fall through + case AT_OR_AFTER: + while (!isGraphemeBreak(buf, start, count, offset)) { + offset++; + } + break; + case BEFORE: + if (offset > start) { + offset--; + } + // fall through + case AT_OR_BEFORE: + while (!isGraphemeBreak(buf, start, count, offset)) { + offset--; + } + break; + case AT: + if (!isGraphemeBreak(buf, start, count, offset)) { + offset = (size_t)-1; + } + break; + } + return offset; +} + +} // namespace android From 69f3585cf6f6ceac263e10b4d06bb0eb05a5ddbc Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 25 Jun 2014 15:58:24 -0700 Subject: [PATCH 039/364] Add purgeCaches() method Expose a method to purge caches used for TextLayout, useful for low memory conditions. Change-Id: I92f41afe987b7be4af5ca0a0c50fb51be35a2758 --- engine/src/flutter/include/minikin/Layout.h | 3 +++ engine/src/flutter/libs/minikin/Layout.cpp | 8 ++++++++ 2 files changed, 11 insertions(+) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 1b91ad87fe..e30f2f2496 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -100,6 +100,9 @@ public: void getBounds(MinikinRect* rect); + // Purge all caches, useful in low memory conditions + static void purgeCaches(); + private: // Find a face in the mFaces vector, or create a new entry int findFace(FakedFont face, LayoutContext* ctx); diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 762a7dbbfa..48db129cf7 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -799,4 +799,12 @@ void Layout::getBounds(MinikinRect* bounds) { bounds->set(mBounds); } +void Layout::purgeCaches() { + AutoMutex _l(gMinikinLock); + LayoutCache& layoutCache = LayoutEngine::getInstance().layoutCache; + layoutCache.mCache.clear(); + HbFaceCache& hbCache = LayoutEngine::getInstance().hbFaceCache; + hbCache.mCache.clear(); +} + } // namespace android From 05d59ee4621458fc2e9d6ce227e1ae39bd101d3b Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 26 Jun 2014 14:00:43 -0700 Subject: [PATCH 040/364] Disable "palt" OpenType feature Proper Japanese layout requires sophisticated rules for spacing punctuation, not just turning on the "palt" (proportional alternate) feature. Until we can support the whole set, roll back palt. Change-Id: If2359c529b70b1dd45dddc00e5f4aa1c91f8b0e9 --- engine/src/flutter/libs/minikin/Layout.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 48db129cf7..01b6599628 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -621,7 +621,13 @@ void Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_ static void addFeatures(vector* features) { // hardcoded features, to be repaced with more flexible configuration static hb_feature_t palt = { HB_TAG('p', 'a', 'l', 't'), 1, 0, ~0u }; + + // Don't enable "palt" for now, pending implementation of more of the + // W3C Japanese layout recommendations. See: + // http://www.w3.org/TR/2012/NOTE-jlreq-20120403/ +#if 0 features->push_back(palt); +#endif } void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, From f9490880cc5f4363360ec02b8e818d245346b97f Mon Sep 17 00:00:00 2001 From: Mike Reed Date: Mon, 7 Jul 2014 10:59:40 -0400 Subject: [PATCH 041/364] setConfig is deprecated Change-Id: Iffad3ef724b565d5d8fed17722630fd74cda9234 --- engine/src/flutter/sample/example_skia.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index e686621c34..1a6aa2362f 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -125,11 +125,10 @@ int runMinikinTest() { SkAutoGraphics ag; - SkScalar width = 800; - SkScalar height = 600; + int width = 800; + int height = 600; SkBitmap bitmap; - bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height); - bitmap.allocPixels(); + bitmap.allocN32Pixels(width, height); SkCanvas canvas(bitmap); SkPaint paint; paint.setARGB(255, 0, 0, 128); From 293208bda839a5726e294a22c85b1c9e1c4b9844 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 7 Jul 2014 14:59:04 -0700 Subject: [PATCH 042/364] Assign non-coverage font runs to base font When a run has no cmap coverage in any font, use the base font. Most of the time, this will cause rendering of the .notdef glyph, which is preferable to displaying nothing. In some cases, Harfbuzz may be able to decompose the characters (not in the cmap) to ones that are, in which case we'll render those, as long as they're in the base font. Bug: 6629748 Bug: 15816880 Change-Id: Ibb1b9242c83626e0c7db363ad65ce44a967a005e --- engine/src/flutter/libs/minikin/FontCollection.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 348c5dc273..a6977fd6c6 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -48,9 +48,6 @@ FontCollection::FontCollection(const vector& typefaces) : FontFamily* family = typefaces[i]; MinikinFont* typeface = family->getClosestMatch(defaultStyle).font; if (typeface == NULL) { - ALOGE("FontCollection: closest match was null"); - // TODO: we shouldn't hit this, as there should be more robust - // checks upstream to prevent empty/invalid FontFamily objects continue; } family->RefLocked(); @@ -76,6 +73,8 @@ FontCollection::FontCollection(const vector& typefaces) : lastChar.push_back(instance->mCoverage->nextSetBit(0)); } nTypefaces = mInstances.size(); + LOG_ALWAYS_FATAL_IF(nTypefaces == 0, + "Font collection must have at least one valid typeface"); size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage; size_t offset = 0; for (size_t i = 0; i < nPages; i++) { @@ -144,6 +143,9 @@ const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t } } } + if (bestInstance == NULL) { + bestInstance = &mInstances[0]; + } return bestInstance; } From b6138e6653b4fd735044b9e27496d4cb7a273900 Mon Sep 17 00:00:00 2001 From: Elliott Hughes Date: Thu, 10 Jul 2014 10:39:07 -0700 Subject: [PATCH 043/364] Switch minikin to the new icu. Change-Id: I29a59edfe6102257c9f308aac1b4348ef7a18db7 --- engine/src/flutter/libs/minikin/Android.mk | 2 +- engine/src/flutter/sample/Android.mk | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index fd949c2a90..fde2cbbbf4 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -35,7 +35,7 @@ LOCAL_MODULE := libminikin LOCAL_C_INCLUDES += \ external/harfbuzz_ng/src \ external/freetype/include \ - external/icu4c/common \ + external/icu/icu4c/source/common \ frameworks/minikin/include LOCAL_SHARED_LIBRARIES := \ diff --git a/engine/src/flutter/sample/Android.mk b/engine/src/flutter/sample/Android.mk index a19019ad82..ec06e3852a 100644 --- a/engine/src/flutter/sample/Android.mk +++ b/engine/src/flutter/sample/Android.mk @@ -22,7 +22,7 @@ LOCAL_MODULE_TAGS := tests LOCAL_C_INCLUDES += \ external/harfbuzz_ng/src \ external/freetype/include \ - external/icu4c/common \ + external/icu/icu4c/source/common \ frameworks/minikin/include LOCAL_SRC_FILES:= example.cpp @@ -52,7 +52,7 @@ LOCAL_MODULE_TAG := tests LOCAL_C_INCLUDES += \ external/harfbuzz_ng/src \ external/freetype/include \ - external/icu4c/common \ + external/icu/icu4c/source/common \ frameworks/minikin/include \ external/skia/src/core From da0c3511e311a406e2c804f498449afc098a2a98 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 10 Jul 2014 17:48:37 -0400 Subject: [PATCH 044/364] Use __builtin_clzl if element is long Change-Id: I50a112739847fa826088854f6d172a188ff4cfb3 --- engine/src/flutter/libs/minikin/SparseBitSet.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp index e0b3c1d5a7..7acb7ba345 100644 --- a/engine/src/flutter/libs/minikin/SparseBitSet.cpp +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -105,9 +105,9 @@ void SparseBitSet::initFromRanges(const uint32_t* ranges, size_t nRanges) { } } -// Note: this implementation depends on GCC builtin, and also assumes 32-bit elements. int SparseBitSet::CountLeadingZeros(element x) { - return __builtin_clz(x); + // Note: GCC / clang builtin + return sizeof(element) <= sizeof(int) ? __builtin_clz(x) : __builtin_clzl(x); } uint32_t SparseBitSet::nextSetBit(uint32_t fromIndex) const { From 29eb45e667be81d37f29fcce2adccb8c5e6d5ada Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Fri, 11 Jul 2014 11:30:06 -0400 Subject: [PATCH 045/364] Don't pass invalid Unicode codepoint to Skia Bug: 15849380 Change-Id: Ib5285e57c5806bd399600fadd56e8bc809da323f --- engine/src/flutter/libs/minikin/Layout.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 01b6599628..21b8362260 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -258,6 +258,12 @@ static hb_bool_t harfbuzzGetGlyph(hb_font_t* hbFont, void* fontData, hb_codepoin MinikinPaint* paint = reinterpret_cast(fontData); MinikinFont* font = paint->font; uint32_t glyph_id; + /* HarfBuzz replaces broken input codepoints with (unsigned int) -1. + * Skia expects valid Unicode. + * Replace invalid codepoints with U+FFFD REPLACEMENT CHARACTER. + */ + if (unicode > 0x10FFFF) + unicode = 0xFFFD; bool ok = font->GetGlyph(unicode, &glyph_id); if (ok) { *glyph = glyph_id; From 7043f8f1fc2476e5b9bf076fe434cd5f1283a5db Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 17 Jul 2014 19:47:01 -0400 Subject: [PATCH 046/364] Add letter-spacing support Bug: 15594400 Change-Id: Ied94d7674be4097b0f44c9b0770d3294dc6433c1 --- engine/src/flutter/include/minikin/CssParse.h | 2 + .../src/flutter/include/minikin/MinikinFont.h | 1 + engine/src/flutter/libs/minikin/CssParse.cpp | 1 + engine/src/flutter/libs/minikin/Layout.cpp | 45 +++++++++++++++++-- 4 files changed, 45 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/include/minikin/CssParse.h b/engine/src/flutter/include/minikin/CssParse.h index ea28b81ad9..259b933a54 100644 --- a/engine/src/flutter/include/minikin/CssParse.h +++ b/engine/src/flutter/include/minikin/CssParse.h @@ -30,6 +30,7 @@ enum CssTag { fontStyle, fontWeight, cssLang, + letterSpacing, minikinBidi, minikinHinting, minikinVariant, @@ -44,6 +45,7 @@ const std::string cssTagNames[] = { "font-style", "font-weight", "lang", + "letter-spacing", "-minikin-bidi", "-minikin-hinting", "-minikin-variant", diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 7915ef2e0a..935d4bb0b3 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -34,6 +34,7 @@ struct MinikinPaint { float size; float scaleX; float skewX; + float letterSpacing; uint32_t paintFlags; FontFakery fakery; }; diff --git a/engine/src/flutter/libs/minikin/CssParse.cpp b/engine/src/flutter/libs/minikin/CssParse.cpp index 8168a748d2..057dab7e82 100644 --- a/engine/src/flutter/libs/minikin/CssParse.cpp +++ b/engine/src/flutter/libs/minikin/CssParse.cpp @@ -44,6 +44,7 @@ static CssTag parseTag(const string str, size_t off, size_t len) { if (strEqC(str, off, len, "font-style")) return fontStyle; } else if (c == 'l') { if (strEqC(str, off, len, "lang")) return cssLang; + if (strEqC(str, off, len, "letter-spacing")) return letterSpacing; } else if (c == '-') { if (strEqC(str, off, len, "-minikin-bidi")) return minikinBidi; if (strEqC(str, off, len, "-minikin-hinting")) return minikinHinting; diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 21b8362260..5125a32f9b 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -64,6 +64,7 @@ public: const uint16_t* chars, size_t start, size_t count, size_t nchars, bool dir) : mStart(start), mCount(count), mId(collection->getId()), mStyle(style), mSize(paint.size), mScaleX(paint.scaleX), mSkewX(paint.skewX), + mLetterSpacing(paint.letterSpacing), mPaintFlags(paint.paintFlags), mIsRtl(dir) { mText.setTo(chars, nchars); } @@ -81,6 +82,7 @@ private: float mSize; float mScaleX; float mSkewX; + float mLetterSpacing; int32_t mPaintFlags; bool mIsRtl; // Note: any fields added to MinikinPaint must also be reflected here. @@ -144,6 +146,7 @@ bool LayoutCacheKey::operator==(const LayoutCacheKey& other) const { && mSize == other.mSize && mScaleX == other.mScaleX && mSkewX == other.mSkewX + && mLetterSpacing == other.mLetterSpacing && mPaintFlags == other.mPaintFlags && mIsRtl == other.mIsRtl && mText == other.mText; @@ -157,6 +160,7 @@ hash_t LayoutCacheKey::hash() const { hash = JenkinsHashMix(hash, hash_type(mSize)); hash = JenkinsHashMix(hash, hash_type(mScaleX)); hash = JenkinsHashMix(hash, hash_type(mSkewX)); + hash = JenkinsHashMix(hash, hash_type(mLetterSpacing)); hash = JenkinsHashMix(hash, hash_type(mPaintFlags)); hash = JenkinsHashMix(hash, hash_type(mIsRtl)); hash = JenkinsHashMixShorts(hash, mText.string(), mText.size()); @@ -511,6 +515,8 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu ? ctx.props.value(fontScaleX).getDoubleValue() : 1; ctx.paint.skewX = ctx.props.hasTag(fontSkewX) ? ctx.props.value(fontSkewX).getDoubleValue() : 0; + ctx.paint.letterSpacing = ctx.props.hasTag(letterSpacing) + ? ctx.props.value(letterSpacing).getDoubleValue() : 0; ctx.paint.paintFlags = ctx.props.hasTag(paintFlags) ? ctx.props.value(paintFlags).getUintValue() : 0; int bidiFlags = ctx.props.hasTag(minikinBidi) ? ctx.props.value(minikinBidi).getIntValue() : 0; @@ -646,8 +652,25 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t } vector features; + // Disable default-on non-required ligature features if letter-spacing + // See http://dev.w3.org/csswg/css-text-3/#letter-spacing-property + // "When the effective spacing between two characters is not zero (due to + // either justification or a non-zero value of letter-spacing), user agents + // should not apply optional ligatures." + if (fabs(ctx->paint.letterSpacing) > 0.03) + { + static const hb_feature_t no_liga = { HB_TAG('l', 'i', 'g', 'a'), 0, 0, ~0u }; + static const hb_feature_t no_clig = { HB_TAG('c', 'l', 'i', 'g'), 0, 0, ~0u }; + features.push_back(no_liga); + features.push_back(no_clig); + } addFeatures(&features); + double size = ctx->paint.size; + double scaleX = ctx->paint.scaleX; + double letterSpace = ctx->paint.letterSpacing * size * scaleX; + double letterSpaceHalf = letterSpace * .5; + float x = mAdvance; float y = 0; for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { @@ -664,8 +687,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t std::cout << "Run " << run_ix << ", font " << font_ix << " [" << run.start << ":" << run.end << "]" << std::endl; #endif - double size = ctx->paint.size; - double scaleX = ctx->paint.scaleX; + hb_font_set_ppem(hbFont, size * scaleX, size); hb_font_set_scale(hbFont, HBFloatToFixed(size * scaleX), HBFloatToFixed(size)); @@ -689,11 +711,22 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t unsigned int numGlyphs; hb_glyph_info_t* info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); hb_glyph_position_t* positions = hb_buffer_get_glyph_positions(buffer, NULL); + if (numGlyphs) + { + mAdvances[info[0].cluster - start] += letterSpaceHalf; + x += letterSpaceHalf; + } for (unsigned int i = 0; i < numGlyphs; i++) { #ifdef VERBOSE std::cout << positions[i].x_advance << " " << positions[i].y_advance << " " << positions[i].x_offset << " " << positions[i].y_offset << std::endl; std::cout << "DoLayout " << info[i].codepoint << ": " << HBFixedToFloat(positions[i].x_advance) << "; " << positions[i].x_offset << ", " << positions[i].y_offset << std::endl; #endif + if (i > 0 && info[i - 1].cluster != info[i].cluster) { + mAdvances[info[i - 1].cluster - start] += letterSpaceHalf; + mAdvances[info[i].cluster - start] += letterSpaceHalf; + x += letterSpaceHalf; + } + hb_codepoint_t glyph_ix = info[i].codepoint; float xoff = HBFixedToFloat(positions[i].x_offset); float yoff = -HBFixedToFloat(positions[i].y_offset); @@ -705,10 +738,14 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t ctx->paint.font->GetBounds(&glyphBounds, glyph_ix, ctx->paint); glyphBounds.offset(x + xoff, y + yoff); mBounds.join(glyphBounds); - size_t cluster = info[i].cluster - start; - mAdvances[cluster] += xAdvance; + mAdvances[info[i].cluster - start] += xAdvance; x += xAdvance; } + if (numGlyphs) + { + mAdvances[info[numGlyphs - 1].cluster - start] += letterSpaceHalf; + x += letterSpaceHalf; + } } } mAdvance = x; From ca5b3e16760ba111efbe43324801dc2b1a74e115 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Fri, 25 Jul 2014 17:31:46 +0000 Subject: [PATCH 047/364] Revert "Don't pass invalid Unicode codepoint to Skia" After update to HarfBuzz 0.9.33 we don't need this anymore. HarfBuzz takes care of invalid input and passes U+FFFD to us. This reverts commit 29eb45e667be81d37f29fcce2adccb8c5e6d5ada. Change-Id: Icfd0dc836a8d684fb1723fc215aa01f99639ff59 --- engine/src/flutter/libs/minikin/Layout.cpp | 6 ------ 1 file changed, 6 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 21b8362260..01b6599628 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -258,12 +258,6 @@ static hb_bool_t harfbuzzGetGlyph(hb_font_t* hbFont, void* fontData, hb_codepoin MinikinPaint* paint = reinterpret_cast(fontData); MinikinFont* font = paint->font; uint32_t glyph_id; - /* HarfBuzz replaces broken input codepoints with (unsigned int) -1. - * Skia expects valid Unicode. - * Replace invalid codepoints with U+FFFD REPLACEMENT CHARACTER. - */ - if (unicode > 0x10FFFF) - unicode = 0xFFFD; bool ok = font->GetGlyph(unicode, &glyph_id); if (ok) { *glyph = glyph_id; From ded72d1e4a2bd01048319e44293138a87f95bf28 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 24 Jul 2014 19:18:14 -0400 Subject: [PATCH 048/364] Remove deprecated API It has been unused outside minikin. Change-Id: Iaa2237767d81c77f90d0264e633375e601dd72f1 --- engine/src/flutter/include/minikin/Layout.h | 11 +---------- engine/src/flutter/libs/minikin/Layout.cpp | 9 --------- engine/src/flutter/sample/example.cpp | 4 ++-- engine/src/flutter/sample/example_skia.cpp | 4 ++-- 4 files changed, 5 insertions(+), 23 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index e30f2f2496..11e5819cd1 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -68,19 +68,13 @@ public: void dump() const; void setFontCollection(const FontCollection* collection); - // deprecated - missing functionality - void doLayout(const uint16_t* buf, size_t nchars); - void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, const std::string& css); void draw(Bitmap*, int x0, int y0, float size) const; - // deprecated - pass as argument to doLayout instead - void setProperties(const std::string& css); - // This must be called before any invocations. - // TODO: probably have a factory instead + // TODO: probably have a factory instead static void init(); // public accessors @@ -122,9 +116,6 @@ private: // Append another layout (for example, cached value) into this one void appendLayout(Layout* src, size_t start); - // deprecated - remove when setProperties is removed - std::string mCssString; - std::vector mGlyphs; std::vector mAdvances; diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 5125a32f9b..0715c76645 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -490,11 +490,6 @@ static size_t getNextWordBreak(const uint16_t* chars, size_t offset, size_t len) return len; } -// deprecated API, to avoid breaking client -void Layout::doLayout(const uint16_t* buf, size_t nchars) { - doLayout(buf, 0, nchars, nchars, mCssString); -} - static void clearHbFonts(LayoutContext* ctx) { for (size_t i = 0; i < ctx->hbFonts.size(); i++) { hb_font_destroy(ctx->hbFonts[i]); @@ -803,10 +798,6 @@ void Layout::draw(Bitmap* surface, int x0, int y0, float size) const { } } -void Layout::setProperties(const string& css) { - mCssString = css; -} - size_t Layout::nGlyphs() const { return mGlyphs.size(); } diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index b8bd66f4be..124729114f 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -83,10 +83,10 @@ int runMinikinTest() { FontCollection *collection = makeFontCollection(); Layout layout; layout.setFontCollection(collection); - layout.setProperties("font-size: 32;"); const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87"; + const char *style = "font-size: 32;"; icu::UnicodeString icuText = icu::UnicodeString::fromUTF8(text); - layout.doLayout(icuText.getBuffer(), icuText.length()); + layout.doLayout(icuText.getBuffer(), 0, icuText.length(), icuText.length(), style); layout.dump(); Bitmap bitmap(250, 50); layout.draw(&bitmap, 10, 40, 32); diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index 1a6aa2362f..4eb0a563ba 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -117,10 +117,10 @@ int runMinikinTest() { FontCollection *collection = makeFontCollection(); Layout layout; layout.setFontCollection(collection); - layout.setProperties("font-size: 32; font-weight: 700;"); const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87"; + const char *style = "font-size: 32; font-weight: 700;"; icu::UnicodeString icuText = icu::UnicodeString::fromUTF8(text); - layout.doLayout(icuText.getBuffer(), icuText.length()); + layout.doLayout(icuText.getBuffer(), 0, icuText.length(), icuText.length(), style); layout.dump(); SkAutoGraphics ag; From 675a078bdf6438986f6a153a0c92cf1e76ed976d Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 24 Jul 2014 20:26:03 -0400 Subject: [PATCH 049/364] Towards CSS removal Extract language from FontStyle during shaping. Don't attach CSS to LayoutContext. Change-Id: Ie621d3415410178d0d15fa7b810eb8e412342ab6 --- .../src/flutter/include/minikin/FontFamily.h | 4 +++ .../src/flutter/libs/minikin/FontFamily.cpp | 24 +++++++++++++- engine/src/flutter/libs/minikin/Layout.cpp | 32 ++++++++++--------- 3 files changed, 44 insertions(+), 16 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 060d1678c3..bcc2e3a59c 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -18,6 +18,7 @@ #define MINIKIN_FONT_FAMILY_H #include +#include #include @@ -39,6 +40,9 @@ public: FontLanguage(const char* buf, size_t size); bool operator==(const FontLanguage other) const { return mBits == other.mBits; } + operator bool() const { return mBits != 0; } + + std::string getString() const; // 0 = no match, 1 = language matches, 2 = language and script match int match(const FontLanguage other) const; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index ad8120f752..ab6ba20b3b 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -34,7 +34,7 @@ namespace android { FontLanguage::FontLanguage(const char* buf, size_t size) { uint32_t bits = 0; size_t i; - for (i = 0; i < size && buf[i] != '-' && buf[i] != '_'; i++) { + for (i = 0; i < size; i++) { uint16_t c = buf[i]; if (c == '-' || c == '_') break; } @@ -60,6 +60,28 @@ FontLanguage::FontLanguage(const char* buf, size_t size) { mBits = bits; } +std::string FontLanguage::getString() const { + char buf[16]; + size_t i = 0; + if (mBits & kBaseLangMask) { + buf[i++] = (mBits >> 8) & 0xFFu; + buf[i++] = mBits & 0xFFu; + } + if (mBits & kScriptMask) { + if (!i) + buf[i++] = 'x'; + buf[i++] = '-'; + buf[i++] = 'H'; + buf[i++] = 'a'; + buf[i++] = 'n'; + if (mBits & kHansFlag) + buf[i++] = 's'; + else + buf[i++] = 't'; + } + return std::string(buf, i); +} + int FontLanguage::match(const FontLanguage other) const { int result = 0; if ((mBits & kBaseLangMask) == (other.mBits & kBaseLangMask)) { diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 0715c76645..6611f0685e 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -170,7 +170,6 @@ hash_t LayoutCacheKey::hash() const { struct LayoutContext { MinikinPaint paint; FontStyle style; - CssProperties props; std::vector hbFonts; // parallel to mFaces }; @@ -502,19 +501,21 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu AutoMutex _l(gMinikinLock); LayoutContext ctx; - ctx.props.parse(css); - ctx.style = styleFromCss(ctx.props); + CssProperties props; + props.parse(css); - ctx.paint.size = ctx.props.value(fontSize).getDoubleValue(); - ctx.paint.scaleX = ctx.props.hasTag(fontScaleX) - ? ctx.props.value(fontScaleX).getDoubleValue() : 1; - ctx.paint.skewX = ctx.props.hasTag(fontSkewX) - ? ctx.props.value(fontSkewX).getDoubleValue() : 0; - ctx.paint.letterSpacing = ctx.props.hasTag(letterSpacing) - ? ctx.props.value(letterSpacing).getDoubleValue() : 0; - ctx.paint.paintFlags = ctx.props.hasTag(paintFlags) - ? ctx.props.value(paintFlags).getUintValue() : 0; - int bidiFlags = ctx.props.hasTag(minikinBidi) ? ctx.props.value(minikinBidi).getIntValue() : 0; + ctx.style = styleFromCss(props); + + ctx.paint.size = props.value(fontSize).getDoubleValue(); + ctx.paint.scaleX = props.hasTag(fontScaleX) + ? props.value(fontScaleX).getDoubleValue() : 1; + ctx.paint.skewX = props.hasTag(fontSkewX) + ? props.value(fontSkewX).getDoubleValue() : 0; + ctx.paint.letterSpacing = props.hasTag(letterSpacing) + ? props.value(letterSpacing).getDoubleValue() : 0; + ctx.paint.paintFlags = props.hasTag(paintFlags) + ? props.value(paintFlags).getUintValue() : 0; + int bidiFlags = props.hasTag(minikinBidi) ? props.value(minikinBidi).getIntValue() : 0; bool isRtl = (bidiFlags & kDirection_Mask) != 0; bool doSingleRun = true; @@ -697,8 +698,9 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_buffer_reset(buffer); hb_buffer_set_script(buffer, script); hb_buffer_set_direction(buffer, isRtl? HB_DIRECTION_RTL : HB_DIRECTION_LTR); - if (ctx->props.hasTag(cssLang)) { - string lang = ctx->props.value(cssLang).getStringValue(); + FontLanguage language = ctx->style.getLanguage(); + if (language) { + string lang = language.getString(); hb_buffer_set_language(buffer, hb_language_from_string(lang.c_str(), -1)); } hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); From abf2e7d050ef0355a6fbb199ddd11a5bc4ce848d Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Fri, 25 Jul 2014 14:49:27 -0400 Subject: [PATCH 050/364] Don't get stuck on invalid UTF-16 Replaces invalid unicode with replacement character U+FFFD and always makes forward progress. Bug: 15849380 Change-Id: Ic59ef6c64b0f5c4450bcae61597adcc269d6e7c5 --- engine/src/flutter/libs/minikin/Layout.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 0715c76645..6b019d401c 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -397,11 +397,10 @@ static hb_codepoint_t decodeUtf16(const uint16_t* chars, size_t len, ssize_t* it const hb_codepoint_t delta = (0xd800 << 10) + 0xdc00 - 0x10000; return (((hb_codepoint_t)v) << 10) + v2 - delta; } - (*iter) -= 2; - return ~0u; + (*iter) -= 1; + return 0xFFFDu; } else { - (*iter)--; - return ~0u; + return 0xFFFDu; } } else { return v; From bff381b1bedf7d9639a910e0d8d3bd38af28a7c2 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Tue, 29 Jul 2014 15:51:12 -0400 Subject: [PATCH 051/364] Remove CSS string doLayout entrypoint and supporting code All usage is ported to the new doLayout() API now. Bug: 16651112 Change-Id: I2c959138a69853b5e30098889d771fe5f4cfaa66 --- engine/src/flutter/include/minikin/CssParse.h | 108 --------- engine/src/flutter/include/minikin/Layout.h | 5 - engine/src/flutter/libs/minikin/Android.mk | 1 - engine/src/flutter/libs/minikin/CssParse.cpp | 210 ------------------ engine/src/flutter/libs/minikin/Layout.cpp | 45 ---- 5 files changed, 369 deletions(-) delete mode 100644 engine/src/flutter/include/minikin/CssParse.h delete mode 100644 engine/src/flutter/libs/minikin/CssParse.cpp diff --git a/engine/src/flutter/include/minikin/CssParse.h b/engine/src/flutter/include/minikin/CssParse.h deleted file mode 100644 index 259b933a54..0000000000 --- a/engine/src/flutter/include/minikin/CssParse.h +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Copyright (C) 2013 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef MINIKIN_CSS_PARSE_H -#define MINIKIN_CSS_PARSE_H - -#include -#include - -namespace android { - -enum CssTag { - unknown, - fontScaleX, - fontSize, - fontSkewX, - fontStyle, - fontWeight, - cssLang, - letterSpacing, - minikinBidi, - minikinHinting, - minikinVariant, - paintFlags, -}; - -const std::string cssTagNames[] = { - "unknown", - "font-scale-x", - "font-size", - "font-skew-x", - "font-style", - "font-weight", - "lang", - "letter-spacing", - "-minikin-bidi", - "-minikin-hinting", - "-minikin-variant", - "-paint-flags", -}; - -class CssValue { -public: - enum Type { - UNKNOWN, - DOUBLE, - STRING - }; - enum Units { - SCALAR, - PERCENT, - PX, - EM - }; - CssValue() : mType(UNKNOWN) { } - explicit CssValue(double v) : - mType(DOUBLE), doubleValue(v), mUnits(SCALAR) { } - Type getType() const { return mType; } - double getDoubleValue() const { return doubleValue; } - int32_t getIntValue() const { return doubleValue; } - uint32_t getUintValue() const { return doubleValue; } - std::string getStringValue() const { return stringValue; } - std::string toString(CssTag tag) const; - void setDoubleValue(double v) { - mType = DOUBLE; - doubleValue = v; - } - void setStringValue(const std::string& v) { - mType = STRING; - stringValue = v; - } -private: - Type mType; - double doubleValue; - std::string stringValue; - Units mUnits; -}; - -class CssProperties { -public: - bool parse(const std::string& str); - bool hasTag(CssTag tag) const; - CssValue value(CssTag tag) const; - - // primarily for debugging - std::string toString() const; -private: - // We'll use STL map for now but can replace it with something - // more efficient if needed - std::map mMap; -}; - -} // namespace android - -#endif // MINIKIN_CSS_PARSE_H diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index cd08e00283..1a0df99e67 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -21,7 +21,6 @@ #include -#include #include #include @@ -68,10 +67,6 @@ public: void dump() const; void setFontCollection(const FontCollection* collection); - // Deprecated. Will be removed. - void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - const std::string& css); - void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint); diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index fde2cbbbf4..386dc2bee1 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -20,7 +20,6 @@ include external/stlport/libstlport.mk LOCAL_SRC_FILES := \ AnalyzeStyle.cpp \ CmapCoverage.cpp \ - CssParse.cpp \ FontCollection.cpp \ FontFamily.cpp \ GraphemeBreak.cpp \ diff --git a/engine/src/flutter/libs/minikin/CssParse.cpp b/engine/src/flutter/libs/minikin/CssParse.cpp deleted file mode 100644 index 057dab7e82..0000000000 --- a/engine/src/flutter/libs/minikin/CssParse.cpp +++ /dev/null @@ -1,210 +0,0 @@ -/* - * Copyright (C) 2013 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include // for sprintf - for debugging - -#include -#include - -using std::map; -using std::pair; -using std::string; - -namespace android { - -static bool strEqC(const string str, size_t off, size_t len, const char* str2) { - if (len != strlen(str2)) return false; - return !memcmp(str.data() + off, str2, len); -} - -static CssTag parseTag(const string str, size_t off, size_t len) { - if (len == 0) return unknown; - char c = str[off]; - if (c == 'f') { - if (strEqC(str, off, len, "font-scale-x")) return fontScaleX; - if (strEqC(str, off, len, "font-size")) return fontSize; - if (strEqC(str, off, len, "font-skew-x")) return fontSkewX; - if (strEqC(str, off, len, "font-weight")) return fontWeight; - if (strEqC(str, off, len, "font-style")) return fontStyle; - } else if (c == 'l') { - if (strEqC(str, off, len, "lang")) return cssLang; - if (strEqC(str, off, len, "letter-spacing")) return letterSpacing; - } else if (c == '-') { - if (strEqC(str, off, len, "-minikin-bidi")) return minikinBidi; - if (strEqC(str, off, len, "-minikin-hinting")) return minikinHinting; - if (strEqC(str, off, len, "-minikin-variant")) return minikinVariant; - if (strEqC(str, off, len, "-paint-flags")) return paintFlags; - } - return unknown; -} - -static bool parseStringValue(const string& str, size_t* off, size_t len, CssTag tag, CssValue* v) { - const char* data = str.data(); - size_t beg = *off; - if (beg == len) return false; - char first = data[beg]; - bool quoted = false; - if (first == '\'' || first == '\"') { - quoted = true; - beg++; - } - size_t end; - for (end = beg; end < len; end++) { - char c = data[end]; - if (quoted && c == first) { - v->setStringValue(std::string(str, beg, end - beg)); - *off = end + 1; - return true; - } else if (!quoted && (c == ';' || c == ' ')) { - break; - } // TODO: deal with backslash escape, but only important for real strings - } - v->setStringValue(std::string(str, beg, end - beg)); - *off = end; - return true; -} - -static bool parseValue(const string& str, size_t* off, size_t len, CssTag tag, CssValue* v) { - if (tag == cssLang) { - return parseStringValue(str, off, len, tag, v); - } - const char* data = str.data(); - char* endptr; - double fv = strtod(data + *off, &endptr); - if (endptr == data + *off) { - // No numeric value, try tag-specific idents - size_t end; - for (end = *off; end < len; end++) { - char c = data[end]; - if (c != '-' && !(c >= 'a' && c <= 'z') && - !(c >= '0' && c <= '9')) break; - } - size_t taglen = end - *off; - endptr += taglen; - if (tag == fontStyle) { - if (strEqC(str, *off, taglen, "normal")) { - fv = 0; - } else if (strEqC(str, *off, taglen, "italic")) { - fv = 1; - // TODO: oblique, but who really cares? - } else { - return false; - } - } else if (tag == fontWeight) { - if (strEqC(str, *off, taglen, "normal")) { - fv = 400; - } else if (strEqC(str, *off, taglen, "bold")) { - fv = 700; - } else { - return false; - } - } else if (tag == minikinVariant) { - if (strEqC(str, *off, taglen, "compact")) { - fv = VARIANT_COMPACT; - } else if (strEqC(str, *off, taglen, "elegant")) { - fv = VARIANT_ELEGANT; - } - } else { - return false; - } - } - v->setDoubleValue(fv); - *off = endptr - data; - return true; -} - -string CssValue::toString(CssTag tag) const { - if (mType == DOUBLE) { - if (tag == fontStyle) { - return doubleValue ? "italic" : "normal"; - } else if (tag == minikinVariant) { - if (doubleValue == VARIANT_COMPACT) return "compact"; - if (doubleValue == VARIANT_ELEGANT) return "elegant"; - } - char buf[64]; - sprintf(buf, "%g", doubleValue); - return string(buf); - } else if (mType == STRING) { - return stringValue; // should probably quote - } - return ""; -} - -bool CssProperties::parse(const string& str) { - size_t len = str.size(); - size_t i = 0; - while (true) { - size_t j = i; - while (j < len && str[j] == ' ') j++; - if (j == len) break; - size_t k = str.find_first_of(':', j); - if (k == string::npos) { - return false; // error: junk after end - } - CssTag tag = parseTag(str, j, k - j); -#ifdef VERBOSE - printf("parseTag result %d, ijk %lu %lu %lu\n", tag, i, j, k); -#endif - if (tag == unknown) return false; // error: unknown tag - k++; // skip over colon - while (k < len && str[k] == ' ') k++; - if (k == len) return false; // error: missing value - CssValue v; - if (!parseValue(str, &k, len, tag, &v)) break; -#ifdef VERBOSE - printf("parseValue ok\n"); -#endif - mMap.insert(pair(tag, v)); - while (k < len && str[k] == ' ') k++; - if (k < len) { - if (str[k] != ';') return false; - k++; - } - i = k; - } - return true; -} - -bool CssProperties::hasTag(CssTag tag) const { - return (mMap.find(tag) != mMap.end()); -} - -CssValue CssProperties::value(CssTag tag) const { - map::const_iterator it = mMap.find(tag); - if (it == mMap.end()) { - CssValue unknown; - return unknown; - } else { - return it->second; - } -} - -string CssProperties::toString() const { - string result; - for (map::const_iterator it = mMap.begin(); - it != mMap.end(); it++) { - result += cssTagNames[it->first]; - result += ": "; - result += it->second.toString(it->first); - result += ";\n"; - } - return result; -} - -} // namespace android diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 2a396dcc77..f34d1b9f19 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -354,27 +354,6 @@ int Layout::findFace(FakedFont face, LayoutContext* ctx) { return ix; } -static FontStyle styleFromCss(const CssProperties &props) { - int weight = 4; - if (props.hasTag(fontWeight)) { - weight = props.value(fontWeight).getIntValue() / 100; - } - bool italic = false; - if (props.hasTag(fontStyle)) { - italic = props.value(fontStyle).getIntValue() != 0; - } - FontLanguage lang; - if (props.hasTag(cssLang)) { - string langStr = props.value(cssLang).getStringValue(); - lang = FontLanguage(langStr.c_str(), langStr.size()); - } - int variant = 0; - if (props.hasTag(minikinVariant)) { - variant = props.value(minikinVariant).getIntValue(); - } - return FontStyle(lang, variant, weight, italic); -} - static hb_script_t codePointToScript(hb_codepoint_t codepoint) { static hb_unicode_funcs_t* u = 0; if (!u) { @@ -495,30 +474,6 @@ static void clearHbFonts(LayoutContext* ctx) { ctx->hbFonts.clear(); } -void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - const string& css) { - - CssProperties props; - props.parse(css); - - FontStyle style = styleFromCss(props); - MinikinPaint paint; - - paint.size = props.value(fontSize).getDoubleValue(); - paint.scaleX = props.hasTag(fontScaleX) - ? props.value(fontScaleX).getDoubleValue() : 1; - paint.skewX = props.hasTag(fontSkewX) - ? props.value(fontSkewX).getDoubleValue() : 0; - paint.letterSpacing = props.hasTag(letterSpacing) - ? props.value(letterSpacing).getDoubleValue() : 0; - paint.paintFlags = props.hasTag(paintFlags) - ? props.value(paintFlags).getUintValue() : 0; - - int bidiFlags = props.hasTag(minikinBidi) ? props.value(minikinBidi).getIntValue() : 0; - - doLayout(buf, start, count, bufSize, bidiFlags, style, paint); -} - void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint) { AutoMutex _l(gMinikinLock); From b501846d80e9a5066e3462222cf4b57f2f748d96 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Tue, 29 Jul 2014 12:46:07 -0400 Subject: [PATCH 052/364] Add doLayout variant that does NOT take css string New API removes CSS string and directly takes needed objects. Bug: 16651112 Change-Id: Ie5f7c2ab05be6cbd77cae0a5fd6bb453771ada59 --- engine/src/flutter/include/minikin/Layout.h | 4 +++ engine/src/flutter/libs/minikin/Layout.cpp | 28 +++++++++++++++------ 2 files changed, 24 insertions(+), 8 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 11e5819cd1..cd08e00283 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -68,9 +68,13 @@ public: void dump() const; void setFontCollection(const FontCollection* collection); + // Deprecated. Will be removed. void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, const std::string& css); + void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + int bidiFlags, const FontStyle &style, const MinikinPaint &paint); + void draw(Bitmap*, int x0, int y0, float size) const; // This must be called before any invocations. diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 072cedad2b..2a396dcc77 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -497,24 +497,36 @@ static void clearHbFonts(LayoutContext* ctx) { void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, const string& css) { - AutoMutex _l(gMinikinLock); - LayoutContext ctx; CssProperties props; props.parse(css); - ctx.style = styleFromCss(props); + FontStyle style = styleFromCss(props); + MinikinPaint paint; - ctx.paint.size = props.value(fontSize).getDoubleValue(); - ctx.paint.scaleX = props.hasTag(fontScaleX) + paint.size = props.value(fontSize).getDoubleValue(); + paint.scaleX = props.hasTag(fontScaleX) ? props.value(fontScaleX).getDoubleValue() : 1; - ctx.paint.skewX = props.hasTag(fontSkewX) + paint.skewX = props.hasTag(fontSkewX) ? props.value(fontSkewX).getDoubleValue() : 0; - ctx.paint.letterSpacing = props.hasTag(letterSpacing) + paint.letterSpacing = props.hasTag(letterSpacing) ? props.value(letterSpacing).getDoubleValue() : 0; - ctx.paint.paintFlags = props.hasTag(paintFlags) + paint.paintFlags = props.hasTag(paintFlags) ? props.value(paintFlags).getUintValue() : 0; + int bidiFlags = props.hasTag(minikinBidi) ? props.value(minikinBidi).getIntValue() : 0; + + doLayout(buf, start, count, bufSize, bidiFlags, style, paint); +} + +void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + int bidiFlags, const FontStyle &style, const MinikinPaint &paint) { + AutoMutex _l(gMinikinLock); + + LayoutContext ctx; + ctx.style = style; + ctx.paint = paint; + bool isRtl = (bidiFlags & kDirection_Mask) != 0; bool doSingleRun = true; From f3879f9b1f5593552e96cd0f3c2cf755c376fb85 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Tue, 29 Jul 2014 16:26:49 -0400 Subject: [PATCH 053/364] Initialize MinikinPaint members We are stack-allocating MinikinPaint objects in Minikin clients, and without a constructor adding new members to the struct cannot be done without updating all clients (only one right now!). Change-Id: I4170f16498bb6b07cb795495011aca58087ed0bd --- engine/src/flutter/include/minikin/MinikinFont.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 935d4bb0b3..873a3eaf4a 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -30,6 +30,8 @@ class MinikinFont; // Possibly move into own .h file? // Note: if you add a field here, also update LayoutCacheKey struct MinikinPaint { + MinikinPaint() : font(0), size(0), scaleX(0), skewX(0), letterSpacing(0), paintFlags(0), + fakery() { } MinikinFont *font; float size; float scaleX; From 8bee8f92e045f5e709dbcbedd9d486b55e73f54e Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Tue, 29 Jul 2014 16:57:00 -0400 Subject: [PATCH 054/364] Fix examples build Was broken after recent CSS removal. Change-Id: I160fbc73286b21336d6f3943ff92d7d150dff74b --- engine/src/flutter/sample/example.cpp | 7 +++++-- engine/src/flutter/sample/example_skia.cpp | 6 +++++- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index 124729114f..487357a47b 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -84,9 +84,12 @@ int runMinikinTest() { Layout layout; layout.setFontCollection(collection); const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87"; - const char *style = "font-size: 32;"; + int bidiFlags = 0; + FontStyle fontStyle; + MinikinPaint paint; + paint.size = 32; icu::UnicodeString icuText = icu::UnicodeString::fromUTF8(text); - layout.doLayout(icuText.getBuffer(), 0, icuText.length(), icuText.length(), style); + layout.doLayout(icuText.getBuffer(), 0, icuText.length(), icuText.length(), bidiFlags, fontStyle, paint); layout.dump(); Bitmap bitmap(250, 50); layout.draw(&bitmap, 10, 40, 32); diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index 4eb0a563ba..51fcf47e58 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -119,8 +119,12 @@ int runMinikinTest() { layout.setFontCollection(collection); const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87"; const char *style = "font-size: 32; font-weight: 700;"; + int bidiFlags = 0; + FontStyle fontStyle(7); + MinikinPaint minikinPaint; + minikinPaint.size = 32; icu::UnicodeString icuText = icu::UnicodeString::fromUTF8(text); - layout.doLayout(icuText.getBuffer(), 0, icuText.length(), icuText.length(), style); + layout.doLayout(icuText.getBuffer(), 0, icuText.length(), icuText.length(), bidiFlags, fontStyle, minikinPaint); layout.dump(); SkAutoGraphics ag; From a944efa7a0e61169f56c0002b95e9d6951b1e86e Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Tue, 29 Jul 2014 17:19:22 -0400 Subject: [PATCH 055/364] Support fontFeatureSettings Bug: 15246510 Change-Id: I544915d29b2be4fb9f82f1989188a3a918c50fbc --- .../src/flutter/include/minikin/MinikinFont.h | 12 +++++-- engine/src/flutter/libs/minikin/Layout.cpp | 35 ++++++++++++------- 2 files changed, 33 insertions(+), 14 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 873a3eaf4a..9b25f9234d 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -17,6 +17,8 @@ #ifndef MINIKIN_FONT_H #define MINIKIN_FONT_H +#include + #include #include @@ -28,10 +30,15 @@ namespace android { class MinikinFont; // Possibly move into own .h file? -// Note: if you add a field here, also update LayoutCacheKey +// Note: if you add a field here, either add it to LayoutCacheKey or to skipCache() struct MinikinPaint { MinikinPaint() : font(0), size(0), scaleX(0), skewX(0), letterSpacing(0), paintFlags(0), - fakery() { } + fakery(), fontFeatureSettings() { } + + bool skipCache() const { + return !fontFeatureSettings.empty(); + } + MinikinFont *font; float size; float scaleX; @@ -39,6 +46,7 @@ struct MinikinPaint { float letterSpacing; uint32_t paintFlags; FontFakery fakery; + std::string fontFeatureSettings; }; struct MinikinRect { diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index f34d1b9f19..aaac186a48 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -578,7 +578,8 @@ void Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_ bool isRtl, LayoutContext* ctx, size_t bufStart) { LayoutCache& cache = LayoutEngine::getInstance().layoutCache; LayoutCacheKey key(mCollection, ctx->paint, ctx->style, buf, start, count, bufSize, isRtl); - Layout* value = cache.mCache.get(key); + bool skipCache = ctx->paint.skipCache(); + Layout* value = skipCache ? NULL : cache.mCache.get(key); if (value == NULL) { value = new Layout(); value->setFontCollection(mCollection); @@ -589,19 +590,29 @@ void Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_ value->doLayoutRun(key.textBuf(), start, count, bufSize, isRtl, ctx); } appendLayout(value, bufStart); - cache.mCache.put(key, value); + if (!skipCache) + cache.mCache.put(key, value); } -static void addFeatures(vector* features) { - // hardcoded features, to be repaced with more flexible configuration - static hb_feature_t palt = { HB_TAG('p', 'a', 'l', 't'), 1, 0, ~0u }; +static void addFeatures(const string &str, vector* features) { + if (!str.size()) + return; - // Don't enable "palt" for now, pending implementation of more of the - // W3C Japanese layout recommendations. See: - // http://www.w3.org/TR/2012/NOTE-jlreq-20120403/ -#if 0 - features->push_back(palt); -#endif + const char* start = str.c_str(); + const char* end = start + str.size(); + + while (start < end) { + static hb_feature_t feature; + const char* p = strchr(start, ','); + if (!p) + p = end; + /* We do not allow setting features on ranges. As such, reject any + * setting that has non-universal range. */ + if (hb_feature_from_string (start, p - start, &feature) + && feature.start == 0 && feature.end == (unsigned int) -1) + features->push_back(feature); + start = p + 1; + } } void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, @@ -626,7 +637,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t features.push_back(no_liga); features.push_back(no_clig); } - addFeatures(&features); + addFeatures(ctx->paint.fontFeatureSettings, &features); double size = ctx->paint.size; double scaleX = ctx->paint.scaleX; From 2f24599f4a258160854d18096b302ec2c3aa66c9 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Fri, 8 Aug 2014 15:25:57 -0400 Subject: [PATCH 056/364] Choose same font for Emoji keycap and its base character The U+20E3 COMBINING KEYCAP is used in our fonts to generate an emoji rendering of ASCII numbers and letters through GSUB. For that to work we need to choose the same (Emoji) font for the character coming *before* the COMBINING KEYCAP character. This is a special-case of a broader need to choose fonts per grapheme cluster as opposed to per character, but for now, special-case U+20E3. Bug: 7557244 Change-Id: I958e5a01068df8495bbb9bc3b9ed871cea1838b6 --- .../flutter/libs/minikin/FontCollection.cpp | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index a6977fd6c6..009584e8a8 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -152,9 +152,11 @@ const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t const uint32_t NBSP = 0xa0; const uint32_t ZWJ = 0x200c; const uint32_t ZWNJ = 0x200d; +const uint32_t KEYCAP = 0x20e3; + // Characters where we want to continue using existing font run instead of // recomputing the best match in the fallback list. -static const uint32_t stickyWhitelist[] = { '!', ',', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ }; +static const uint32_t stickyWhitelist[] = { '!', ',', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, KEYCAP }; static bool isStickyWhitelisted(uint32_t c) { for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) { @@ -185,6 +187,19 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty || !(isStickyWhitelisted(ch) && lastInstance->mCoverage->get(ch))) { const FontInstance* instance = getInstanceForChar(ch, lang, variant); if (i == 0 || instance != lastInstance) { + size_t start = i; + // Workaround for Emoji keycap until we implement per-cluster font + // selection: if keycap is found in a different font that also + // supports previous char, attach previous char to the new run. + // Only handles non-surrogate characters. + // Bug 7557244. + if (ch == KEYCAP && i && instance && instance->mCoverage->get(string[i - 1])) { + run->end--; + if (run->start == run->end) { + result->pop_back(); + } + start--; + } Run dummy; result->push_back(dummy); run = &result->back(); @@ -194,7 +209,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty run->fakedFont = instance->mFamily->getClosestMatch(style); } lastInstance = instance; - run->start = i; + run->start = start; } } run->end = i + nShorts; From a33151e9c78c5547eeadbaaa9168dad361df05e4 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Wed, 20 Aug 2014 17:41:51 -0400 Subject: [PATCH 057/364] Speed up cache lookup Avoid copying the string for cache lookup. Bug: 17111260 Change-Id: Ic220bfc991fc6b3dada197304aabdf72a8941bd7 --- engine/src/flutter/include/minikin/Layout.h | 2 + engine/src/flutter/libs/minikin/Layout.cpp | 99 +++++++++++++-------- 2 files changed, 66 insertions(+), 35 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 1a0df99e67..c88d087c04 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -97,6 +97,8 @@ public: static void purgeCaches(); private: + friend class LayoutCacheKey; + // Find a face in the mFaces vector, or create a new entry int findFace(FakedFont face, LayoutContext* ctx); diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index aaac186a48..e3557302ed 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -56,6 +56,19 @@ enum { const int kDirection_Mask = 0x1; +struct LayoutContext { + MinikinPaint paint; + FontStyle style; + std::vector hbFonts; // parallel to mFaces + + void clearHbFonts() { + for (size_t i = 0; i < hbFonts.size(); i++) { + hb_font_destroy(hbFonts[i]); + } + hbFonts.clear(); + } +}; + // Layout cache datatypes class LayoutCacheKey { @@ -65,16 +78,32 @@ public: : mStart(start), mCount(count), mId(collection->getId()), mStyle(style), mSize(paint.size), mScaleX(paint.scaleX), mSkewX(paint.skewX), mLetterSpacing(paint.letterSpacing), - mPaintFlags(paint.paintFlags), mIsRtl(dir) { - mText.setTo(chars, nchars); + mPaintFlags(paint.paintFlags), mIsRtl(dir), + mChars(chars), mNchars(nchars) { } bool operator==(const LayoutCacheKey &other) const; hash_t hash() const; - // This is present to avoid having to copy the text more than once. - const uint16_t* textBuf() { return mText.string(); } + void copyText() { + uint16_t* charsCopy = new uint16_t[mNchars]; + memcpy(charsCopy, mChars, mNchars * sizeof(uint16_t)); + mChars = charsCopy; + } + void freeText() { + delete[] mChars; + mChars = NULL; + } + + void doLayout(Layout* layout, LayoutContext* ctx, const FontCollection* collection) const { + layout->setFontCollection(collection); + layout->mAdvances.resize(mCount, 0); + ctx->clearHbFonts(); + layout->doLayoutRun(mChars, mStart, mCount, mNchars, mIsRtl, ctx); + } + private: - String16 mText; + const uint16_t* mChars; + size_t mNchars; size_t mStart; size_t mCount; uint32_t mId; // for the font collection @@ -95,13 +124,30 @@ public: mCache.setOnEntryRemovedListener(this); } + void clear() { + mCache.clear(); + } + + Layout* get(LayoutCacheKey& key, LayoutContext* ctx, const FontCollection* collection) { + Layout* layout = mCache.get(key); + if (layout == NULL) { + key.copyText(); + layout = new Layout(); + key.doLayout(layout, ctx, collection); + mCache.put(key, layout); + } + return layout; + } + +private: // callback for OnEntryRemoved void operator()(LayoutCacheKey& key, Layout*& value) { + key.freeText(); delete value; } LruCache mCache; -private: + //static const size_t kMaxEntries = LruCache::kUnlimitedCapacity; // TODO: eviction based on memory footprint; for now, we just use a constant @@ -149,7 +195,8 @@ bool LayoutCacheKey::operator==(const LayoutCacheKey& other) const { && mLetterSpacing == other.mLetterSpacing && mPaintFlags == other.mPaintFlags && mIsRtl == other.mIsRtl - && mText == other.mText; + && mNchars == other.mNchars + && !memcmp(mChars, other.mChars, mNchars * sizeof(uint16_t)); } hash_t LayoutCacheKey::hash() const { @@ -163,16 +210,10 @@ hash_t LayoutCacheKey::hash() const { hash = JenkinsHashMix(hash, hash_type(mLetterSpacing)); hash = JenkinsHashMix(hash, hash_type(mPaintFlags)); hash = JenkinsHashMix(hash, hash_type(mIsRtl)); - hash = JenkinsHashMixShorts(hash, mText.string(), mText.size()); + hash = JenkinsHashMixShorts(hash, mChars, mNchars); return JenkinsHashWhiten(hash); } -struct LayoutContext { - MinikinPaint paint; - FontStyle style; - std::vector hbFonts; // parallel to mFaces -}; - hash_t hash_type(const LayoutCacheKey& key) { return key.hash(); } @@ -467,13 +508,6 @@ static size_t getNextWordBreak(const uint16_t* chars, size_t offset, size_t len) return len; } -static void clearHbFonts(LayoutContext* ctx) { - for (size_t i = 0; i < ctx->hbFonts.size(); i++) { - hb_font_destroy(ctx->hbFonts[i]); - } - ctx->hbFonts.clear(); -} - void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint) { AutoMutex _l(gMinikinLock); @@ -543,7 +577,7 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu if (doSingleRun) { doLayoutRunCached(buf, start, count, bufSize, isRtl, &ctx, start); } - clearHbFonts(&ctx); + ctx.clearHbFonts(); } void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, @@ -579,19 +613,14 @@ void Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_ LayoutCache& cache = LayoutEngine::getInstance().layoutCache; LayoutCacheKey key(mCollection, ctx->paint, ctx->style, buf, start, count, bufSize, isRtl); bool skipCache = ctx->paint.skipCache(); - Layout* value = skipCache ? NULL : cache.mCache.get(key); - if (value == NULL) { - value = new Layout(); - value->setFontCollection(mCollection); - value->mAdvances.resize(count, 0); - clearHbFonts(ctx); - // Note: we do the layout from the copy stored in the key, in case a - // badly-behaved client is mutating the buffer in a separate thread. - value->doLayoutRun(key.textBuf(), start, count, bufSize, isRtl, ctx); + if (skipCache) { + Layout layout; + key.doLayout(&layout, ctx, mCollection); + appendLayout(&layout, bufStart); + } else { + Layout* layout = cache.get(key, ctx, mCollection); + appendLayout(layout, bufStart); } - appendLayout(value, bufStart); - if (!skipCache) - cache.mCache.put(key, value); } static void addFeatures(const string &str, vector* features) { @@ -821,7 +850,7 @@ void Layout::getBounds(MinikinRect* bounds) { void Layout::purgeCaches() { AutoMutex _l(gMinikinLock); LayoutCache& layoutCache = LayoutEngine::getInstance().layoutCache; - layoutCache.mCache.clear(); + layoutCache.clear(); HbFaceCache& hbCache = LayoutEngine::getInstance().hbFaceCache; hbCache.mCache.clear(); } From df03550a40706a55ca1bfcb67da62765194cf98f Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 21 Aug 2014 16:30:03 -0400 Subject: [PATCH 058/364] Fix Layout initialization in the skipCache path C++ local var initialization always tricks me. Previously, Layout didn't have a constructor, which meant that defining it on the stack left mAdvance uninitialized. This was not an issue when we were doing "new Layout()", since that invokes zero-initialization, but was an issue for the skipCache path that was allocating layout on stack by just "Layout l" instead of "Layout l = Layout()". To avoid surprises, add a constructors that clears everything. Also adds reset() method to reset the layout for reuse. Change-Id: I3e02f00da9dd7d360abe13f63c310f6882292d0a --- engine/src/flutter/include/minikin/Layout.h | 11 +++++++++-- engine/src/flutter/libs/minikin/Layout.cpp | 17 +++++++++++------ 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index c88d087c04..9f8759768d 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -64,6 +64,14 @@ class LayoutContext; // extend through the lifetime of the Layout object. class Layout { public: + + Layout() : mGlyphs(), mAdvances(), mCollection(0), mFaces(), mAdvance(0), mBounds() { + mBounds.setEmpty(); + } + + // Clears layout, ready to be used again + void reset(); + void dump() const; void setFontCollection(const FontCollection* collection); @@ -72,8 +80,7 @@ public: void draw(Bitmap*, int x0, int y0, float size) const; - // This must be called before any invocations. - // TODO: probably have a factory instead + // Deprecated. Nont needed. Remove when callers are removed. static void init(); // public accessors diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index e3557302ed..46819d64e4 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -267,10 +267,18 @@ void MinikinRect::join(const MinikinRect& r) { } } -// TODO: the actual initialization is deferred, maybe make this explicit +// Deprecated. Remove when callers are removed. void Layout::init() { } +void Layout::reset() { + mGlyphs.clear(); + mFaces.clear(); + mBounds.setEmpty(); + mAdvances.clear(); + mAdvance = 0; +} + void Layout::setFontCollection(const FontCollection* collection) { mCollection = collection; } @@ -519,12 +527,9 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu bool isRtl = (bidiFlags & kDirection_Mask) != 0; bool doSingleRun = true; - mGlyphs.clear(); - mFaces.clear(); - mBounds.setEmpty(); - mAdvances.clear(); + reset(); mAdvances.resize(count, 0); - mAdvance = 0; + if (!(bidiFlags == kBidi_Force_LTR || bidiFlags == kBidi_Force_RTL)) { UBiDi* bidi = ubidi_open(); if (bidi) { From 11c8920a3fc1c5895e777f71c822501367eef69c Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 21 Aug 2014 19:14:14 -0400 Subject: [PATCH 059/364] Allocate font vector on stack This reduces another allocation (last one?) we were doing when fulfilling shaping requests from the cache. Bug: 17111260 Change-Id: Ieb8ae1ccfcaacedb257e1e9263777f10623aaf98 --- engine/src/flutter/libs/minikin/Layout.cpp | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 46819d64e4..c3d4c13e86 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -760,11 +760,16 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t } void Layout::appendLayout(Layout* src, size_t start) { - // Note: size==1 is by far most common, should have specialized vector for this - std::vector fontMap; + int fontMapStack[16]; + int* fontMap; + if (src->mFaces.size() < sizeof(fontMapStack) / sizeof(fontMapStack[0])) { + fontMap = fontMapStack; + } else { + fontMap = new int[src->mFaces.size()]; + } for (size_t i = 0; i < src->mFaces.size(); i++) { int font_ix = findFace(src->mFaces[i], NULL); - fontMap.push_back(font_ix); + fontMap[i] = font_ix; } int x0 = mAdvance; for (size_t i = 0; i < src->mGlyphs.size(); i++) { @@ -783,6 +788,10 @@ void Layout::appendLayout(Layout* src, size_t start) { srcBounds.offset(x0, 0); mBounds.join(srcBounds); mAdvance += src->mAdvance; + + if (fontMap != fontMapStack) { + delete[] fontMap; + } } void Layout::draw(Bitmap* surface, int x0, int y0, float size) const { From 543c65c80b71e3111314bf429004a10d004e861b Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Tue, 26 Aug 2014 22:08:58 -0700 Subject: [PATCH 060/364] Try Unicode decomposition for selecting fallback font This patch finds an appropriate fallback font in the case where no font directly maps the requested character, but a font does exist for the character's canonical decomposition. This yields correct rendering of compatibility characters such as U+FA70. Bug: 15816880 Bug: 16856221 Change-Id: Idff8ed6b942fec992a0815a32028b95af091d0ee --- .../src/flutter/libs/minikin/FontCollection.cpp | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 009584e8a8..ca5b1d1ab3 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -19,6 +19,9 @@ #define LOG_TAG "Minikin" #include +#include "unicode/unistr.h" +#include "unicode/unorm2.h" + #include "MinikinInternal.h" #include #include @@ -143,7 +146,18 @@ const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t } } } - if (bestInstance == NULL) { + if (bestInstance == NULL && !mInstanceVec.empty()) { + UErrorCode errorCode = U_ZERO_ERROR; + const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode); + if (U_SUCCESS(errorCode)) { + UChar decomposed[4]; + int len = unorm2_getRawDecomposition(normalizer, ch, decomposed, 4, &errorCode); + if (U_SUCCESS(errorCode) && len > 0) { + int off = 0; + U16_NEXT_UNSAFE(decomposed, off, ch); + return getInstanceForChar(ch, lang, variant); + } + } bestInstance = &mInstances[0]; } return bestInstance; From ff55a581fa07b52f3cffcf3fc825d297cf955ffe Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 3 Sep 2014 10:37:05 -0700 Subject: [PATCH 061/364] Snap advance widths to integers Fractional advance widths were causing subtle problems with text positioning when the same text was drawn with different spans in the hwui renderer. Quantizing the coordinates on layout (as opposed to waiting until the renderer draws the glyphs) solves the problem. This patch also fixes a discrepancy between x position and advance widths when letterspacing. Bug: 17347779 Change-Id: Ia705944047408c2839d5ad078eefd6bbec446872 --- .../src/flutter/include/minikin/MinikinFont.h | 6 +++++ engine/src/flutter/libs/minikin/Layout.cpp | 26 +++++++++++++------ 2 files changed, 24 insertions(+), 8 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 9b25f9234d..3f07589697 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -49,6 +49,12 @@ struct MinikinPaint { std::string fontFeatureSettings; }; +// Only a few flags affect layout, but those that do should have values +// consistent with Android's paint flags. +enum MinikinPaintFlags { + LinearTextFlag = 0x40, +}; + struct MinikinRect { float mLeft, mTop, mRight, mBottom; bool isEmpty() const { diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index c3d4c13e86..fcae6cc51d 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -676,7 +676,14 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t double size = ctx->paint.size; double scaleX = ctx->paint.scaleX; double letterSpace = ctx->paint.letterSpacing * size * scaleX; - double letterSpaceHalf = letterSpace * .5; + double letterSpaceHalfLeft; + if ((ctx->paint.paintFlags & LinearTextFlag) == 0) { + letterSpace = round(letterSpace); + letterSpaceHalfLeft = floor(letterSpace * 0.5); + } else { + letterSpaceHalfLeft = letterSpace * 0.5; + } + double letterSpaceHalfRight = letterSpace - letterSpaceHalfLeft; float x = mAdvance; float y = 0; @@ -721,8 +728,8 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_glyph_position_t* positions = hb_buffer_get_glyph_positions(buffer, NULL); if (numGlyphs) { - mAdvances[info[0].cluster - start] += letterSpaceHalf; - x += letterSpaceHalf; + mAdvances[info[0].cluster - start] += letterSpaceHalfLeft; + x += letterSpaceHalfLeft; } for (unsigned int i = 0; i < numGlyphs; i++) { #ifdef VERBOSE @@ -730,9 +737,9 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t ": " << HBFixedToFloat(positions[i].x_advance) << "; " << positions[i].x_offset << ", " << positions[i].y_offset << std::endl; #endif if (i > 0 && info[i - 1].cluster != info[i].cluster) { - mAdvances[info[i - 1].cluster - start] += letterSpaceHalf; - mAdvances[info[i].cluster - start] += letterSpaceHalf; - x += letterSpaceHalf; + mAdvances[info[i - 1].cluster - start] += letterSpaceHalfRight; + mAdvances[info[i].cluster - start] += letterSpaceHalfLeft; + x += letterSpace; } hb_codepoint_t glyph_ix = info[i].codepoint; @@ -742,6 +749,9 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t LayoutGlyph glyph = {font_ix, glyph_ix, x + xoff, y + yoff}; mGlyphs.push_back(glyph); float xAdvance = HBFixedToFloat(positions[i].x_advance); + if ((ctx->paint.paintFlags & LinearTextFlag) == 0) { + xAdvance = roundf(xAdvance); + } MinikinRect glyphBounds; ctx->paint.font->GetBounds(&glyphBounds, glyph_ix, ctx->paint); glyphBounds.offset(x + xoff, y + yoff); @@ -751,8 +761,8 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t } if (numGlyphs) { - mAdvances[info[numGlyphs - 1].cluster - start] += letterSpaceHalf; - x += letterSpaceHalf; + mAdvances[info[numGlyphs - 1].cluster - start] += letterSpaceHalfRight; + x += letterSpaceHalfRight; } } } From 6cba4a1dcae7ce1a359638405c3703b3cbb91277 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 22 Sep 2014 11:16:04 -0700 Subject: [PATCH 062/364] Fine-tune fake-bolding condition The old logic for fake bolding results in no fake bolding for a bold span on a light weight (300) because the target weight (600 in this case) didn't meet the condition. This patch fine-tunes the threshold to enable fake bolding for this. Bug: 17587185 Change-Id: I04abd00a74240cbed79c417f81486aa2158b2806 --- engine/src/flutter/libs/minikin/FontFamily.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index ab6ba20b3b..f688a33962 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -141,11 +141,11 @@ static int computeMatch(FontStyle style1, FontStyle style2) { } static FontFakery computeFakery(FontStyle wanted, FontStyle actual) { - // If desired weight is bold or darker, and 2 or more grades higher - // than actual (for example, medium 500 -> bold 700), then select - // fake bold. + // If desired weight is semibold or darker, and 2 or more grades + // higher than actual (for example, medium 500 -> bold 700), then + // select fake bold. int wantedWeight = wanted.getWeight(); - bool isFakeBold = wantedWeight >= 7 && (wantedWeight - actual.getWeight()) >= 2; + bool isFakeBold = wantedWeight >= 6 && (wantedWeight - actual.getWeight()) >= 2; bool isFakeItalic = wanted.getItalic() && !actual.getItalic(); return FontFakery(isFakeBold, isFakeItalic); } From 92e8cc7071364e58b3d5642649f7032a63f389f7 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 23 Oct 2014 14:54:42 -0700 Subject: [PATCH 063/364] Silently ignore invalid rangeOffset values Some fonts contain a cmap segment for char 0xffff that contains an invalid rangeOffset. This was rejected by the existing code, which means the font is considered to have empty Unicode coverage. This patch just discards the invalid segment (consistent with OpenType Sanitizer), making the custom font display. Bug: 18106256 Change-Id: Icc8616a3030f80e62db906332be64d434ae72ea2 --- .../src/flutter/libs/minikin/CmapCoverage.cpp | 23 ++++++++++--------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index 4156d69d5a..75033729e3 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -16,9 +16,8 @@ // Determine coverage of font given its raw "cmap" OpenType table -#ifdef PRINTF_DEBUG -#include -#endif +#define LOG_TAG "Minikin" +#include #include using std::vector; @@ -38,8 +37,8 @@ static uint32_t readU32(const uint8_t* data, size_t offset) { } static void addRange(vector &coverage, uint32_t start, uint32_t end) { -#ifdef PRINTF_DEBUG - printf("adding range %d-%d\n", start, end); +#ifdef VERBOSE_DEBUG + ALOGD("adding range %d-%d\n", start, end); #endif if (coverage.empty() || coverage.back() < start) { coverage.push_back(start); @@ -82,7 +81,8 @@ static bool getCoverageFormat4(vector& coverage, const uint8_t* data, uint32_t actualRangeOffset = kHeaderSize + 6 * segCount + rangeOffset + (i + j - start) * 2; if (actualRangeOffset + 2 > size) { - return false; + // invalid rangeOffset is considered a "warning" by OpenType Sanitizer + continue; } int glyphId = readU16(data, actualRangeOffset); if (glyphId != 0) { @@ -146,8 +146,8 @@ bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, bestTable = i; } } -#ifdef PRINTF_DEBUG - printf("best table = %d\n", bestTable); +#ifdef VERBOSE_DEBUG + ALOGD("best table = %d\n", bestTable); #endif if (bestTable < 0) { return false; @@ -168,10 +168,11 @@ bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, if (success) { coverage.initFromRanges(&coverageVec.front(), coverageVec.size() >> 1); } -#ifdef PRINTF_DEBUG - for (int i = 0; i < coverageVec.size(); i += 2) { - printf("%x:%x\n", coverageVec[i], coverageVec[i + 1]); +#ifdef VERBOSE_DEBUG + for (size_t i = 0; i < coverageVec.size(); i += 2) { + ALOGD("%x:%x\n", coverageVec[i], coverageVec[i + 1]); } + ALOGD("success = %d", success); #endif return success; } From 474b009ef443dbb82c1f93688613b9853ab1b396 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 29 Oct 2014 11:04:04 -0700 Subject: [PATCH 064/364] Move coverage bitmap from FontCollection to FontFamily This will significantly reduce memory usage and also speed the creation of new font families. In particular, the coverage bitmaps for the fonts in the fallback stack will be computed once in the Zygote, rather than separately in each app process. Bug: 17756900 Change-Id: I66f5706bddd4658d78fe5b709f7251ca9d2ff4f8 --- .../flutter/include/minikin/FontCollection.h | 12 +-- .../src/flutter/include/minikin/FontFamily.h | 7 ++ .../flutter/libs/minikin/FontCollection.cpp | 83 +++++++------------ .../src/flutter/libs/minikin/FontFamily.cpp | 21 +++++ 4 files changed, 63 insertions(+), 60 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 12700c6ebe..ffdb4d1819 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -21,7 +21,6 @@ #include #include -#include #include namespace android { @@ -52,17 +51,12 @@ private: static const int kLogCharsPerPage = 8; static const int kPageMask = (1 << kLogCharsPerPage) - 1; - struct FontInstance { - SparseBitSet* mCoverage; - FontFamily* mFamily; - }; - struct Range { size_t start; size_t end; }; - const FontInstance* getInstanceForChar(uint32_t ch, FontLanguage lang, int variant) const; + FontFamily* getFamilyForChar(uint32_t ch, FontLanguage lang, int variant) const; // static for allocating unique id's static uint32_t sNextId; @@ -74,10 +68,10 @@ private: uint32_t mMaxChar; // This vector has ownership of the bitsets and typeface objects. - std::vector mInstances; + std::vector mFamilies; // This vector contains pointers into mInstances - std::vector mInstanceVec; + std::vector mFamilyVec; // These are offsets into mInstanceVec, one range per page std::vector mRanges; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index bcc2e3a59c..08c7a2c987 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -23,6 +23,7 @@ #include #include +#include namespace android { @@ -139,6 +140,9 @@ public: size_t getNumFonts() const; MinikinFont* getFont(size_t index) const; FontStyle getStyle(size_t index) const; + + // Get Unicode coverage. Lifetime of returned bitset is same as receiver. + const SparseBitSet* getCoverage(); private: void addFontLocked(MinikinFont* typeface, FontStyle style); @@ -152,6 +156,9 @@ private: FontLanguage mLang; int mVariant; std::vector mFonts; + + SparseBitSet mCoverage; + bool mCoverageValid; }; } // namespace android diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index ca5b1d1ab3..7b6b950787 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -23,7 +23,6 @@ #include "unicode/unorm2.h" #include "MinikinInternal.h" -#include #include using std::vector; @@ -54,28 +53,12 @@ FontCollection::FontCollection(const vector& typefaces) : continue; } family->RefLocked(); - FontInstance dummy; - mInstances.push_back(dummy); // emplace_back would be better - FontInstance* instance = &mInstances.back(); - instance->mFamily = family; - instance->mCoverage = new SparseBitSet; -#ifdef VERBOSE_DEBUG - ALOGD("closest match = %p, family size = %d\n", typeface, family->getNumFonts()); -#endif - const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); - size_t cmapSize = 0; - bool ok = typeface->GetTable(cmapTag, NULL, &cmapSize); - UniquePtr cmapData(new uint8_t[cmapSize]); - ok = typeface->GetTable(cmapTag, cmapData.get(), &cmapSize); - CmapCoverage::getCoverage(*instance->mCoverage, cmapData.get(), cmapSize); -#ifdef VERBOSE_DEBUG - ALOGD("font coverage length=%d, first ch=%x\n", instance->mCoverage->length(), - instance->mCoverage->nextSetBit(0)); -#endif - mMaxChar = max(mMaxChar, instance->mCoverage->length()); - lastChar.push_back(instance->mCoverage->nextSetBit(0)); + mFamilies.push_back(family); // emplace_back would be better + const SparseBitSet* coverage = family->getCoverage(); + mMaxChar = max(mMaxChar, coverage->length()); + lastChar.push_back(coverage->nextSetBit(0)); } - nTypefaces = mInstances.size(); + nTypefaces = mFamilies.size(); LOG_ALWAYS_FATAL_IF(nTypefaces == 0, "Font collection must have at least one valid typeface"); size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage; @@ -90,10 +73,10 @@ FontCollection::FontCollection(const vector& typefaces) : range->start = offset; for (size_t j = 0; j < nTypefaces; j++) { if (lastChar[j] < (i + 1) << kLogCharsPerPage) { - const FontInstance* instance = &mInstances[j]; - mInstanceVec.push_back(instance); + FontFamily* family = mFamilies[j]; + mFamilyVec.push_back(family); offset++; - uint32_t nextChar = instance->mCoverage->nextSetBit((i + 1) << kLogCharsPerPage); + uint32_t nextChar = family->getCoverage()->nextSetBit((i + 1) << kLogCharsPerPage); #ifdef VERBOSE_DEBUG ALOGD("nextChar = %d (j = %d)\n", nextChar, j); #endif @@ -105,9 +88,8 @@ FontCollection::FontCollection(const vector& typefaces) : } FontCollection::~FontCollection() { - for (size_t i = 0; i < mInstances.size(); i++) { - delete mInstances[i].mCoverage; - mInstances[i].mFamily->UnrefLocked(); + for (size_t i = 0; i < mFamilies.size(); i++) { + mFamilies[i]->UnrefLocked(); } } @@ -117,7 +99,7 @@ FontCollection::~FontCollection() { // 3. If a font matches just language, it gets a score of 2. // 4. Matching the "compact" or "elegant" variant adds one to the score. // 5. Highest score wins, with ties resolved to the first font. -const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t ch, +FontFamily* FontCollection::getFamilyForChar(uint32_t ch, FontLanguage lang, int variant) const { if (ch >= mMaxChar) { return NULL; @@ -126,15 +108,14 @@ const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t #ifdef VERBOSE_DEBUG ALOGD("querying range %d:%d\n", range.start, range.end); #endif - const FontInstance* bestInstance = NULL; + FontFamily* bestFamily = NULL; int bestScore = -1; for (size_t i = range.start; i < range.end; i++) { - const FontInstance* instance = mInstanceVec[i]; - if (instance->mCoverage->get(ch)) { - FontFamily* family = instance->mFamily; + FontFamily* family = mFamilyVec[i]; + if (family->getCoverage()->get(ch)) { // First font family in collection always matches - if (mInstances[0].mFamily == family) { - return instance; + if (mFamilies[0] == family) { + return family; } int score = lang.match(family->lang()) * 2; if (variant != 0 && variant == family->variant()) { @@ -142,11 +123,11 @@ const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t } if (score > bestScore) { bestScore = score; - bestInstance = instance; + bestFamily = family; } } } - if (bestInstance == NULL && !mInstanceVec.empty()) { + if (bestFamily == NULL && !mFamilyVec.empty()) { UErrorCode errorCode = U_ZERO_ERROR; const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode); if (U_SUCCESS(errorCode)) { @@ -155,12 +136,12 @@ const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t if (U_SUCCESS(errorCode) && len > 0) { int off = 0; U16_NEXT_UNSAFE(decomposed, off, ch); - return getInstanceForChar(ch, lang, variant); + return getFamilyForChar(ch, lang, variant); } } - bestInstance = &mInstances[0]; + bestFamily = mFamilies[0]; } - return bestInstance; + return bestFamily; } const uint32_t NBSP = 0xa0; @@ -183,7 +164,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty vector* result) const { FontLanguage lang = style.getLanguage(); int variant = style.getVariant(); - const FontInstance* lastInstance = NULL; + FontFamily* lastFamily = NULL; Run* run = NULL; int nShorts; for (size_t i = 0; i < string_size; i += nShorts) { @@ -197,17 +178,17 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } } // Continue using existing font as long as it has coverage and is whitelisted - if (lastInstance == NULL - || !(isStickyWhitelisted(ch) && lastInstance->mCoverage->get(ch))) { - const FontInstance* instance = getInstanceForChar(ch, lang, variant); - if (i == 0 || instance != lastInstance) { + if (lastFamily == NULL + || !(isStickyWhitelisted(ch) && lastFamily->getCoverage()->get(ch))) { + FontFamily* family = getFamilyForChar(ch, lang, variant); + if (i == 0 || family != lastFamily) { size_t start = i; // Workaround for Emoji keycap until we implement per-cluster font // selection: if keycap is found in a different font that also // supports previous char, attach previous char to the new run. // Only handles non-surrogate characters. // Bug 7557244. - if (ch == KEYCAP && i && instance && instance->mCoverage->get(string[i - 1])) { + if (ch == KEYCAP && i && family && family->getCoverage()->get(string[i - 1])) { run->end--; if (run->start == run->end) { result->pop_back(); @@ -217,12 +198,12 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty Run dummy; result->push_back(dummy); run = &result->back(); - if (instance == NULL) { + if (family == NULL) { run->fakedFont.font = NULL; } else { - run->fakedFont = instance->mFamily->getClosestMatch(style); + run->fakedFont = family->getClosestMatch(style); } - lastInstance = instance; + lastFamily = family; run->start = start; } } @@ -235,10 +216,10 @@ MinikinFont* FontCollection::baseFont(FontStyle style) { } FakedFont FontCollection::baseFontFaked(FontStyle style) { - if (mInstances.empty()) { + if (mFamilies.empty()) { return FakedFont(); } - return mInstances[0].mFamily->getClosestMatch(style); + return mFamilies[0]->getClosestMatch(style); } uint32_t FontCollection::getId() const { diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index f688a33962..d2e5867cdd 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -23,6 +23,7 @@ #include "MinikinInternal.h" #include #include +#include #include #include @@ -128,6 +129,7 @@ void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { typeface->RefLocked(); mFonts.push_back(Font(typeface, style)); + mCoverageValid = false; } // Compute a matching metric between two styles - 0 is an exact match @@ -183,4 +185,23 @@ FontStyle FontFamily::getStyle(size_t index) const { return mFonts[index].style; } +const SparseBitSet* FontFamily::getCoverage() { + if (!mCoverageValid) { + const FontStyle defaultStyle; + MinikinFont* typeface = getClosestMatch(defaultStyle).font; + const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); + size_t cmapSize = 0; + bool ok = typeface->GetTable(cmapTag, NULL, &cmapSize); + UniquePtr cmapData(new uint8_t[cmapSize]); + ok = typeface->GetTable(cmapTag, cmapData.get(), &cmapSize); + CmapCoverage::getCoverage(mCoverage, cmapData.get(), cmapSize); +#ifdef VERBOSE_DEBUG + ALOGD("font coverage length=%d, first ch=%x\n", mCoverage->length(), + mCoverage->nextSetBit(0)); +#endif + mCoverageValid = true; + } + return &mCoverage; +} + } // namespace android From a4e238f757417c13e688f69f49eed4db168dc6c9 Mon Sep 17 00:00:00 2001 From: Dan Albert Date: Tue, 11 Nov 2014 19:32:48 -0800 Subject: [PATCH 065/364] Move frameworks/minikin over to libc++. Bug: 15193147 Change-Id: I5e15c95415c39515340e2663acd5fd26666db720 --- engine/src/flutter/libs/minikin/Android.mk | 2 -- engine/src/flutter/libs/minikin/Layout.cpp | 8 +++++--- engine/src/flutter/sample/Android.mk | 4 ---- 3 files changed, 5 insertions(+), 9 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 386dc2bee1..60a46efcf9 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -15,7 +15,6 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) -include external/stlport/libstlport.mk LOCAL_SRC_FILES := \ AnalyzeStyle.cpp \ @@ -43,7 +42,6 @@ LOCAL_SHARED_LIBRARIES := \ liblog \ libpng \ libz \ - libstlport \ libicuuc \ libutils diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index fcae6cc51d..fa7770138c 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -17,12 +17,14 @@ #define LOG_TAG "Minikin" #include -#include -#include +#include +#include // for debugging + #include #include #include // for debugging -#include // ditto +#include +#include #include #include diff --git a/engine/src/flutter/sample/Android.mk b/engine/src/flutter/sample/Android.mk index ec06e3852a..101a413cae 100644 --- a/engine/src/flutter/sample/Android.mk +++ b/engine/src/flutter/sample/Android.mk @@ -15,7 +15,6 @@ LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) -include external/stlport/libstlport.mk LOCAL_MODULE_TAGS := tests @@ -31,7 +30,6 @@ LOCAL_SHARED_LIBRARIES += \ libutils \ liblog \ libcutils \ - libstlport \ libharfbuzz_ng \ libicuuc \ libft2 \ @@ -45,7 +43,6 @@ include $(BUILD_EXECUTABLE) include $(CLEAR_VARS) -include external/stlport/libstlport.mk LOCAL_MODULE_TAG := tests @@ -63,7 +60,6 @@ LOCAL_SHARED_LIBRARIES += \ libutils \ liblog \ libcutils \ - libstlport \ libharfbuzz_ng \ libicuuc \ libskia \ From 477b5d2cdbbc7c8115d5fcf441ea25cedc48d08c Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 29 Oct 2014 11:04:04 -0700 Subject: [PATCH 066/364] Move coverage bitmap from FontCollection to FontFamily This will significantly reduce memory usage and also speed the creation of new font families. In particular, the coverage bitmaps for the fonts in the fallback stack will be computed once in the Zygote, rather than separately in each app process. Bug: 17756900 Change-Id: I66f5706bddd4658d78fe5b709f7251ca9d2ff4f8 --- .../flutter/include/minikin/FontCollection.h | 12 +-- .../src/flutter/include/minikin/FontFamily.h | 7 ++ .../flutter/libs/minikin/FontCollection.cpp | 83 +++++++------------ .../src/flutter/libs/minikin/FontFamily.cpp | 21 +++++ 4 files changed, 63 insertions(+), 60 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 12700c6ebe..ffdb4d1819 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -21,7 +21,6 @@ #include #include -#include #include namespace android { @@ -52,17 +51,12 @@ private: static const int kLogCharsPerPage = 8; static const int kPageMask = (1 << kLogCharsPerPage) - 1; - struct FontInstance { - SparseBitSet* mCoverage; - FontFamily* mFamily; - }; - struct Range { size_t start; size_t end; }; - const FontInstance* getInstanceForChar(uint32_t ch, FontLanguage lang, int variant) const; + FontFamily* getFamilyForChar(uint32_t ch, FontLanguage lang, int variant) const; // static for allocating unique id's static uint32_t sNextId; @@ -74,10 +68,10 @@ private: uint32_t mMaxChar; // This vector has ownership of the bitsets and typeface objects. - std::vector mInstances; + std::vector mFamilies; // This vector contains pointers into mInstances - std::vector mInstanceVec; + std::vector mFamilyVec; // These are offsets into mInstanceVec, one range per page std::vector mRanges; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index bcc2e3a59c..08c7a2c987 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -23,6 +23,7 @@ #include #include +#include namespace android { @@ -139,6 +140,9 @@ public: size_t getNumFonts() const; MinikinFont* getFont(size_t index) const; FontStyle getStyle(size_t index) const; + + // Get Unicode coverage. Lifetime of returned bitset is same as receiver. + const SparseBitSet* getCoverage(); private: void addFontLocked(MinikinFont* typeface, FontStyle style); @@ -152,6 +156,9 @@ private: FontLanguage mLang; int mVariant; std::vector mFonts; + + SparseBitSet mCoverage; + bool mCoverageValid; }; } // namespace android diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index ca5b1d1ab3..7b6b950787 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -23,7 +23,6 @@ #include "unicode/unorm2.h" #include "MinikinInternal.h" -#include #include using std::vector; @@ -54,28 +53,12 @@ FontCollection::FontCollection(const vector& typefaces) : continue; } family->RefLocked(); - FontInstance dummy; - mInstances.push_back(dummy); // emplace_back would be better - FontInstance* instance = &mInstances.back(); - instance->mFamily = family; - instance->mCoverage = new SparseBitSet; -#ifdef VERBOSE_DEBUG - ALOGD("closest match = %p, family size = %d\n", typeface, family->getNumFonts()); -#endif - const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); - size_t cmapSize = 0; - bool ok = typeface->GetTable(cmapTag, NULL, &cmapSize); - UniquePtr cmapData(new uint8_t[cmapSize]); - ok = typeface->GetTable(cmapTag, cmapData.get(), &cmapSize); - CmapCoverage::getCoverage(*instance->mCoverage, cmapData.get(), cmapSize); -#ifdef VERBOSE_DEBUG - ALOGD("font coverage length=%d, first ch=%x\n", instance->mCoverage->length(), - instance->mCoverage->nextSetBit(0)); -#endif - mMaxChar = max(mMaxChar, instance->mCoverage->length()); - lastChar.push_back(instance->mCoverage->nextSetBit(0)); + mFamilies.push_back(family); // emplace_back would be better + const SparseBitSet* coverage = family->getCoverage(); + mMaxChar = max(mMaxChar, coverage->length()); + lastChar.push_back(coverage->nextSetBit(0)); } - nTypefaces = mInstances.size(); + nTypefaces = mFamilies.size(); LOG_ALWAYS_FATAL_IF(nTypefaces == 0, "Font collection must have at least one valid typeface"); size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage; @@ -90,10 +73,10 @@ FontCollection::FontCollection(const vector& typefaces) : range->start = offset; for (size_t j = 0; j < nTypefaces; j++) { if (lastChar[j] < (i + 1) << kLogCharsPerPage) { - const FontInstance* instance = &mInstances[j]; - mInstanceVec.push_back(instance); + FontFamily* family = mFamilies[j]; + mFamilyVec.push_back(family); offset++; - uint32_t nextChar = instance->mCoverage->nextSetBit((i + 1) << kLogCharsPerPage); + uint32_t nextChar = family->getCoverage()->nextSetBit((i + 1) << kLogCharsPerPage); #ifdef VERBOSE_DEBUG ALOGD("nextChar = %d (j = %d)\n", nextChar, j); #endif @@ -105,9 +88,8 @@ FontCollection::FontCollection(const vector& typefaces) : } FontCollection::~FontCollection() { - for (size_t i = 0; i < mInstances.size(); i++) { - delete mInstances[i].mCoverage; - mInstances[i].mFamily->UnrefLocked(); + for (size_t i = 0; i < mFamilies.size(); i++) { + mFamilies[i]->UnrefLocked(); } } @@ -117,7 +99,7 @@ FontCollection::~FontCollection() { // 3. If a font matches just language, it gets a score of 2. // 4. Matching the "compact" or "elegant" variant adds one to the score. // 5. Highest score wins, with ties resolved to the first font. -const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t ch, +FontFamily* FontCollection::getFamilyForChar(uint32_t ch, FontLanguage lang, int variant) const { if (ch >= mMaxChar) { return NULL; @@ -126,15 +108,14 @@ const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t #ifdef VERBOSE_DEBUG ALOGD("querying range %d:%d\n", range.start, range.end); #endif - const FontInstance* bestInstance = NULL; + FontFamily* bestFamily = NULL; int bestScore = -1; for (size_t i = range.start; i < range.end; i++) { - const FontInstance* instance = mInstanceVec[i]; - if (instance->mCoverage->get(ch)) { - FontFamily* family = instance->mFamily; + FontFamily* family = mFamilyVec[i]; + if (family->getCoverage()->get(ch)) { // First font family in collection always matches - if (mInstances[0].mFamily == family) { - return instance; + if (mFamilies[0] == family) { + return family; } int score = lang.match(family->lang()) * 2; if (variant != 0 && variant == family->variant()) { @@ -142,11 +123,11 @@ const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t } if (score > bestScore) { bestScore = score; - bestInstance = instance; + bestFamily = family; } } } - if (bestInstance == NULL && !mInstanceVec.empty()) { + if (bestFamily == NULL && !mFamilyVec.empty()) { UErrorCode errorCode = U_ZERO_ERROR; const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode); if (U_SUCCESS(errorCode)) { @@ -155,12 +136,12 @@ const FontCollection::FontInstance* FontCollection::getInstanceForChar(uint32_t if (U_SUCCESS(errorCode) && len > 0) { int off = 0; U16_NEXT_UNSAFE(decomposed, off, ch); - return getInstanceForChar(ch, lang, variant); + return getFamilyForChar(ch, lang, variant); } } - bestInstance = &mInstances[0]; + bestFamily = mFamilies[0]; } - return bestInstance; + return bestFamily; } const uint32_t NBSP = 0xa0; @@ -183,7 +164,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty vector* result) const { FontLanguage lang = style.getLanguage(); int variant = style.getVariant(); - const FontInstance* lastInstance = NULL; + FontFamily* lastFamily = NULL; Run* run = NULL; int nShorts; for (size_t i = 0; i < string_size; i += nShorts) { @@ -197,17 +178,17 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } } // Continue using existing font as long as it has coverage and is whitelisted - if (lastInstance == NULL - || !(isStickyWhitelisted(ch) && lastInstance->mCoverage->get(ch))) { - const FontInstance* instance = getInstanceForChar(ch, lang, variant); - if (i == 0 || instance != lastInstance) { + if (lastFamily == NULL + || !(isStickyWhitelisted(ch) && lastFamily->getCoverage()->get(ch))) { + FontFamily* family = getFamilyForChar(ch, lang, variant); + if (i == 0 || family != lastFamily) { size_t start = i; // Workaround for Emoji keycap until we implement per-cluster font // selection: if keycap is found in a different font that also // supports previous char, attach previous char to the new run. // Only handles non-surrogate characters. // Bug 7557244. - if (ch == KEYCAP && i && instance && instance->mCoverage->get(string[i - 1])) { + if (ch == KEYCAP && i && family && family->getCoverage()->get(string[i - 1])) { run->end--; if (run->start == run->end) { result->pop_back(); @@ -217,12 +198,12 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty Run dummy; result->push_back(dummy); run = &result->back(); - if (instance == NULL) { + if (family == NULL) { run->fakedFont.font = NULL; } else { - run->fakedFont = instance->mFamily->getClosestMatch(style); + run->fakedFont = family->getClosestMatch(style); } - lastInstance = instance; + lastFamily = family; run->start = start; } } @@ -235,10 +216,10 @@ MinikinFont* FontCollection::baseFont(FontStyle style) { } FakedFont FontCollection::baseFontFaked(FontStyle style) { - if (mInstances.empty()) { + if (mFamilies.empty()) { return FakedFont(); } - return mInstances[0].mFamily->getClosestMatch(style); + return mFamilies[0]->getClosestMatch(style); } uint32_t FontCollection::getId() const { diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index f688a33962..d2e5867cdd 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -23,6 +23,7 @@ #include "MinikinInternal.h" #include #include +#include #include #include @@ -128,6 +129,7 @@ void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { typeface->RefLocked(); mFonts.push_back(Font(typeface, style)); + mCoverageValid = false; } // Compute a matching metric between two styles - 0 is an exact match @@ -183,4 +185,23 @@ FontStyle FontFamily::getStyle(size_t index) const { return mFonts[index].style; } +const SparseBitSet* FontFamily::getCoverage() { + if (!mCoverageValid) { + const FontStyle defaultStyle; + MinikinFont* typeface = getClosestMatch(defaultStyle).font; + const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); + size_t cmapSize = 0; + bool ok = typeface->GetTable(cmapTag, NULL, &cmapSize); + UniquePtr cmapData(new uint8_t[cmapSize]); + ok = typeface->GetTable(cmapTag, cmapData.get(), &cmapSize); + CmapCoverage::getCoverage(mCoverage, cmapData.get(), cmapSize); +#ifdef VERBOSE_DEBUG + ALOGD("font coverage length=%d, first ch=%x\n", mCoverage->length(), + mCoverage->nextSetBit(0)); +#endif + mCoverageValid = true; + } + return &mCoverage; +} + } // namespace android From faf26d176f220c5fa00c20085b764346c998405e Mon Sep 17 00:00:00 2001 From: Andreas Gampe Date: Mon, 24 Nov 2014 18:35:14 -0800 Subject: [PATCH 067/364] Minikin: Remove unused variables, fix init order For build-system CFLAGS clean-up, fix unused variables. Reorder initializer list to initialize in the order of member declarations. Change-Id: I64358b2dcf0e39d0f4e18fdc3473de867f84fcba --- engine/src/flutter/include/minikin/FontFamily.h | 3 ++- engine/src/flutter/libs/minikin/FontCollection.cpp | 6 +++++- engine/src/flutter/libs/minikin/FontFamily.cpp | 14 +++++++++++--- engine/src/flutter/libs/minikin/Layout.cpp | 6 +++--- .../flutter/libs/minikin/MinikinFontFreeType.cpp | 2 +- engine/src/flutter/sample/example_skia.cpp | 3 --- 6 files changed, 22 insertions(+), 12 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 08c7a2c987..7bdff6eb4f 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -141,7 +141,8 @@ public: MinikinFont* getFont(size_t index) const; FontStyle getStyle(size_t index) const; - // Get Unicode coverage. Lifetime of returned bitset is same as receiver. + // Get Unicode coverage. Lifetime of returned bitset is same as receiver. May return nullptr on + // error. const SparseBitSet* getCoverage(); private: void addFontLocked(MinikinFont* typeface, FontStyle style); diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 7b6b950787..e3911c5bd3 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -53,8 +53,12 @@ FontCollection::FontCollection(const vector& typefaces) : continue; } family->RefLocked(); - mFamilies.push_back(family); // emplace_back would be better const SparseBitSet* coverage = family->getCoverage(); + if (coverage == nullptr) { + family->UnrefLocked(); + continue; + } + mFamilies.push_back(family); // emplace_back would be better mMaxChar = max(mMaxChar, coverage->length()); lastChar.push_back(coverage->nextSetBit(0)); } diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index d2e5867cdd..da7320bce5 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -191,10 +191,18 @@ const SparseBitSet* FontFamily::getCoverage() { MinikinFont* typeface = getClosestMatch(defaultStyle).font; const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); size_t cmapSize = 0; - bool ok = typeface->GetTable(cmapTag, NULL, &cmapSize); + if (!typeface->GetTable(cmapTag, NULL, &cmapSize)) { + ALOGE("Could not get cmap table size!\n"); + // Note: This means we will retry on the next call to getCoverage, as we can't store + // the failure. This is fine, as we assume this doesn't really happen in practice. + return nullptr; + } UniquePtr cmapData(new uint8_t[cmapSize]); - ok = typeface->GetTable(cmapTag, cmapData.get(), &cmapSize); - CmapCoverage::getCoverage(mCoverage, cmapData.get(), cmapSize); + if (!typeface->GetTable(cmapTag, cmapData.get(), &cmapSize)) { + ALOGE("Unexpected failure to read cmap table!\n"); + return nullptr; + } + CmapCoverage::getCoverage(mCoverage, cmapData.get(), cmapSize); // TODO: Error check? #ifdef VERBOSE_DEBUG ALOGD("font coverage length=%d, first ch=%x\n", mCoverage->length(), mCoverage->nextSetBit(0)); diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index fa7770138c..db0667b09a 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -77,11 +77,11 @@ class LayoutCacheKey { public: LayoutCacheKey(const FontCollection* collection, const MinikinPaint& paint, FontStyle style, const uint16_t* chars, size_t start, size_t count, size_t nchars, bool dir) - : mStart(start), mCount(count), mId(collection->getId()), mStyle(style), + : mChars(chars), mNchars(nchars), + mStart(start), mCount(count), mId(collection->getId()), mStyle(style), mSize(paint.size), mScaleX(paint.scaleX), mSkewX(paint.skewX), mLetterSpacing(paint.letterSpacing), - mPaintFlags(paint.paintFlags), mIsRtl(dir), - mChars(chars), mNchars(nchars) { + mPaintFlags(paint.paintFlags), mIsRtl(dir) { } bool operator==(const LayoutCacheKey &other) const; hash_t hash() const; diff --git a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp index a251ddadbf..972f3f1d14 100644 --- a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp @@ -49,7 +49,7 @@ float MinikinFontFreeType::GetHorizontalAdvance(uint32_t glyph_id, FT_Set_Pixel_Sizes(mTypeface, 0, paint.size); FT_UInt32 flags = FT_LOAD_DEFAULT; // TODO: respect hinting settings FT_Fixed advance; - FT_Error error = FT_Get_Advance(mTypeface, glyph_id, flags, &advance); + FT_Get_Advance(mTypeface, glyph_id, flags, &advance); return advance * (1.0 / 65536); } diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index 51fcf47e58..f892b8c987 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -55,8 +55,6 @@ FontCollection *makeFontCollection() { }; FontFamily *family = new FontFamily(); - FT_Face face; - FT_Error error; for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { const char *fn = fns[i]; SkTypeface *skFace = SkTypeface::CreateFromFile(fn); @@ -118,7 +116,6 @@ int runMinikinTest() { Layout layout; layout.setFontCollection(collection); const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87"; - const char *style = "font-size: 32; font-weight: 700;"; int bidiFlags = 0; FontStyle fontStyle(7); MinikinPaint minikinPaint; From 65866430cf310c8711d77b2feff70a25006cb948 Mon Sep 17 00:00:00 2001 From: Narayan Kamath Date: Mon, 5 Jan 2015 11:44:09 +0000 Subject: [PATCH 068/364] Remove hardcoded ICU include paths. ICU exports them using LOCAL_EXPORT_C_INCLUDE_DIRS. bug: 18581021 Change-Id: Ia57b3b4d231966203274b0e7e7b850beb1bd11c0 --- engine/src/flutter/libs/minikin/Android.mk | 1 - engine/src/flutter/sample/Android.mk | 2 -- 2 files changed, 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 60a46efcf9..d9c973d97f 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -33,7 +33,6 @@ LOCAL_MODULE := libminikin LOCAL_C_INCLUDES += \ external/harfbuzz_ng/src \ external/freetype/include \ - external/icu/icu4c/source/common \ frameworks/minikin/include LOCAL_SHARED_LIBRARIES := \ diff --git a/engine/src/flutter/sample/Android.mk b/engine/src/flutter/sample/Android.mk index 101a413cae..c4a644d74d 100644 --- a/engine/src/flutter/sample/Android.mk +++ b/engine/src/flutter/sample/Android.mk @@ -21,7 +21,6 @@ LOCAL_MODULE_TAGS := tests LOCAL_C_INCLUDES += \ external/harfbuzz_ng/src \ external/freetype/include \ - external/icu/icu4c/source/common \ frameworks/minikin/include LOCAL_SRC_FILES:= example.cpp @@ -49,7 +48,6 @@ LOCAL_MODULE_TAG := tests LOCAL_C_INCLUDES += \ external/harfbuzz_ng/src \ external/freetype/include \ - external/icu/icu4c/source/common \ frameworks/minikin/include \ external/skia/src/core From 4c4af7f4dc0723f5340bf3b589805d883ea39df8 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Wed, 25 Feb 2015 11:56:34 -0800 Subject: [PATCH 069/364] Disable HarfBuzz's fallback to compatibility decompositions Previously, HarfBuzz's default fallback to compatibility decompositions resulted in Mathematical Alphanumeric Symbols getting rendered as normal letters and digits when there was no font available to render them. This patch disables that fallback, to ensure they are displayed as tofus. Based on a patch by Behdad Esfahbod. Bug: 19202569 Change-Id: I357f172302448d4ab0b24efc86119f1977b5996b --- engine/src/flutter/libs/minikin/Layout.cpp | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 344766a5ec..375f61d54f 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -173,13 +173,24 @@ private: static const size_t kMaxEntries = 100; }; +static unsigned int disabledDecomposeCompatibility(hb_unicode_funcs_t*, hb_codepoint_t, + hb_codepoint_t*, void*) { + return 0; +} + class LayoutEngine : public Singleton { public: LayoutEngine() { + unicodeFunctions = hb_unicode_funcs_create(hb_icu_get_unicode_funcs()); + /* Disable the function used for compatibility decomposition */ + hb_unicode_funcs_set_decompose_compatibility_func( + unicodeFunctions, disabledDecomposeCompatibility, NULL, NULL); hbBuffer = hb_buffer_create(); + hb_buffer_set_unicode_funcs(hbBuffer, unicodeFunctions); } hb_buffer_t* hbBuffer; + hb_unicode_funcs_t* unicodeFunctions; LayoutCache layoutCache; HbFaceCache hbFaceCache; }; @@ -402,7 +413,7 @@ int Layout::findFace(FakedFont face, LayoutContext* ctx) { static hb_script_t codePointToScript(hb_codepoint_t codepoint) { static hb_unicode_funcs_t* u = 0; if (!u) { - u = hb_icu_get_unicode_funcs(); + u = LayoutEngine::getInstance().unicodeFunctions; } return hb_unicode_script(u, codepoint); } @@ -709,7 +720,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t srunend = srunstart; hb_script_t script = getScriptRun(buf + start, run.end, &srunend); - hb_buffer_reset(buffer); + hb_buffer_clear_contents(buffer); hb_buffer_set_script(buffer, script); hb_buffer_set_direction(buffer, isRtl? HB_DIRECTION_RTL : HB_DIRECTION_LTR); FontLanguage language = ctx->style.getLanguage(); From aa1337a41a1da0d7472240dc04fd6431c1f37a90 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 29 Jan 2015 16:28:37 -0800 Subject: [PATCH 070/364] HyphenEdit in support of hyphenation Adds a "HyphenEdit" field to the Minikin Paint object, which represents an edit to the text to add a hyphen (and, in the future, other edits to support nonstandard hyphenation). Change-Id: Ib4ee690b0fe2137e1d1e2c9251e5526b274ec3a7 --- .../src/flutter/include/minikin/MinikinFont.h | 16 +++++++++++++++- engine/src/flutter/libs/minikin/Layout.cpp | 18 +++++++++++++++++- 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 3f07589697..ee885f497c 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -27,6 +27,18 @@ namespace android { +// The hyphen edit represents an edit to the string when a word is +// hyphenated. The most common hyphen edit is adding a "-" at the end +// of a syllable, but nonstandard hyphenation allows for more choices. +class HyphenEdit { +public: + HyphenEdit() : hyphen(0) { } + HyphenEdit(uint32_t hyphenInt) : hyphen(hyphenInt) { } + bool hasHyphen() const { return hyphen != 0; } +private: + uint32_t hyphen; +}; + class MinikinFont; // Possibly move into own .h file? @@ -36,7 +48,8 @@ struct MinikinPaint { fakery(), fontFeatureSettings() { } bool skipCache() const { - return !fontFeatureSettings.empty(); + // TODO: add hyphen to cache + return !fontFeatureSettings.empty() || hyphenEdit.hasHyphen(); } MinikinFont *font; @@ -46,6 +59,7 @@ struct MinikinPaint { float letterSpacing; uint32_t paintFlags; FontFakery fakery; + HyphenEdit hyphenEdit; std::string fontFeatureSettings; }; diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 375f61d54f..8e5e546283 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -594,12 +594,15 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, bool isRtl, LayoutContext* ctx, size_t dstStart) { + HyphenEdit hyphen = ctx->paint.hyphenEdit; if (!isRtl) { // left to right size_t wordstart = start == bufSize ? start : getPrevWordBreak(buf, start + 1); size_t wordend; for (size_t iter = start; iter < start + count; iter = wordend) { wordend = getNextWordBreak(buf, iter, bufSize); + // Only apply hyphen to the last word in the string. + ctx->paint.hyphenEdit = wordend >= start + count ? hyphen : HyphenEdit(); size_t wordcount = std::min(start + count, wordend) - iter; doLayoutWord(buf + wordstart, iter - wordstart, wordcount, wordend - wordstart, isRtl, ctx, iter - dstStart); @@ -612,6 +615,8 @@ void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t wordend = end == 0 ? 0 : getNextWordBreak(buf, end - 1, bufSize); for (size_t iter = end; iter > start; iter = wordstart) { wordstart = getPrevWordBreak(buf, iter); + // Only apply hyphen to the last (leftmost) word in the string. + ctx->paint.hyphenEdit = iter == end ? hyphen : HyphenEdit(); size_t bufStart = std::max(start, wordstart); doLayoutWord(buf + wordstart, bufStart - wordstart, iter - bufStart, wordend - wordstart, isRtl, ctx, bufStart - dstStart); @@ -729,6 +734,12 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_buffer_set_language(buffer, hb_language_from_string(lang.c_str(), -1)); } hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); + if (ctx->paint.hyphenEdit.hasHyphen() && srunend > srunstart) { + // TODO: check whether this is really the desired semantics. It could have the + // effect of assigning the hyphen width to a nonspacing mark + unsigned int lastCluster = srunend - 1; + hb_buffer_add(buffer, 0x2010, lastCluster); + } hb_shape(hbFont, buffer, features.empty() ? NULL : &features[0], features.size()); unsigned int numGlyphs; hb_glyph_info_t* info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); @@ -763,7 +774,12 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t ctx->paint.font->GetBounds(&glyphBounds, glyph_ix, ctx->paint); glyphBounds.offset(x + xoff, y + yoff); mBounds.join(glyphBounds); - mAdvances[info[i].cluster - start] += xAdvance; + if (info[i].cluster - start < count) { + mAdvances[info[i].cluster - start] += xAdvance; + } else { + ALOGE("cluster %d (start %d) out of bounds of count %d", + info[i].cluster - start, start, count); + } x += xAdvance; } if (numGlyphs) From e65751d7284391c76fb6a26c03c08d20bdad5a56 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Fri, 13 Mar 2015 20:36:53 -0700 Subject: [PATCH 071/364] Add LineBreaker to Minikin This patch adds a LineBreaker class to Minikin, which will be used for computing line breaks in StaticLayout. The version in this patch contains basically the same functionality that existed before, but hopefully better performance and an interface that's suitable for more sophisticated paragraph layout. Note that this version contains a high quality strategy, which mostly works but doesn't respect varying line width. Change-Id: I02485d58b1e52856296a72cdd4efd963bc572933 --- engine/src/flutter/include/minikin/Layout.h | 11 + .../src/flutter/include/minikin/LineBreaker.h | 209 ++++++++++++ engine/src/flutter/libs/minikin/Android.mk | 1 + engine/src/flutter/libs/minikin/Layout.cpp | 13 - .../src/flutter/libs/minikin/LineBreaker.cpp | 301 ++++++++++++++++++ 5 files changed, 522 insertions(+), 13 deletions(-) create mode 100644 engine/src/flutter/include/minikin/LineBreaker.h create mode 100644 engine/src/flutter/libs/minikin/LineBreaker.cpp diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 9f8759768d..543f553ce1 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -57,6 +57,17 @@ struct LayoutGlyph { // Internal state used during layout operation class LayoutContext; +enum { + kBidi_LTR = 0, + kBidi_RTL = 1, + kBidi_Default_LTR = 2, + kBidi_Default_RTL = 3, + kBidi_Force_LTR = 4, + kBidi_Force_RTL = 5, + + kBidi_Mask = 0x7 +}; + // Lifecycle and threading assumptions for Layout: // The object is assumed to be owned by a single thread; multiple threads // may not mutate it at the same time. diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h new file mode 100644 index 0000000000..29afba0bee --- /dev/null +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -0,0 +1,209 @@ +/* + * 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. + */ + +/** + * A module for breaking paragraphs into lines, supporting high quality + * hyphenation and justification. + */ + +#ifndef MINIKIN_LINE_BREAKER_H +#define MINIKIN_LINE_BREAKER_H + +#include "unicode/brkiter.h" +#include "unicode/locid.h" +#include +#include + +namespace android { + +enum BreakStrategy { + kBreakStrategy_Greedy = 0, + kBreakStrategy_HighQuality = 1, + kBreakStrategy_Balanced = 2 +}; + +// TODO: want to generalize to be able to handle array of line widths +class LineWidths { + public: + void setWidths(float firstWidth, int firstWidthLineCount, float restWidth) { + mFirstWidth = firstWidth; + mFirstWidthLineCount = firstWidthLineCount; + mRestWidth = restWidth; + } + float getLineWidth(int line) const { + return (line < mFirstWidthLineCount) ? mFirstWidth : mRestWidth; + } + private: + float mFirstWidth; + int mFirstWidthLineCount; + float mRestWidth; +}; + +class TabStops { + public: + void set(const int* stops, size_t nStops, int tabWidth) { + if (stops != nullptr) { + mStops.assign(stops, stops + nStops); + } else { + mStops.clear(); + } + mTabWidth = tabWidth; + } + float nextTab(float widthSoFar) const { + for (size_t i = 0; i < mStops.size(); i++) { + if (mStops[i] > widthSoFar) { + return mStops[i]; + } + } + return floor(widthSoFar / mTabWidth + 1) * mTabWidth; + } + private: + std::vector mStops; + int mTabWidth; +}; + +class LineBreaker { + public: + ~LineBreaker() { + utext_close(&mUText); + delete mBreakIterator; + } + + // Note: Locale persists across multiple invocations (it is not cleaned up by finish()), + // explicitly to avoid the cost of creating ICU BreakIterator objects. It should always + // be set on the first invocation, but callers are encouraged not to call again unless + // locale has actually changed. + // That logic could be here but it's better for performance that it's upstream because of + // the cost of constructing and comparing the ICU Locale object. + void setLocale(const icu::Locale& locale) { + delete mBreakIterator; + UErrorCode status = U_ZERO_ERROR; + mBreakIterator = icu::BreakIterator::createLineInstance(locale, status); + // TODO: check status + // TODO: load hyphenator from locale + } + + void resize(size_t size) { + mTextBuf.resize(size); + mCharWidths.resize(size); + } + + size_t size() const { + return mTextBuf.size(); + } + + uint16_t* buffer() { + return mTextBuf.data(); + } + + float* charWidths() { + return mCharWidths.data(); + } + + // set text to current contents of buffer + void setText(); + + void setLineWidths(float firstWidth, int firstWidthLineCount, float restWidth); + + void setTabStops(const int* stops, size_t nStops, int tabWidth) { + mTabStops.set(stops, nStops, tabWidth); + } + + BreakStrategy getStrategy() const { return mStrategy; } + + void setStrategy(BreakStrategy strategy) { mStrategy = strategy; } + + // TODO: this class is actually fairly close to being general and not tied to using + // Minikin to do the shaping of the strings. The main thing that would need to be changed + // is having some kind of callback (or virtual class, or maybe even template), which could + // easily be instantiated with Minikin's Layout. Future work for when needed. + float addStyleRun(const MinikinPaint* paint, const FontCollection* typeface, + FontStyle style, size_t start, size_t end, bool isRtl); + + void addReplacement(size_t start, size_t end, float width); + + size_t computeBreaks(); + + const int* getBreaks() const { + return mBreaks.data(); + } + + const float* getWidths() const { + return mWidths.data(); + } + + const uint8_t* getFlags() const { + return mFlags.data(); + } + + void finish(); + + private: + // ParaWidth is used to hold cumulative width from beginning of paragraph. Note that for + // very large 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; + + // A single candidate break + struct Candidate { + size_t offset; // offset to text buffer, in code units + size_t prev; // index to previous break + ParaWidth preBreak; + ParaWidth postBreak; + float penalty; // penalty of this break (for example, hyphen penalty) + float score; // best score found for this break + }; + + float currentLineWidth() const; + + void addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, float penalty); + + void addCandidate(Candidate cand); + + void computeBreaksGreedy(); + + void computeBreaksOpt(); + + icu::BreakIterator* mBreakIterator = nullptr; + UText mUText = UTEXT_INITIALIZER; + std::vectormTextBuf; + std::vectormCharWidths; + + // layout parameters + BreakStrategy mStrategy = kBreakStrategy_Greedy; + LineWidths mLineWidths; + TabStops mTabStops; + + // result of line breaking + std::vector mBreaks; + std::vector mWidths; + std::vector mFlags; + + ParaWidth mWidth = 0; + std::vector mCandidates; + + // the following are state for greedy breaker (updated while adding style runs) + size_t mLastBreak; + size_t mBestBreak; + float mBestScore; + ParaWidth mPreBreak; // prebreak of last break + int mFirstTabIndex; +}; + +} // namespace android + +#endif // MINIKIN_LINE_BREAKER_H diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index d9c973d97f..54068243ee 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -23,6 +23,7 @@ LOCAL_SRC_FILES := \ FontFamily.cpp \ GraphemeBreak.cpp \ Layout.cpp \ + LineBreaker.cpp \ MinikinInternal.cpp \ MinikinRefCounted.cpp \ MinikinFontFreeType.cpp \ diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 8e5e546283..28dac7f644 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -43,19 +43,6 @@ using std::vector; namespace android { -// TODO: these should move into the header file, but for now we don't want -// to cause namespace collisions with TextLayout.h -enum { - kBidi_LTR = 0, - kBidi_RTL = 1, - kBidi_Default_LTR = 2, - kBidi_Default_RTL = 3, - kBidi_Force_LTR = 4, - kBidi_Force_RTL = 5, - - kBidi_Mask = 0x7 -}; - const int kDirection_Mask = 0x1; struct LayoutContext { diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp new file mode 100644 index 0000000000..99d7f69de5 --- /dev/null +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -0,0 +1,301 @@ +/* + * 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. + */ + +#define VERBOSE_DEBUG 0 + +#include + +#define LOG_TAG "Minikin" +#include + +#include +#include + +using std::vector; + +namespace android { + +const int CHAR_TAB = 0x0009; + +// Large scores in a hierarchy; we prefer desperate breaks to an overfull line. All these +// constants are larger than any reasonable actual width score. +const float SCORE_INFTY = std::numeric_limits::max(); +const float SCORE_OVERFULL = 1e12f; +const float SCORE_DESPERATE = 1e10f; + +// When the text buffer is within this limit, capacity of vectors is retained at finish(), +// to avoid allocation. +const size_t MAX_TEXT_BUF_RETAIN = 32678; + +void LineBreaker::setText() { + UErrorCode status = U_ZERO_ERROR; + utext_openUChars(&mUText, mTextBuf.data(), mTextBuf.size(), &status); + mBreakIterator->setText(&mUText, status); + mBreakIterator->first(); + + // handle initial break here because addStyleRun may never be called + mBreakIterator->next(); + mCandidates.clear(); + Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0}; + mCandidates.push_back(cand); + + // reset greedy breaker state + mBreaks.clear(); + mWidths.clear(); + mFlags.clear(); + mLastBreak = 0; + mBestBreak = 0; + mBestScore = SCORE_INFTY; + mPreBreak = 0; + mFirstTabIndex = INT_MAX; +} + +void LineBreaker::setLineWidths(float firstWidth, int firstWidthLineCount, float restWidth) { + ALOGD("width %f", firstWidth); + mLineWidths.setWidths(firstWidth, firstWidthLineCount, restWidth); +} + +// This function determines whether a character is a space that disappears at end of line. +// It is the Unicode set: [[:General_Category=Space_Separator:]-[:Line_Break=Glue:]] +// Note: all such characters are in the BMP, so it's ok to use code units for this. +static bool isLineEndSpace(uint16_t c) { + return c == ' ' || c == 0x1680 || (0x2000 <= c && c <= 0x200A && c != 0x2007) || c == 0x205F || + c == 0x3000; +} + +// Ordinarily, this method measures the text in the range given. However, when paint +// is nullptr, it assumes the widths have already been calculated and stored in the +// width buffer. +// This method finds the candidate word breaks (using the ICU break iterator) and sends them +// to addCandidate. +float LineBreaker::addStyleRun(const MinikinPaint* paint, const FontCollection* typeface, + FontStyle style, size_t start, size_t end, bool isRtl) { + Layout layout; // performance TODO: move layout to self object to reduce allocation cost? + float width = 0.0f; + int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; + + if (paint != nullptr) { + layout.setFontCollection(typeface); + layout.doLayout(mTextBuf.data(), start, end - start, mTextBuf.size(), bidiFlags, style, + *paint); + layout.getAdvances(mCharWidths.data() + start); + width = layout.getAdvance(); + } + + ParaWidth postBreak = mWidth; + size_t current = (size_t)mBreakIterator->current(); + for (size_t i = start; i < end; i++) { + uint16_t c = mTextBuf[i]; + if (c == CHAR_TAB) { + mWidth = mPreBreak + mTabStops.nextTab(mWidth - mPreBreak); + if (mFirstTabIndex == INT_MAX) { + mFirstTabIndex = (int)i; + } + // fall back to greedy; other modes don't know how to deal with tabs + mStrategy = kBreakStrategy_Greedy; + } else { + mWidth += mCharWidths[i]; + if (!isLineEndSpace(c)) { + postBreak = mWidth; + } + } + if (i + 1 == current) { + // TODO: hyphenation goes here + + // Skip break for zero-width characters. + if (current == mTextBuf.size() || mCharWidths[current] > 0) { + addWordBreak(current, mWidth, postBreak, 0); + } + current = (size_t)mBreakIterator->next(); + } + } + + return width; +} + +// add a word break (possibly for a hyphenated fragment), and add desperate breaks if +// needed (ie when word exceeds current line width) +void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, + float penalty) { + Candidate cand; + ParaWidth width = mCandidates.back().preBreak; + if (postBreak - width > currentLineWidth()) { + // Add desperate breaks. + // Note: these breaks are based on the shaping of the (non-broken) original text; they + // are imprecise especially in the presence of kerning, ligatures, and Arabic shaping. + size_t i = mCandidates.back().offset; + width += mCharWidths[i++]; + for (; i < offset; i++) { + float w = mCharWidths[i]; + if (w > 0) { + cand.offset = i; + cand.preBreak = width; + cand.postBreak = width; + cand.penalty = SCORE_DESPERATE; +#if VERBOSE_DEBUG + ALOGD("desperate cand: %d %g:%g", + mCandidates.size(), cand.postBreak, cand.preBreak); +#endif + addCandidate(cand); + width += w; + } + } + } + + cand.offset = offset; + cand.preBreak = preBreak; + cand.postBreak = postBreak; + cand.penalty = penalty; +#if VERBOSE_DEBUG + ALOGD("cand: %d %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); +#endif + addCandidate(cand); +} + +// TODO performance: could avoid populating mCandidates if greedy only +void LineBreaker::addCandidate(Candidate cand) { + size_t candIndex = mCandidates.size(); + mCandidates.push_back(cand); + if (cand.postBreak - mPreBreak > currentLineWidth()) { + // This break would create an overfull line, pick the best break and break there (greedy) + if (mBestBreak == mLastBreak) { + mBestBreak = candIndex; + } + mBreaks.push_back(mCandidates[mBestBreak].offset); + mWidths.push_back(mCandidates[mBestBreak].postBreak - mPreBreak); + mFlags.push_back(mFirstTabIndex < mBreaks.back()); + mFirstTabIndex = INT_MAX; + mBestScore = SCORE_INFTY; +#if VERBOSE_DEBUG + ALOGD("break: %d %g", mBreaks.back(), mWidths.back()); +#endif + mLastBreak = mBestBreak; + mPreBreak = mCandidates[mBestBreak].preBreak; + } + if (cand.penalty <= mBestScore) { + mBestBreak = candIndex; + mBestScore = cand.penalty; + } +} + +void LineBreaker::addReplacement(size_t start, size_t end, float width) { + mCharWidths[start] = width; + std::fill(&mCharWidths[start + 1], &mCharWidths[end], 0.0f); + addStyleRun(nullptr, nullptr, FontStyle(), start, end, false); +} + +float LineBreaker::currentLineWidth() const { + return mLineWidths.getLineWidth(mBreaks.size()); +} + +void LineBreaker::computeBreaksGreedy() { + // All breaks but the last have been added in addCandidate already. + size_t nCand = mCandidates.size(); + if (nCand == 1 || mLastBreak != nCand - 1) { + mBreaks.push_back(mCandidates[nCand - 1].offset); + mWidths.push_back(mCandidates[nCand - 1].postBreak - mPreBreak); + mFlags.push_back(mFirstTabIndex < mBreaks.back()); + // don't need to update mFirstTabIndex or mBestScore, because we're done +#if VERBOSE_DEBUG + ALOGD("final break: %d %g", mBreaks.back(), mWidths.back()); +#endif + } +} + +void LineBreaker::computeBreaksOpt() { + // clear existing greedy break result + mBreaks.clear(); + mWidths.clear(); + mFlags.clear(); + size_t active = 0; + size_t nCand = mCandidates.size(); + float width = mLineWidths.getLineWidth(0); + // TODO: actually support non-constant width + for (size_t i = 1; i < nCand; i++) { + bool stretchIsFree = mStrategy != kBreakStrategy_Balanced && i == nCand - 1; + float best = SCORE_INFTY; + size_t bestPrev = 0; + + // Width-based component of score increases as line gets shorter, so score will always be + // at least this. + float bestHope = 0; + + ParaWidth leftEdge = mCandidates[i].postBreak - width; + for (size_t j = active; j < i; j++) { + float jScore = mCandidates[j].score; + if (jScore + bestHope >= best) continue; + float delta = mCandidates[j].preBreak - leftEdge; + + // TODO: for justified text, refine with shrink/stretch + float widthScore; + if (delta < 0) { + widthScore = SCORE_OVERFULL; + active = j + 1; + } else { + widthScore = stretchIsFree ? 0 : delta * delta; + bestHope = widthScore; + } + + float score = jScore + widthScore; + if (score <= best) { + best = score; + bestPrev = j; + } + } + mCandidates[i].score = best + mCandidates[i].penalty; + mCandidates[i].prev = bestPrev; + } + size_t prev; + for (size_t i = nCand - 1; i > 0; i = prev) { + prev = mCandidates[i].prev; + mBreaks.push_back(mCandidates[i].offset); + mWidths.push_back(mCandidates[i].postBreak - mCandidates[prev].preBreak); + mFlags.push_back(0); + } + std::reverse(mBreaks.begin(), mBreaks.end()); + std::reverse(mWidths.begin(), mWidths.end()); + std::reverse(mFlags.begin(), mFlags.end()); +} + +size_t LineBreaker::computeBreaks() { + if (mStrategy == kBreakStrategy_Greedy) { + computeBreaksGreedy(); + } else { + computeBreaksOpt(); + } + return mBreaks.size(); +} + +void LineBreaker::finish() { + mWidth = 0; + mCandidates.clear(); + mBreaks.clear(); + mWidths.clear(); + mFlags.clear(); + if (mTextBuf.size() > MAX_TEXT_BUF_RETAIN) { + mTextBuf.clear(); + mTextBuf.shrink_to_fit(); + mCharWidths.clear(); + mCharWidths.shrink_to_fit(); + mCandidates.shrink_to_fit(); + mBreaks.shrink_to_fit(); + mWidths.shrink_to_fit(); + mFlags.shrink_to_fit(); + } + mStrategy = kBreakStrategy_Greedy; +} + +} // namespace android From b038d920c433d8971b179b888220cc2a197bc227 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 18 Mar 2015 23:04:28 -0700 Subject: [PATCH 072/364] Add hyphenation to line breaking This patch adds hyphenation using the Liang hyphenation algorithm, similar to TeX. It also improves the optimized line breaker so that it works correctly and efficiently even when the line width is not constant (there is a specialization for constant width, which is probably worthwhile, but performance TODOs remain). Still to be done: * hyphenator has many shortcuts, only tested with English * interaction between punctuation and hyphenation is problematic Change-Id: I2d94a1668ebc536398b7c43fcf486333eeb7c6aa --- .../src/flutter/include/minikin/Hyphenator.h | 62 ++++++ .../src/flutter/include/minikin/LineBreaker.h | 45 ++-- engine/src/flutter/libs/minikin/Android.mk | 1 + .../src/flutter/libs/minikin/Hyphenator.cpp | 152 ++++++++++++++ .../src/flutter/libs/minikin/LineBreaker.cpp | 194 ++++++++++++++---- 5 files changed, 406 insertions(+), 48 deletions(-) create mode 100644 engine/src/flutter/include/minikin/Hyphenator.h create mode 100644 engine/src/flutter/libs/minikin/Hyphenator.cpp diff --git a/engine/src/flutter/include/minikin/Hyphenator.h b/engine/src/flutter/include/minikin/Hyphenator.h new file mode 100644 index 0000000000..581c657fbe --- /dev/null +++ b/engine/src/flutter/include/minikin/Hyphenator.h @@ -0,0 +1,62 @@ +/* + * 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. + */ + +/** + * An implementation of Liang's hyphenation algorithm. + */ + +#include +#include + +#ifndef MINIKIN_HYPHENATOR_H +#define MINIKIN_HYPHENATOR_H + +namespace android { + +class Trie { +public: + std::vector result; + std::unordered_map succ; +}; + +class Hyphenator { +public: + // Note: this will also require a locale, for proper case folding behavior + static Hyphenator* load(const uint16_t* patternData, size_t size); + + // Compute the hyphenation of a word, storing the hyphenation in result vector. Each + // entry in the vector is a "hyphen edit" to be applied at the corresponding code unit + // offset in the word. Currently 0 means no hyphen and 1 means insert hyphen and break, + // but this will be expanded to other edits for nonstandard hyphenation. + // Example: word is "hyphen", result is [0 0 1 0 0 0], corresponding to "hy-phen". + void hyphenate(std::vector* result, const uint16_t* word, size_t len); + +private: + void addPattern(const uint16_t* pattern, size_t size); + + void hyphenateSoft(std::vector* result, const uint16_t* word, size_t len); + + // TODO: these should become parameters, as they might vary by locale, screen size, and + // possibly explicit user control. + static const int MIN_PREFIX = 2; + static const int MIN_SUFFIX = 3; + + Trie root; +}; + +} // namespace android + +#endif // MINIKIN_HYPHENATOR_H \ No newline at end of file diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index 29afba0bee..92e72e249c 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -26,6 +26,7 @@ #include "unicode/locid.h" #include #include +#include "minikin/Hyphenator.h" namespace android { @@ -43,6 +44,10 @@ class LineWidths { mFirstWidthLineCount = firstWidthLineCount; mRestWidth = restWidth; } + bool isConstant() const { + // technically mFirstWidthLineCount == 0 would count too, but doesn't actually happen + return mRestWidth == mFirstWidth; + } float getLineWidth(int line) const { return (line < mFirstWidthLineCount) ? mFirstWidth : mRestWidth; } @@ -77,6 +82,8 @@ class TabStops { class LineBreaker { public: + const static int kTab_Shift = 29; // keep synchronized with TAB_MASK in StaticLayout.java + ~LineBreaker() { utext_close(&mUText); delete mBreakIterator; @@ -88,13 +95,8 @@ class LineBreaker { // locale has actually changed. // That logic could be here but it's better for performance that it's upstream because of // the cost of constructing and comparing the ICU Locale object. - void setLocale(const icu::Locale& locale) { - delete mBreakIterator; - UErrorCode status = U_ZERO_ERROR; - mBreakIterator = icu::BreakIterator::createLineInstance(locale, status); - // TODO: check status - // TODO: load hyphenator from locale - } + // Note: caller is responsible for managing lifetime of hyphenator + void setLocale(const icu::Locale& locale, Hyphenator* hyphenator); void resize(size_t size) { mTextBuf.resize(size); @@ -130,8 +132,8 @@ class LineBreaker { // Minikin to do the shaping of the strings. The main thing that would need to be changed // is having some kind of callback (or virtual class, or maybe even template), which could // easily be instantiated with Minikin's Layout. Future work for when needed. - float addStyleRun(const MinikinPaint* paint, const FontCollection* typeface, - FontStyle style, size_t start, size_t end, bool isRtl); + float addStyleRun(MinikinPaint* paint, const FontCollection* typeface, FontStyle style, + size_t start, size_t end, bool isRtl); void addReplacement(size_t start, size_t end, float width); @@ -145,7 +147,7 @@ class LineBreaker { return mWidths.data(); } - const uint8_t* getFlags() const { + const int* getFlags() const { return mFlags.data(); } @@ -166,23 +168,40 @@ class LineBreaker { ParaWidth postBreak; float penalty; // penalty of this break (for example, hyphen penalty) float score; // best score found for this break + size_t lineNumber; // only updated for non-constant line widths + uint8_t hyphenEdit; }; float currentLineWidth() const; - void addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, float penalty); + // compute shrink/stretch penalty for line + float computeScore(float delta, bool atEnd); + + void addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, float penalty, + uint8_t hyph); void addCandidate(Candidate cand); + // push an actual break to the output. Takes care of setting flags for tab + void pushBreak(int offset, float width, uint8_t hyph); + void computeBreaksGreedy(); - void computeBreaksOpt(); + void computeBreaksOptimal(); + + // special case when LineWidth is constant (layout is rectangle) + void computeBreaksOptimalRect(); + + void finishBreaksOptimal(); icu::BreakIterator* mBreakIterator = nullptr; UText mUText = UTEXT_INITIALIZER; std::vectormTextBuf; std::vectormCharWidths; + Hyphenator* mHyphenator; + std::vector mHyphBuf; + // layout parameters BreakStrategy mStrategy = kBreakStrategy_Greedy; LineWidths mLineWidths; @@ -191,7 +210,7 @@ class LineBreaker { // result of line breaking std::vector mBreaks; std::vector mWidths; - std::vector mFlags; + std::vector mFlags; ParaWidth mWidth = 0; std::vector mCandidates; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 54068243ee..34b535cabd 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -22,6 +22,7 @@ LOCAL_SRC_FILES := \ FontCollection.cpp \ FontFamily.cpp \ GraphemeBreak.cpp \ + Hyphenator.cpp \ Layout.cpp \ LineBreaker.cpp \ MinikinInternal.cpp \ diff --git a/engine/src/flutter/libs/minikin/Hyphenator.cpp b/engine/src/flutter/libs/minikin/Hyphenator.cpp new file mode 100644 index 0000000000..c50b3861af --- /dev/null +++ b/engine/src/flutter/libs/minikin/Hyphenator.cpp @@ -0,0 +1,152 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include + +// HACK: for reading pattern file +#include + +#define LOG_TAG "Minikin" +#include "utils/Log.h" + +#include "minikin/Hyphenator.h" + +using std::vector; + +namespace android { + +static const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; + +void Hyphenator::addPattern(const uint16_t* pattern, size_t size) { + vector word; + vector result; + + // start by parsing the Liang-format pattern into a word and a result vector, the + // vector right-aligned but without leading zeros. Examples: + // a1bc2d -> abcd [1, 0, 2, 0] + // abc1 -> abc [1] + // 1a2b3c4d5 -> abcd [1, 2, 3, 4, 5] + bool lastWasLetter = false; + bool haveSeenNumber = false; + for (size_t i = 0; i < size; i++) { + uint16_t c = pattern[i]; + if (isdigit(c)) { + result.push_back(c - '0'); + lastWasLetter = false; + haveSeenNumber = true; + } else { + word.push_back(c); + if (lastWasLetter && haveSeenNumber) { + result.push_back(0); + } + lastWasLetter = true; + } + } + if (lastWasLetter) { + result.push_back(0); + } + Trie* t = &root; + for (size_t i = 0; i < word.size(); i++) { + t = &t->succ[word[i]]; + } + t->result = result; +} + +// If any soft hyphen is present in the word, use soft hyphens to decide hyphenation, +// as recommended in UAX #14 (Use of Soft Hyphen) +void Hyphenator::hyphenateSoft(vector* result, const uint16_t* word, size_t len) { + (*result)[0] = 0; + for (size_t i = 1; i < len; i++) { + (*result)[i] = word[i - 1] == CHAR_SOFT_HYPHEN; + } +} + +void Hyphenator::hyphenate(vector* result, const uint16_t* word, size_t len) { + result->clear(); + result->resize(len); + if (len < MIN_PREFIX + MIN_SUFFIX) return; + size_t maxOffset = len - MIN_SUFFIX + 1; + for (size_t i = 0; i < len + 1; i++) { + const Trie* node = &root; + for (size_t j = i; j < len + 2; j++) { + uint16_t c; + if (j == 0 || j == len + 1) { + c = '.'; // word boundary character in pattern data files + } else { + c = word[j - 1]; + if (c == CHAR_SOFT_HYPHEN) { + hyphenateSoft(result, word, len); + return; + } + // TODO: use locale-sensitive case folding from ICU. + c = tolower(c); + } + auto search = node->succ.find(c); + if (search != node->succ.end()) { + node = &search->second; + } else { + break; + } + if (!node->result.empty()) { + int resultLen = node->result.size(); + int offset = j + 1 - resultLen; + int start = std::max(MIN_PREFIX - offset, 0); + int end = std::min(resultLen, (int)maxOffset - offset); + // TODO performance: this inner loop can profitably be optimized + for (int k = start; k < end; k++) { + (*result)[offset + k] = std::max((*result)[offset + k], node->result[k]); + } +#if 0 + // debug printing of matched patterns + std::string dbg; + for (size_t k = i; k <= j + 1; k++) { + int off = k - j - 2 + resultLen; + if (off >= 0 && node->result[off] != 0) { + dbg.push_back((char)('0' + node->result[off])); + } + if (k < j + 1) { + uint16_t c = (k == 0 || k == len + 1) ? '.' : word[k - 1]; + dbg.push_back((char)c); + } + } + ALOGD("%d:%d %s", i, j, dbg.c_str()); +#endif + } + } + } + // Since the above calculation does not modify values outside + // [MIN_PREFIX, len - MIN_SUFFIX], they are left as 0. + for (size_t i = MIN_PREFIX; i < maxOffset; i++) { + (*result)[i] &= 1; + } +} + +Hyphenator* Hyphenator::load(const uint16_t *patternData, size_t size) { + Hyphenator* result = new Hyphenator; + for (size_t i = 0; i < size; i++) { + size_t end = i; + while (patternData[end] != '\n') end++; + result->addPattern(patternData + i, end - i); + i = end; + } + return result; +} + +} // namespace android diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 99d7f69de5..f7f3fb3fd0 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -29,6 +29,7 @@ using std::vector; namespace android { const int CHAR_TAB = 0x0009; +const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; // Large scores in a hierarchy; we prefer desperate breaks to an overfull line. All these // constants are larger than any reasonable actual width score. @@ -40,6 +41,16 @@ const float SCORE_DESPERATE = 1e10f; // to avoid allocation. const size_t MAX_TEXT_BUF_RETAIN = 32678; +void LineBreaker::setLocale(const icu::Locale& locale, Hyphenator* hyphenator) { + delete mBreakIterator; + UErrorCode status = U_ZERO_ERROR; + mBreakIterator = icu::BreakIterator::createLineInstance(locale, status); + // TODO: check status + + // TODO: load actual resource dependent on locale; letting Minikin do it is a hack + mHyphenator = hyphenator; +} + void LineBreaker::setText() { UErrorCode status = U_ZERO_ERROR; utext_openUChars(&mUText, mTextBuf.data(), mTextBuf.size(), &status); @@ -49,7 +60,7 @@ void LineBreaker::setText() { // handle initial break here because addStyleRun may never be called mBreakIterator->next(); mCandidates.clear(); - Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0}; + Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0, 0, 0}; mCandidates.push_back(cand); // reset greedy breaker state @@ -64,7 +75,6 @@ void LineBreaker::setText() { } void LineBreaker::setLineWidths(float firstWidth, int firstWidthLineCount, float restWidth) { - ALOGD("width %f", firstWidth); mLineWidths.setWidths(firstWidth, firstWidthLineCount, restWidth); } @@ -81,22 +91,29 @@ static bool isLineEndSpace(uint16_t c) { // width buffer. // This method finds the candidate word breaks (using the ICU break iterator) and sends them // to addCandidate. -float LineBreaker::addStyleRun(const MinikinPaint* paint, const FontCollection* typeface, +float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typeface, FontStyle style, size_t start, size_t end, bool isRtl) { Layout layout; // performance TODO: move layout to self object to reduce allocation cost? float width = 0.0f; int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; + float hyphenPenalty = 0.0; if (paint != nullptr) { layout.setFontCollection(typeface); layout.doLayout(mTextBuf.data(), start, end - start, mTextBuf.size(), bidiFlags, style, *paint); layout.getAdvances(mCharWidths.data() + start); width = layout.getAdvance(); + + // a heuristic that seems to perform well + hyphenPenalty = 0.5 * paint->size * paint->scaleX * mLineWidths.getLineWidth(0); } - ParaWidth postBreak = mWidth; size_t current = (size_t)mBreakIterator->current(); + size_t wordEnd = start; + size_t lastBreak = start; + ParaWidth lastBreakWidth = mWidth; + ParaWidth postBreak = mWidth; for (size_t i = start; i < end; i++) { uint16_t c = mTextBuf[i]; if (c == CHAR_TAB) { @@ -110,14 +127,48 @@ float LineBreaker::addStyleRun(const MinikinPaint* paint, const FontCollection* mWidth += mCharWidths[i]; if (!isLineEndSpace(c)) { postBreak = mWidth; + wordEnd = i + 1; } } if (i + 1 == current) { - // TODO: hyphenation goes here + // Override ICU's treatment of soft hyphen as a break opportunity, because we want it + // to be a hyphen break, with penalty and drawing behavior. + if (c != CHAR_SOFT_HYPHEN) { + if (paint != nullptr && mHyphenator != nullptr && wordEnd > lastBreak) { + mHyphenator->hyphenate(&mHyphBuf, &mTextBuf[lastBreak], wordEnd - lastBreak); + #if VERBOSE_DEBUG + std::string hyphenatedString; + for (size_t j = lastBreak; j < wordEnd; j++) { + if (mHyphBuf[j - lastBreak]) hyphenatedString.push_back('-'); + // Note: only works with ASCII, should do UTF-8 conversion here + hyphenatedString.push_back(buffer()[j]); + } + ALOGD("hyphenated string: %s", hyphenatedString.c_str()); + #endif - // Skip break for zero-width characters. - if (current == mTextBuf.size() || mCharWidths[current] > 0) { - addWordBreak(current, mWidth, postBreak, 0); + // measure hyphenated substrings + for (size_t j = lastBreak; j < wordEnd; j++) { + uint8_t hyph = mHyphBuf[j - lastBreak]; + if (hyph) { + paint->hyphenEdit = hyph; + layout.doLayout(mTextBuf.data(), lastBreak, j - lastBreak, + mTextBuf.size(), bidiFlags, style, *paint); + ParaWidth hyphPostBreak = lastBreakWidth + layout.getAdvance(); + paint->hyphenEdit = 0; + layout.doLayout(mTextBuf.data(), j, wordEnd - j, + mTextBuf.size(), bidiFlags, style, *paint); + ParaWidth hyphPreBreak = postBreak - layout.getAdvance(); + addWordBreak(j, hyphPreBreak, hyphPostBreak, hyphenPenalty, hyph); + } + } + } + + // Skip break for zero-width characters. + if (current == mTextBuf.size() || mCharWidths[current] > 0) { + addWordBreak(current, mWidth, postBreak, 0.0, 0); + } + lastBreak = current; + lastBreakWidth = mWidth; } current = (size_t)mBreakIterator->next(); } @@ -129,7 +180,7 @@ float LineBreaker::addStyleRun(const MinikinPaint* paint, const FontCollection* // add a word break (possibly for a hyphenated fragment), and add desperate breaks if // needed (ie when word exceeds current line width) void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, - float penalty) { + float penalty, uint8_t hyph) { Candidate cand; ParaWidth width = mCandidates.back().preBreak; if (postBreak - width > currentLineWidth()) { @@ -145,6 +196,7 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.preBreak = width; cand.postBreak = width; cand.penalty = SCORE_DESPERATE; + cand.hyphenEdit = 0; #if VERBOSE_DEBUG ALOGD("desperate cand: %d %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); @@ -159,12 +211,24 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.preBreak = preBreak; cand.postBreak = postBreak; cand.penalty = penalty; + cand.hyphenEdit = hyph; #if VERBOSE_DEBUG ALOGD("cand: %d %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); #endif addCandidate(cand); } +// TODO: for justified text, refine with shrink/stretch +float LineBreaker::computeScore(float delta, bool atEnd) { + if (delta < 0) { + return SCORE_OVERFULL; + } else if (atEnd && mStrategy != kBreakStrategy_Balanced) { + return 0.0; + } else { + return delta * delta; + } +} + // TODO performance: could avoid populating mCandidates if greedy only void LineBreaker::addCandidate(Candidate cand) { size_t candIndex = mCandidates.size(); @@ -174,10 +238,8 @@ void LineBreaker::addCandidate(Candidate cand) { if (mBestBreak == mLastBreak) { mBestBreak = candIndex; } - mBreaks.push_back(mCandidates[mBestBreak].offset); - mWidths.push_back(mCandidates[mBestBreak].postBreak - mPreBreak); - mFlags.push_back(mFirstTabIndex < mBreaks.back()); - mFirstTabIndex = INT_MAX; + pushBreak(mCandidates[mBestBreak].offset, mCandidates[mBestBreak].postBreak - mPreBreak, + mCandidates[mBestBreak].hyphenEdit); mBestScore = SCORE_INFTY; #if VERBOSE_DEBUG ALOGD("break: %d %g", mBreaks.back(), mWidths.back()); @@ -191,6 +253,15 @@ void LineBreaker::addCandidate(Candidate cand) { } } +void LineBreaker::pushBreak(int offset, float width, uint8_t hyph) { + mBreaks.push_back(offset); + mWidths.push_back(width); + int flags = (mFirstTabIndex < mBreaks.back()) << kTab_Shift; + flags |= hyph; + mFlags.push_back(flags); + mFirstTabIndex = INT_MAX; +} + void LineBreaker::addReplacement(size_t start, size_t end, float width) { mCharWidths[start] = width; std::fill(&mCharWidths[start + 1], &mCharWidths[end], 0.0f); @@ -205,27 +276,87 @@ void LineBreaker::computeBreaksGreedy() { // All breaks but the last have been added in addCandidate already. size_t nCand = mCandidates.size(); if (nCand == 1 || mLastBreak != nCand - 1) { - mBreaks.push_back(mCandidates[nCand - 1].offset); - mWidths.push_back(mCandidates[nCand - 1].postBreak - mPreBreak); - mFlags.push_back(mFirstTabIndex < mBreaks.back()); - // don't need to update mFirstTabIndex or mBestScore, because we're done + pushBreak(mCandidates[nCand - 1].offset, mCandidates[nCand - 1].postBreak - mPreBreak, 0); + // don't need to update mBestScore, because we're done #if VERBOSE_DEBUG ALOGD("final break: %d %g", mBreaks.back(), mWidths.back()); #endif } } -void LineBreaker::computeBreaksOpt() { +// Follow "prev" links in mCandidates array, and copy to result arrays. +void LineBreaker::finishBreaksOptimal() { // clear existing greedy break result mBreaks.clear(); mWidths.clear(); mFlags.clear(); + size_t nCand = mCandidates.size(); + size_t prev; + for (size_t i = nCand - 1; i > 0; i = prev) { + prev = mCandidates[i].prev; + mBreaks.push_back(mCandidates[i].offset); + mWidths.push_back(mCandidates[i].postBreak - mCandidates[prev].preBreak); + mFlags.push_back(mCandidates[i].hyphenEdit); + } + std::reverse(mBreaks.begin(), mBreaks.end()); + std::reverse(mWidths.begin(), mWidths.end()); + std::reverse(mFlags.begin(), mFlags.end()); +} + +void LineBreaker::computeBreaksOptimal() { + size_t active = 0; + size_t nCand = mCandidates.size(); + for (size_t i = 1; i < nCand; i++) { + bool atEnd = i == nCand - 1; + float best = SCORE_INFTY; + size_t bestPrev = 0; + + size_t lineNumberLast = mCandidates[active].lineNumber; + float width = mLineWidths.getLineWidth(lineNumberLast); + ParaWidth leftEdge = mCandidates[i].postBreak - width; + float bestHope = 0; + + for (size_t j = active; j < i; j++) { + size_t lineNumber = mCandidates[j].lineNumber; + if (lineNumber != lineNumberLast) { + float widthNew = mLineWidths.getLineWidth(lineNumber); + if (widthNew != width) { + leftEdge = mCandidates[i].postBreak - width; + bestHope = 0; + width = widthNew; + } + lineNumberLast = lineNumber; + } + float jScore = mCandidates[j].score; + if (jScore + bestHope >= best) continue; + float delta = mCandidates[j].preBreak - leftEdge; + + float widthScore = computeScore(delta, atEnd); + if (delta < 0) { + active = j + 1; + } else { + bestHope = widthScore; + } + + float score = jScore + widthScore; + if (score <= best) { + best = score; + bestPrev = j; + } + } + mCandidates[i].score = best + mCandidates[i].penalty; + mCandidates[i].prev = bestPrev; + mCandidates[i].lineNumber = mCandidates[bestPrev].lineNumber + 1; + } + finishBreaksOptimal(); +} + +void LineBreaker::computeBreaksOptimalRect() { size_t active = 0; size_t nCand = mCandidates.size(); float width = mLineWidths.getLineWidth(0); - // TODO: actually support non-constant width for (size_t i = 1; i < nCand; i++) { - bool stretchIsFree = mStrategy != kBreakStrategy_Balanced && i == nCand - 1; + bool atEnd = i == nCand - 1; float best = SCORE_INFTY; size_t bestPrev = 0; @@ -235,17 +366,15 @@ void LineBreaker::computeBreaksOpt() { ParaWidth leftEdge = mCandidates[i].postBreak - width; for (size_t j = active; j < i; j++) { + // TODO performance: can break if bestHope >= best; worth it? float jScore = mCandidates[j].score; if (jScore + bestHope >= best) continue; float delta = mCandidates[j].preBreak - leftEdge; - // TODO: for justified text, refine with shrink/stretch - float widthScore; + float widthScore = computeScore(delta, atEnd); if (delta < 0) { - widthScore = SCORE_OVERFULL; active = j + 1; } else { - widthScore = stretchIsFree ? 0 : delta * delta; bestHope = widthScore; } @@ -258,23 +387,16 @@ void LineBreaker::computeBreaksOpt() { mCandidates[i].score = best + mCandidates[i].penalty; mCandidates[i].prev = bestPrev; } - size_t prev; - for (size_t i = nCand - 1; i > 0; i = prev) { - prev = mCandidates[i].prev; - mBreaks.push_back(mCandidates[i].offset); - mWidths.push_back(mCandidates[i].postBreak - mCandidates[prev].preBreak); - mFlags.push_back(0); - } - std::reverse(mBreaks.begin(), mBreaks.end()); - std::reverse(mWidths.begin(), mWidths.end()); - std::reverse(mFlags.begin(), mFlags.end()); + finishBreaksOptimal(); } size_t LineBreaker::computeBreaks() { if (mStrategy == kBreakStrategy_Greedy) { computeBreaksGreedy(); + } else if (mLineWidths.isConstant()) { + computeBreaksOptimalRect(); } else { - computeBreaksOpt(); + computeBreaksOptimal(); } return mBreaks.size(); } @@ -290,6 +412,8 @@ void LineBreaker::finish() { mTextBuf.shrink_to_fit(); mCharWidths.clear(); mCharWidths.shrink_to_fit(); + mHyphBuf.clear(); + mHyphBuf.shrink_to_fit(); mCandidates.shrink_to_fit(); mBreaks.shrink_to_fit(); mWidths.shrink_to_fit(); From f8ed26a065cdb58adfa5df940bd2f0f6ae70d236 Mon Sep 17 00:00:00 2001 From: Ed Heyl Date: Mon, 30 Mar 2015 20:40:33 +0000 Subject: [PATCH 073/364] Fix build: Revert "Add hyphenation to line breaking" This reverts commit b038d920c433d8971b179b888220cc2a197bc227. Change-Id: I3fed65046274d3aeb748f0730585ab89927f5741 --- .../src/flutter/include/minikin/Hyphenator.h | 62 ------ .../src/flutter/include/minikin/LineBreaker.h | 45 ++-- engine/src/flutter/libs/minikin/Android.mk | 1 - .../src/flutter/libs/minikin/Hyphenator.cpp | 152 -------------- .../src/flutter/libs/minikin/LineBreaker.cpp | 194 ++++-------------- 5 files changed, 48 insertions(+), 406 deletions(-) delete mode 100644 engine/src/flutter/include/minikin/Hyphenator.h delete mode 100644 engine/src/flutter/libs/minikin/Hyphenator.cpp diff --git a/engine/src/flutter/include/minikin/Hyphenator.h b/engine/src/flutter/include/minikin/Hyphenator.h deleted file mode 100644 index 581c657fbe..0000000000 --- a/engine/src/flutter/include/minikin/Hyphenator.h +++ /dev/null @@ -1,62 +0,0 @@ -/* - * 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. - */ - -/** - * An implementation of Liang's hyphenation algorithm. - */ - -#include -#include - -#ifndef MINIKIN_HYPHENATOR_H -#define MINIKIN_HYPHENATOR_H - -namespace android { - -class Trie { -public: - std::vector result; - std::unordered_map succ; -}; - -class Hyphenator { -public: - // Note: this will also require a locale, for proper case folding behavior - static Hyphenator* load(const uint16_t* patternData, size_t size); - - // Compute the hyphenation of a word, storing the hyphenation in result vector. Each - // entry in the vector is a "hyphen edit" to be applied at the corresponding code unit - // offset in the word. Currently 0 means no hyphen and 1 means insert hyphen and break, - // but this will be expanded to other edits for nonstandard hyphenation. - // Example: word is "hyphen", result is [0 0 1 0 0 0], corresponding to "hy-phen". - void hyphenate(std::vector* result, const uint16_t* word, size_t len); - -private: - void addPattern(const uint16_t* pattern, size_t size); - - void hyphenateSoft(std::vector* result, const uint16_t* word, size_t len); - - // TODO: these should become parameters, as they might vary by locale, screen size, and - // possibly explicit user control. - static const int MIN_PREFIX = 2; - static const int MIN_SUFFIX = 3; - - Trie root; -}; - -} // namespace android - -#endif // MINIKIN_HYPHENATOR_H \ No newline at end of file diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index 92e72e249c..29afba0bee 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -26,7 +26,6 @@ #include "unicode/locid.h" #include #include -#include "minikin/Hyphenator.h" namespace android { @@ -44,10 +43,6 @@ class LineWidths { mFirstWidthLineCount = firstWidthLineCount; mRestWidth = restWidth; } - bool isConstant() const { - // technically mFirstWidthLineCount == 0 would count too, but doesn't actually happen - return mRestWidth == mFirstWidth; - } float getLineWidth(int line) const { return (line < mFirstWidthLineCount) ? mFirstWidth : mRestWidth; } @@ -82,8 +77,6 @@ class TabStops { class LineBreaker { public: - const static int kTab_Shift = 29; // keep synchronized with TAB_MASK in StaticLayout.java - ~LineBreaker() { utext_close(&mUText); delete mBreakIterator; @@ -95,8 +88,13 @@ class LineBreaker { // locale has actually changed. // That logic could be here but it's better for performance that it's upstream because of // the cost of constructing and comparing the ICU Locale object. - // Note: caller is responsible for managing lifetime of hyphenator - void setLocale(const icu::Locale& locale, Hyphenator* hyphenator); + void setLocale(const icu::Locale& locale) { + delete mBreakIterator; + UErrorCode status = U_ZERO_ERROR; + mBreakIterator = icu::BreakIterator::createLineInstance(locale, status); + // TODO: check status + // TODO: load hyphenator from locale + } void resize(size_t size) { mTextBuf.resize(size); @@ -132,8 +130,8 @@ class LineBreaker { // Minikin to do the shaping of the strings. The main thing that would need to be changed // is having some kind of callback (or virtual class, or maybe even template), which could // easily be instantiated with Minikin's Layout. Future work for when needed. - float addStyleRun(MinikinPaint* paint, const FontCollection* typeface, FontStyle style, - size_t start, size_t end, bool isRtl); + float addStyleRun(const MinikinPaint* paint, const FontCollection* typeface, + FontStyle style, size_t start, size_t end, bool isRtl); void addReplacement(size_t start, size_t end, float width); @@ -147,7 +145,7 @@ class LineBreaker { return mWidths.data(); } - const int* getFlags() const { + const uint8_t* getFlags() const { return mFlags.data(); } @@ -168,40 +166,23 @@ class LineBreaker { ParaWidth postBreak; float penalty; // penalty of this break (for example, hyphen penalty) float score; // best score found for this break - size_t lineNumber; // only updated for non-constant line widths - uint8_t hyphenEdit; }; float currentLineWidth() const; - // compute shrink/stretch penalty for line - float computeScore(float delta, bool atEnd); - - void addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, float penalty, - uint8_t hyph); + void addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, float penalty); void addCandidate(Candidate cand); - // push an actual break to the output. Takes care of setting flags for tab - void pushBreak(int offset, float width, uint8_t hyph); - void computeBreaksGreedy(); - void computeBreaksOptimal(); - - // special case when LineWidth is constant (layout is rectangle) - void computeBreaksOptimalRect(); - - void finishBreaksOptimal(); + void computeBreaksOpt(); icu::BreakIterator* mBreakIterator = nullptr; UText mUText = UTEXT_INITIALIZER; std::vectormTextBuf; std::vectormCharWidths; - Hyphenator* mHyphenator; - std::vector mHyphBuf; - // layout parameters BreakStrategy mStrategy = kBreakStrategy_Greedy; LineWidths mLineWidths; @@ -210,7 +191,7 @@ class LineBreaker { // result of line breaking std::vector mBreaks; std::vector mWidths; - std::vector mFlags; + std::vector mFlags; ParaWidth mWidth = 0; std::vector mCandidates; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 34b535cabd..54068243ee 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -22,7 +22,6 @@ LOCAL_SRC_FILES := \ FontCollection.cpp \ FontFamily.cpp \ GraphemeBreak.cpp \ - Hyphenator.cpp \ Layout.cpp \ LineBreaker.cpp \ MinikinInternal.cpp \ diff --git a/engine/src/flutter/libs/minikin/Hyphenator.cpp b/engine/src/flutter/libs/minikin/Hyphenator.cpp deleted file mode 100644 index c50b3861af..0000000000 --- a/engine/src/flutter/libs/minikin/Hyphenator.cpp +++ /dev/null @@ -1,152 +0,0 @@ -/* - * 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. - */ - -#include -#include -#include -#include -#include - -// HACK: for reading pattern file -#include - -#define LOG_TAG "Minikin" -#include "utils/Log.h" - -#include "minikin/Hyphenator.h" - -using std::vector; - -namespace android { - -static const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; - -void Hyphenator::addPattern(const uint16_t* pattern, size_t size) { - vector word; - vector result; - - // start by parsing the Liang-format pattern into a word and a result vector, the - // vector right-aligned but without leading zeros. Examples: - // a1bc2d -> abcd [1, 0, 2, 0] - // abc1 -> abc [1] - // 1a2b3c4d5 -> abcd [1, 2, 3, 4, 5] - bool lastWasLetter = false; - bool haveSeenNumber = false; - for (size_t i = 0; i < size; i++) { - uint16_t c = pattern[i]; - if (isdigit(c)) { - result.push_back(c - '0'); - lastWasLetter = false; - haveSeenNumber = true; - } else { - word.push_back(c); - if (lastWasLetter && haveSeenNumber) { - result.push_back(0); - } - lastWasLetter = true; - } - } - if (lastWasLetter) { - result.push_back(0); - } - Trie* t = &root; - for (size_t i = 0; i < word.size(); i++) { - t = &t->succ[word[i]]; - } - t->result = result; -} - -// If any soft hyphen is present in the word, use soft hyphens to decide hyphenation, -// as recommended in UAX #14 (Use of Soft Hyphen) -void Hyphenator::hyphenateSoft(vector* result, const uint16_t* word, size_t len) { - (*result)[0] = 0; - for (size_t i = 1; i < len; i++) { - (*result)[i] = word[i - 1] == CHAR_SOFT_HYPHEN; - } -} - -void Hyphenator::hyphenate(vector* result, const uint16_t* word, size_t len) { - result->clear(); - result->resize(len); - if (len < MIN_PREFIX + MIN_SUFFIX) return; - size_t maxOffset = len - MIN_SUFFIX + 1; - for (size_t i = 0; i < len + 1; i++) { - const Trie* node = &root; - for (size_t j = i; j < len + 2; j++) { - uint16_t c; - if (j == 0 || j == len + 1) { - c = '.'; // word boundary character in pattern data files - } else { - c = word[j - 1]; - if (c == CHAR_SOFT_HYPHEN) { - hyphenateSoft(result, word, len); - return; - } - // TODO: use locale-sensitive case folding from ICU. - c = tolower(c); - } - auto search = node->succ.find(c); - if (search != node->succ.end()) { - node = &search->second; - } else { - break; - } - if (!node->result.empty()) { - int resultLen = node->result.size(); - int offset = j + 1 - resultLen; - int start = std::max(MIN_PREFIX - offset, 0); - int end = std::min(resultLen, (int)maxOffset - offset); - // TODO performance: this inner loop can profitably be optimized - for (int k = start; k < end; k++) { - (*result)[offset + k] = std::max((*result)[offset + k], node->result[k]); - } -#if 0 - // debug printing of matched patterns - std::string dbg; - for (size_t k = i; k <= j + 1; k++) { - int off = k - j - 2 + resultLen; - if (off >= 0 && node->result[off] != 0) { - dbg.push_back((char)('0' + node->result[off])); - } - if (k < j + 1) { - uint16_t c = (k == 0 || k == len + 1) ? '.' : word[k - 1]; - dbg.push_back((char)c); - } - } - ALOGD("%d:%d %s", i, j, dbg.c_str()); -#endif - } - } - } - // Since the above calculation does not modify values outside - // [MIN_PREFIX, len - MIN_SUFFIX], they are left as 0. - for (size_t i = MIN_PREFIX; i < maxOffset; i++) { - (*result)[i] &= 1; - } -} - -Hyphenator* Hyphenator::load(const uint16_t *patternData, size_t size) { - Hyphenator* result = new Hyphenator; - for (size_t i = 0; i < size; i++) { - size_t end = i; - while (patternData[end] != '\n') end++; - result->addPattern(patternData + i, end - i); - i = end; - } - return result; -} - -} // namespace android diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index f7f3fb3fd0..99d7f69de5 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -29,7 +29,6 @@ using std::vector; namespace android { const int CHAR_TAB = 0x0009; -const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; // Large scores in a hierarchy; we prefer desperate breaks to an overfull line. All these // constants are larger than any reasonable actual width score. @@ -41,16 +40,6 @@ const float SCORE_DESPERATE = 1e10f; // to avoid allocation. const size_t MAX_TEXT_BUF_RETAIN = 32678; -void LineBreaker::setLocale(const icu::Locale& locale, Hyphenator* hyphenator) { - delete mBreakIterator; - UErrorCode status = U_ZERO_ERROR; - mBreakIterator = icu::BreakIterator::createLineInstance(locale, status); - // TODO: check status - - // TODO: load actual resource dependent on locale; letting Minikin do it is a hack - mHyphenator = hyphenator; -} - void LineBreaker::setText() { UErrorCode status = U_ZERO_ERROR; utext_openUChars(&mUText, mTextBuf.data(), mTextBuf.size(), &status); @@ -60,7 +49,7 @@ void LineBreaker::setText() { // handle initial break here because addStyleRun may never be called mBreakIterator->next(); mCandidates.clear(); - Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0, 0, 0}; + Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0}; mCandidates.push_back(cand); // reset greedy breaker state @@ -75,6 +64,7 @@ void LineBreaker::setText() { } void LineBreaker::setLineWidths(float firstWidth, int firstWidthLineCount, float restWidth) { + ALOGD("width %f", firstWidth); mLineWidths.setWidths(firstWidth, firstWidthLineCount, restWidth); } @@ -91,29 +81,22 @@ static bool isLineEndSpace(uint16_t c) { // width buffer. // This method finds the candidate word breaks (using the ICU break iterator) and sends them // to addCandidate. -float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typeface, +float LineBreaker::addStyleRun(const MinikinPaint* paint, const FontCollection* typeface, FontStyle style, size_t start, size_t end, bool isRtl) { Layout layout; // performance TODO: move layout to self object to reduce allocation cost? float width = 0.0f; int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; - float hyphenPenalty = 0.0; if (paint != nullptr) { layout.setFontCollection(typeface); layout.doLayout(mTextBuf.data(), start, end - start, mTextBuf.size(), bidiFlags, style, *paint); layout.getAdvances(mCharWidths.data() + start); width = layout.getAdvance(); - - // a heuristic that seems to perform well - hyphenPenalty = 0.5 * paint->size * paint->scaleX * mLineWidths.getLineWidth(0); } - size_t current = (size_t)mBreakIterator->current(); - size_t wordEnd = start; - size_t lastBreak = start; - ParaWidth lastBreakWidth = mWidth; ParaWidth postBreak = mWidth; + size_t current = (size_t)mBreakIterator->current(); for (size_t i = start; i < end; i++) { uint16_t c = mTextBuf[i]; if (c == CHAR_TAB) { @@ -127,48 +110,14 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa mWidth += mCharWidths[i]; if (!isLineEndSpace(c)) { postBreak = mWidth; - wordEnd = i + 1; } } if (i + 1 == current) { - // Override ICU's treatment of soft hyphen as a break opportunity, because we want it - // to be a hyphen break, with penalty and drawing behavior. - if (c != CHAR_SOFT_HYPHEN) { - if (paint != nullptr && mHyphenator != nullptr && wordEnd > lastBreak) { - mHyphenator->hyphenate(&mHyphBuf, &mTextBuf[lastBreak], wordEnd - lastBreak); - #if VERBOSE_DEBUG - std::string hyphenatedString; - for (size_t j = lastBreak; j < wordEnd; j++) { - if (mHyphBuf[j - lastBreak]) hyphenatedString.push_back('-'); - // Note: only works with ASCII, should do UTF-8 conversion here - hyphenatedString.push_back(buffer()[j]); - } - ALOGD("hyphenated string: %s", hyphenatedString.c_str()); - #endif + // TODO: hyphenation goes here - // measure hyphenated substrings - for (size_t j = lastBreak; j < wordEnd; j++) { - uint8_t hyph = mHyphBuf[j - lastBreak]; - if (hyph) { - paint->hyphenEdit = hyph; - layout.doLayout(mTextBuf.data(), lastBreak, j - lastBreak, - mTextBuf.size(), bidiFlags, style, *paint); - ParaWidth hyphPostBreak = lastBreakWidth + layout.getAdvance(); - paint->hyphenEdit = 0; - layout.doLayout(mTextBuf.data(), j, wordEnd - j, - mTextBuf.size(), bidiFlags, style, *paint); - ParaWidth hyphPreBreak = postBreak - layout.getAdvance(); - addWordBreak(j, hyphPreBreak, hyphPostBreak, hyphenPenalty, hyph); - } - } - } - - // Skip break for zero-width characters. - if (current == mTextBuf.size() || mCharWidths[current] > 0) { - addWordBreak(current, mWidth, postBreak, 0.0, 0); - } - lastBreak = current; - lastBreakWidth = mWidth; + // Skip break for zero-width characters. + if (current == mTextBuf.size() || mCharWidths[current] > 0) { + addWordBreak(current, mWidth, postBreak, 0); } current = (size_t)mBreakIterator->next(); } @@ -180,7 +129,7 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa // add a word break (possibly for a hyphenated fragment), and add desperate breaks if // needed (ie when word exceeds current line width) void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, - float penalty, uint8_t hyph) { + float penalty) { Candidate cand; ParaWidth width = mCandidates.back().preBreak; if (postBreak - width > currentLineWidth()) { @@ -196,7 +145,6 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.preBreak = width; cand.postBreak = width; cand.penalty = SCORE_DESPERATE; - cand.hyphenEdit = 0; #if VERBOSE_DEBUG ALOGD("desperate cand: %d %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); @@ -211,24 +159,12 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.preBreak = preBreak; cand.postBreak = postBreak; cand.penalty = penalty; - cand.hyphenEdit = hyph; #if VERBOSE_DEBUG ALOGD("cand: %d %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); #endif addCandidate(cand); } -// TODO: for justified text, refine with shrink/stretch -float LineBreaker::computeScore(float delta, bool atEnd) { - if (delta < 0) { - return SCORE_OVERFULL; - } else if (atEnd && mStrategy != kBreakStrategy_Balanced) { - return 0.0; - } else { - return delta * delta; - } -} - // TODO performance: could avoid populating mCandidates if greedy only void LineBreaker::addCandidate(Candidate cand) { size_t candIndex = mCandidates.size(); @@ -238,8 +174,10 @@ void LineBreaker::addCandidate(Candidate cand) { if (mBestBreak == mLastBreak) { mBestBreak = candIndex; } - pushBreak(mCandidates[mBestBreak].offset, mCandidates[mBestBreak].postBreak - mPreBreak, - mCandidates[mBestBreak].hyphenEdit); + mBreaks.push_back(mCandidates[mBestBreak].offset); + mWidths.push_back(mCandidates[mBestBreak].postBreak - mPreBreak); + mFlags.push_back(mFirstTabIndex < mBreaks.back()); + mFirstTabIndex = INT_MAX; mBestScore = SCORE_INFTY; #if VERBOSE_DEBUG ALOGD("break: %d %g", mBreaks.back(), mWidths.back()); @@ -253,15 +191,6 @@ void LineBreaker::addCandidate(Candidate cand) { } } -void LineBreaker::pushBreak(int offset, float width, uint8_t hyph) { - mBreaks.push_back(offset); - mWidths.push_back(width); - int flags = (mFirstTabIndex < mBreaks.back()) << kTab_Shift; - flags |= hyph; - mFlags.push_back(flags); - mFirstTabIndex = INT_MAX; -} - void LineBreaker::addReplacement(size_t start, size_t end, float width) { mCharWidths[start] = width; std::fill(&mCharWidths[start + 1], &mCharWidths[end], 0.0f); @@ -276,87 +205,27 @@ void LineBreaker::computeBreaksGreedy() { // All breaks but the last have been added in addCandidate already. size_t nCand = mCandidates.size(); if (nCand == 1 || mLastBreak != nCand - 1) { - pushBreak(mCandidates[nCand - 1].offset, mCandidates[nCand - 1].postBreak - mPreBreak, 0); - // don't need to update mBestScore, because we're done + mBreaks.push_back(mCandidates[nCand - 1].offset); + mWidths.push_back(mCandidates[nCand - 1].postBreak - mPreBreak); + mFlags.push_back(mFirstTabIndex < mBreaks.back()); + // don't need to update mFirstTabIndex or mBestScore, because we're done #if VERBOSE_DEBUG ALOGD("final break: %d %g", mBreaks.back(), mWidths.back()); #endif } } -// Follow "prev" links in mCandidates array, and copy to result arrays. -void LineBreaker::finishBreaksOptimal() { +void LineBreaker::computeBreaksOpt() { // clear existing greedy break result mBreaks.clear(); mWidths.clear(); mFlags.clear(); - size_t nCand = mCandidates.size(); - size_t prev; - for (size_t i = nCand - 1; i > 0; i = prev) { - prev = mCandidates[i].prev; - mBreaks.push_back(mCandidates[i].offset); - mWidths.push_back(mCandidates[i].postBreak - mCandidates[prev].preBreak); - mFlags.push_back(mCandidates[i].hyphenEdit); - } - std::reverse(mBreaks.begin(), mBreaks.end()); - std::reverse(mWidths.begin(), mWidths.end()); - std::reverse(mFlags.begin(), mFlags.end()); -} - -void LineBreaker::computeBreaksOptimal() { - size_t active = 0; - size_t nCand = mCandidates.size(); - for (size_t i = 1; i < nCand; i++) { - bool atEnd = i == nCand - 1; - float best = SCORE_INFTY; - size_t bestPrev = 0; - - size_t lineNumberLast = mCandidates[active].lineNumber; - float width = mLineWidths.getLineWidth(lineNumberLast); - ParaWidth leftEdge = mCandidates[i].postBreak - width; - float bestHope = 0; - - for (size_t j = active; j < i; j++) { - size_t lineNumber = mCandidates[j].lineNumber; - if (lineNumber != lineNumberLast) { - float widthNew = mLineWidths.getLineWidth(lineNumber); - if (widthNew != width) { - leftEdge = mCandidates[i].postBreak - width; - bestHope = 0; - width = widthNew; - } - lineNumberLast = lineNumber; - } - float jScore = mCandidates[j].score; - if (jScore + bestHope >= best) continue; - float delta = mCandidates[j].preBreak - leftEdge; - - float widthScore = computeScore(delta, atEnd); - if (delta < 0) { - active = j + 1; - } else { - bestHope = widthScore; - } - - float score = jScore + widthScore; - if (score <= best) { - best = score; - bestPrev = j; - } - } - mCandidates[i].score = best + mCandidates[i].penalty; - mCandidates[i].prev = bestPrev; - mCandidates[i].lineNumber = mCandidates[bestPrev].lineNumber + 1; - } - finishBreaksOptimal(); -} - -void LineBreaker::computeBreaksOptimalRect() { size_t active = 0; size_t nCand = mCandidates.size(); float width = mLineWidths.getLineWidth(0); + // TODO: actually support non-constant width for (size_t i = 1; i < nCand; i++) { - bool atEnd = i == nCand - 1; + bool stretchIsFree = mStrategy != kBreakStrategy_Balanced && i == nCand - 1; float best = SCORE_INFTY; size_t bestPrev = 0; @@ -366,15 +235,17 @@ void LineBreaker::computeBreaksOptimalRect() { ParaWidth leftEdge = mCandidates[i].postBreak - width; for (size_t j = active; j < i; j++) { - // TODO performance: can break if bestHope >= best; worth it? float jScore = mCandidates[j].score; if (jScore + bestHope >= best) continue; float delta = mCandidates[j].preBreak - leftEdge; - float widthScore = computeScore(delta, atEnd); + // TODO: for justified text, refine with shrink/stretch + float widthScore; if (delta < 0) { + widthScore = SCORE_OVERFULL; active = j + 1; } else { + widthScore = stretchIsFree ? 0 : delta * delta; bestHope = widthScore; } @@ -387,16 +258,23 @@ void LineBreaker::computeBreaksOptimalRect() { mCandidates[i].score = best + mCandidates[i].penalty; mCandidates[i].prev = bestPrev; } - finishBreaksOptimal(); + size_t prev; + for (size_t i = nCand - 1; i > 0; i = prev) { + prev = mCandidates[i].prev; + mBreaks.push_back(mCandidates[i].offset); + mWidths.push_back(mCandidates[i].postBreak - mCandidates[prev].preBreak); + mFlags.push_back(0); + } + std::reverse(mBreaks.begin(), mBreaks.end()); + std::reverse(mWidths.begin(), mWidths.end()); + std::reverse(mFlags.begin(), mFlags.end()); } size_t LineBreaker::computeBreaks() { if (mStrategy == kBreakStrategy_Greedy) { computeBreaksGreedy(); - } else if (mLineWidths.isConstant()) { - computeBreaksOptimalRect(); } else { - computeBreaksOptimal(); + computeBreaksOpt(); } return mBreaks.size(); } @@ -412,8 +290,6 @@ void LineBreaker::finish() { mTextBuf.shrink_to_fit(); mCharWidths.clear(); mCharWidths.shrink_to_fit(); - mHyphBuf.clear(); - mHyphBuf.shrink_to_fit(); mCandidates.shrink_to_fit(); mBreaks.shrink_to_fit(); mWidths.shrink_to_fit(); From c76f4113d73a9656c8f0565047dba843117c46fc Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 30 Mar 2015 14:20:18 -0700 Subject: [PATCH 074/364] Revert "Fix build: Revert "Add hyphenation to line breaking"" This reverts commit f8ed26a065cdb58adfa5df940bd2f0f6ae70d236. --- .../src/flutter/include/minikin/Hyphenator.h | 62 ++++++ .../src/flutter/include/minikin/LineBreaker.h | 45 ++-- engine/src/flutter/libs/minikin/Android.mk | 1 + .../src/flutter/libs/minikin/Hyphenator.cpp | 152 ++++++++++++++ .../src/flutter/libs/minikin/LineBreaker.cpp | 194 ++++++++++++++---- 5 files changed, 406 insertions(+), 48 deletions(-) create mode 100644 engine/src/flutter/include/minikin/Hyphenator.h create mode 100644 engine/src/flutter/libs/minikin/Hyphenator.cpp diff --git a/engine/src/flutter/include/minikin/Hyphenator.h b/engine/src/flutter/include/minikin/Hyphenator.h new file mode 100644 index 0000000000..581c657fbe --- /dev/null +++ b/engine/src/flutter/include/minikin/Hyphenator.h @@ -0,0 +1,62 @@ +/* + * 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. + */ + +/** + * An implementation of Liang's hyphenation algorithm. + */ + +#include +#include + +#ifndef MINIKIN_HYPHENATOR_H +#define MINIKIN_HYPHENATOR_H + +namespace android { + +class Trie { +public: + std::vector result; + std::unordered_map succ; +}; + +class Hyphenator { +public: + // Note: this will also require a locale, for proper case folding behavior + static Hyphenator* load(const uint16_t* patternData, size_t size); + + // Compute the hyphenation of a word, storing the hyphenation in result vector. Each + // entry in the vector is a "hyphen edit" to be applied at the corresponding code unit + // offset in the word. Currently 0 means no hyphen and 1 means insert hyphen and break, + // but this will be expanded to other edits for nonstandard hyphenation. + // Example: word is "hyphen", result is [0 0 1 0 0 0], corresponding to "hy-phen". + void hyphenate(std::vector* result, const uint16_t* word, size_t len); + +private: + void addPattern(const uint16_t* pattern, size_t size); + + void hyphenateSoft(std::vector* result, const uint16_t* word, size_t len); + + // TODO: these should become parameters, as they might vary by locale, screen size, and + // possibly explicit user control. + static const int MIN_PREFIX = 2; + static const int MIN_SUFFIX = 3; + + Trie root; +}; + +} // namespace android + +#endif // MINIKIN_HYPHENATOR_H \ No newline at end of file diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index 29afba0bee..92e72e249c 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -26,6 +26,7 @@ #include "unicode/locid.h" #include #include +#include "minikin/Hyphenator.h" namespace android { @@ -43,6 +44,10 @@ class LineWidths { mFirstWidthLineCount = firstWidthLineCount; mRestWidth = restWidth; } + bool isConstant() const { + // technically mFirstWidthLineCount == 0 would count too, but doesn't actually happen + return mRestWidth == mFirstWidth; + } float getLineWidth(int line) const { return (line < mFirstWidthLineCount) ? mFirstWidth : mRestWidth; } @@ -77,6 +82,8 @@ class TabStops { class LineBreaker { public: + const static int kTab_Shift = 29; // keep synchronized with TAB_MASK in StaticLayout.java + ~LineBreaker() { utext_close(&mUText); delete mBreakIterator; @@ -88,13 +95,8 @@ class LineBreaker { // locale has actually changed. // That logic could be here but it's better for performance that it's upstream because of // the cost of constructing and comparing the ICU Locale object. - void setLocale(const icu::Locale& locale) { - delete mBreakIterator; - UErrorCode status = U_ZERO_ERROR; - mBreakIterator = icu::BreakIterator::createLineInstance(locale, status); - // TODO: check status - // TODO: load hyphenator from locale - } + // Note: caller is responsible for managing lifetime of hyphenator + void setLocale(const icu::Locale& locale, Hyphenator* hyphenator); void resize(size_t size) { mTextBuf.resize(size); @@ -130,8 +132,8 @@ class LineBreaker { // Minikin to do the shaping of the strings. The main thing that would need to be changed // is having some kind of callback (or virtual class, or maybe even template), which could // easily be instantiated with Minikin's Layout. Future work for when needed. - float addStyleRun(const MinikinPaint* paint, const FontCollection* typeface, - FontStyle style, size_t start, size_t end, bool isRtl); + float addStyleRun(MinikinPaint* paint, const FontCollection* typeface, FontStyle style, + size_t start, size_t end, bool isRtl); void addReplacement(size_t start, size_t end, float width); @@ -145,7 +147,7 @@ class LineBreaker { return mWidths.data(); } - const uint8_t* getFlags() const { + const int* getFlags() const { return mFlags.data(); } @@ -166,23 +168,40 @@ class LineBreaker { ParaWidth postBreak; float penalty; // penalty of this break (for example, hyphen penalty) float score; // best score found for this break + size_t lineNumber; // only updated for non-constant line widths + uint8_t hyphenEdit; }; float currentLineWidth() const; - void addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, float penalty); + // compute shrink/stretch penalty for line + float computeScore(float delta, bool atEnd); + + void addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, float penalty, + uint8_t hyph); void addCandidate(Candidate cand); + // push an actual break to the output. Takes care of setting flags for tab + void pushBreak(int offset, float width, uint8_t hyph); + void computeBreaksGreedy(); - void computeBreaksOpt(); + void computeBreaksOptimal(); + + // special case when LineWidth is constant (layout is rectangle) + void computeBreaksOptimalRect(); + + void finishBreaksOptimal(); icu::BreakIterator* mBreakIterator = nullptr; UText mUText = UTEXT_INITIALIZER; std::vectormTextBuf; std::vectormCharWidths; + Hyphenator* mHyphenator; + std::vector mHyphBuf; + // layout parameters BreakStrategy mStrategy = kBreakStrategy_Greedy; LineWidths mLineWidths; @@ -191,7 +210,7 @@ class LineBreaker { // result of line breaking std::vector mBreaks; std::vector mWidths; - std::vector mFlags; + std::vector mFlags; ParaWidth mWidth = 0; std::vector mCandidates; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 54068243ee..34b535cabd 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -22,6 +22,7 @@ LOCAL_SRC_FILES := \ FontCollection.cpp \ FontFamily.cpp \ GraphemeBreak.cpp \ + Hyphenator.cpp \ Layout.cpp \ LineBreaker.cpp \ MinikinInternal.cpp \ diff --git a/engine/src/flutter/libs/minikin/Hyphenator.cpp b/engine/src/flutter/libs/minikin/Hyphenator.cpp new file mode 100644 index 0000000000..c50b3861af --- /dev/null +++ b/engine/src/flutter/libs/minikin/Hyphenator.cpp @@ -0,0 +1,152 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include + +// HACK: for reading pattern file +#include + +#define LOG_TAG "Minikin" +#include "utils/Log.h" + +#include "minikin/Hyphenator.h" + +using std::vector; + +namespace android { + +static const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; + +void Hyphenator::addPattern(const uint16_t* pattern, size_t size) { + vector word; + vector result; + + // start by parsing the Liang-format pattern into a word and a result vector, the + // vector right-aligned but without leading zeros. Examples: + // a1bc2d -> abcd [1, 0, 2, 0] + // abc1 -> abc [1] + // 1a2b3c4d5 -> abcd [1, 2, 3, 4, 5] + bool lastWasLetter = false; + bool haveSeenNumber = false; + for (size_t i = 0; i < size; i++) { + uint16_t c = pattern[i]; + if (isdigit(c)) { + result.push_back(c - '0'); + lastWasLetter = false; + haveSeenNumber = true; + } else { + word.push_back(c); + if (lastWasLetter && haveSeenNumber) { + result.push_back(0); + } + lastWasLetter = true; + } + } + if (lastWasLetter) { + result.push_back(0); + } + Trie* t = &root; + for (size_t i = 0; i < word.size(); i++) { + t = &t->succ[word[i]]; + } + t->result = result; +} + +// If any soft hyphen is present in the word, use soft hyphens to decide hyphenation, +// as recommended in UAX #14 (Use of Soft Hyphen) +void Hyphenator::hyphenateSoft(vector* result, const uint16_t* word, size_t len) { + (*result)[0] = 0; + for (size_t i = 1; i < len; i++) { + (*result)[i] = word[i - 1] == CHAR_SOFT_HYPHEN; + } +} + +void Hyphenator::hyphenate(vector* result, const uint16_t* word, size_t len) { + result->clear(); + result->resize(len); + if (len < MIN_PREFIX + MIN_SUFFIX) return; + size_t maxOffset = len - MIN_SUFFIX + 1; + for (size_t i = 0; i < len + 1; i++) { + const Trie* node = &root; + for (size_t j = i; j < len + 2; j++) { + uint16_t c; + if (j == 0 || j == len + 1) { + c = '.'; // word boundary character in pattern data files + } else { + c = word[j - 1]; + if (c == CHAR_SOFT_HYPHEN) { + hyphenateSoft(result, word, len); + return; + } + // TODO: use locale-sensitive case folding from ICU. + c = tolower(c); + } + auto search = node->succ.find(c); + if (search != node->succ.end()) { + node = &search->second; + } else { + break; + } + if (!node->result.empty()) { + int resultLen = node->result.size(); + int offset = j + 1 - resultLen; + int start = std::max(MIN_PREFIX - offset, 0); + int end = std::min(resultLen, (int)maxOffset - offset); + // TODO performance: this inner loop can profitably be optimized + for (int k = start; k < end; k++) { + (*result)[offset + k] = std::max((*result)[offset + k], node->result[k]); + } +#if 0 + // debug printing of matched patterns + std::string dbg; + for (size_t k = i; k <= j + 1; k++) { + int off = k - j - 2 + resultLen; + if (off >= 0 && node->result[off] != 0) { + dbg.push_back((char)('0' + node->result[off])); + } + if (k < j + 1) { + uint16_t c = (k == 0 || k == len + 1) ? '.' : word[k - 1]; + dbg.push_back((char)c); + } + } + ALOGD("%d:%d %s", i, j, dbg.c_str()); +#endif + } + } + } + // Since the above calculation does not modify values outside + // [MIN_PREFIX, len - MIN_SUFFIX], they are left as 0. + for (size_t i = MIN_PREFIX; i < maxOffset; i++) { + (*result)[i] &= 1; + } +} + +Hyphenator* Hyphenator::load(const uint16_t *patternData, size_t size) { + Hyphenator* result = new Hyphenator; + for (size_t i = 0; i < size; i++) { + size_t end = i; + while (patternData[end] != '\n') end++; + result->addPattern(patternData + i, end - i); + i = end; + } + return result; +} + +} // namespace android diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 99d7f69de5..f7f3fb3fd0 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -29,6 +29,7 @@ using std::vector; namespace android { const int CHAR_TAB = 0x0009; +const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; // Large scores in a hierarchy; we prefer desperate breaks to an overfull line. All these // constants are larger than any reasonable actual width score. @@ -40,6 +41,16 @@ const float SCORE_DESPERATE = 1e10f; // to avoid allocation. const size_t MAX_TEXT_BUF_RETAIN = 32678; +void LineBreaker::setLocale(const icu::Locale& locale, Hyphenator* hyphenator) { + delete mBreakIterator; + UErrorCode status = U_ZERO_ERROR; + mBreakIterator = icu::BreakIterator::createLineInstance(locale, status); + // TODO: check status + + // TODO: load actual resource dependent on locale; letting Minikin do it is a hack + mHyphenator = hyphenator; +} + void LineBreaker::setText() { UErrorCode status = U_ZERO_ERROR; utext_openUChars(&mUText, mTextBuf.data(), mTextBuf.size(), &status); @@ -49,7 +60,7 @@ void LineBreaker::setText() { // handle initial break here because addStyleRun may never be called mBreakIterator->next(); mCandidates.clear(); - Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0}; + Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0, 0, 0}; mCandidates.push_back(cand); // reset greedy breaker state @@ -64,7 +75,6 @@ void LineBreaker::setText() { } void LineBreaker::setLineWidths(float firstWidth, int firstWidthLineCount, float restWidth) { - ALOGD("width %f", firstWidth); mLineWidths.setWidths(firstWidth, firstWidthLineCount, restWidth); } @@ -81,22 +91,29 @@ static bool isLineEndSpace(uint16_t c) { // width buffer. // This method finds the candidate word breaks (using the ICU break iterator) and sends them // to addCandidate. -float LineBreaker::addStyleRun(const MinikinPaint* paint, const FontCollection* typeface, +float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typeface, FontStyle style, size_t start, size_t end, bool isRtl) { Layout layout; // performance TODO: move layout to self object to reduce allocation cost? float width = 0.0f; int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; + float hyphenPenalty = 0.0; if (paint != nullptr) { layout.setFontCollection(typeface); layout.doLayout(mTextBuf.data(), start, end - start, mTextBuf.size(), bidiFlags, style, *paint); layout.getAdvances(mCharWidths.data() + start); width = layout.getAdvance(); + + // a heuristic that seems to perform well + hyphenPenalty = 0.5 * paint->size * paint->scaleX * mLineWidths.getLineWidth(0); } - ParaWidth postBreak = mWidth; size_t current = (size_t)mBreakIterator->current(); + size_t wordEnd = start; + size_t lastBreak = start; + ParaWidth lastBreakWidth = mWidth; + ParaWidth postBreak = mWidth; for (size_t i = start; i < end; i++) { uint16_t c = mTextBuf[i]; if (c == CHAR_TAB) { @@ -110,14 +127,48 @@ float LineBreaker::addStyleRun(const MinikinPaint* paint, const FontCollection* mWidth += mCharWidths[i]; if (!isLineEndSpace(c)) { postBreak = mWidth; + wordEnd = i + 1; } } if (i + 1 == current) { - // TODO: hyphenation goes here + // Override ICU's treatment of soft hyphen as a break opportunity, because we want it + // to be a hyphen break, with penalty and drawing behavior. + if (c != CHAR_SOFT_HYPHEN) { + if (paint != nullptr && mHyphenator != nullptr && wordEnd > lastBreak) { + mHyphenator->hyphenate(&mHyphBuf, &mTextBuf[lastBreak], wordEnd - lastBreak); + #if VERBOSE_DEBUG + std::string hyphenatedString; + for (size_t j = lastBreak; j < wordEnd; j++) { + if (mHyphBuf[j - lastBreak]) hyphenatedString.push_back('-'); + // Note: only works with ASCII, should do UTF-8 conversion here + hyphenatedString.push_back(buffer()[j]); + } + ALOGD("hyphenated string: %s", hyphenatedString.c_str()); + #endif - // Skip break for zero-width characters. - if (current == mTextBuf.size() || mCharWidths[current] > 0) { - addWordBreak(current, mWidth, postBreak, 0); + // measure hyphenated substrings + for (size_t j = lastBreak; j < wordEnd; j++) { + uint8_t hyph = mHyphBuf[j - lastBreak]; + if (hyph) { + paint->hyphenEdit = hyph; + layout.doLayout(mTextBuf.data(), lastBreak, j - lastBreak, + mTextBuf.size(), bidiFlags, style, *paint); + ParaWidth hyphPostBreak = lastBreakWidth + layout.getAdvance(); + paint->hyphenEdit = 0; + layout.doLayout(mTextBuf.data(), j, wordEnd - j, + mTextBuf.size(), bidiFlags, style, *paint); + ParaWidth hyphPreBreak = postBreak - layout.getAdvance(); + addWordBreak(j, hyphPreBreak, hyphPostBreak, hyphenPenalty, hyph); + } + } + } + + // Skip break for zero-width characters. + if (current == mTextBuf.size() || mCharWidths[current] > 0) { + addWordBreak(current, mWidth, postBreak, 0.0, 0); + } + lastBreak = current; + lastBreakWidth = mWidth; } current = (size_t)mBreakIterator->next(); } @@ -129,7 +180,7 @@ float LineBreaker::addStyleRun(const MinikinPaint* paint, const FontCollection* // add a word break (possibly for a hyphenated fragment), and add desperate breaks if // needed (ie when word exceeds current line width) void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, - float penalty) { + float penalty, uint8_t hyph) { Candidate cand; ParaWidth width = mCandidates.back().preBreak; if (postBreak - width > currentLineWidth()) { @@ -145,6 +196,7 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.preBreak = width; cand.postBreak = width; cand.penalty = SCORE_DESPERATE; + cand.hyphenEdit = 0; #if VERBOSE_DEBUG ALOGD("desperate cand: %d %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); @@ -159,12 +211,24 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.preBreak = preBreak; cand.postBreak = postBreak; cand.penalty = penalty; + cand.hyphenEdit = hyph; #if VERBOSE_DEBUG ALOGD("cand: %d %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); #endif addCandidate(cand); } +// TODO: for justified text, refine with shrink/stretch +float LineBreaker::computeScore(float delta, bool atEnd) { + if (delta < 0) { + return SCORE_OVERFULL; + } else if (atEnd && mStrategy != kBreakStrategy_Balanced) { + return 0.0; + } else { + return delta * delta; + } +} + // TODO performance: could avoid populating mCandidates if greedy only void LineBreaker::addCandidate(Candidate cand) { size_t candIndex = mCandidates.size(); @@ -174,10 +238,8 @@ void LineBreaker::addCandidate(Candidate cand) { if (mBestBreak == mLastBreak) { mBestBreak = candIndex; } - mBreaks.push_back(mCandidates[mBestBreak].offset); - mWidths.push_back(mCandidates[mBestBreak].postBreak - mPreBreak); - mFlags.push_back(mFirstTabIndex < mBreaks.back()); - mFirstTabIndex = INT_MAX; + pushBreak(mCandidates[mBestBreak].offset, mCandidates[mBestBreak].postBreak - mPreBreak, + mCandidates[mBestBreak].hyphenEdit); mBestScore = SCORE_INFTY; #if VERBOSE_DEBUG ALOGD("break: %d %g", mBreaks.back(), mWidths.back()); @@ -191,6 +253,15 @@ void LineBreaker::addCandidate(Candidate cand) { } } +void LineBreaker::pushBreak(int offset, float width, uint8_t hyph) { + mBreaks.push_back(offset); + mWidths.push_back(width); + int flags = (mFirstTabIndex < mBreaks.back()) << kTab_Shift; + flags |= hyph; + mFlags.push_back(flags); + mFirstTabIndex = INT_MAX; +} + void LineBreaker::addReplacement(size_t start, size_t end, float width) { mCharWidths[start] = width; std::fill(&mCharWidths[start + 1], &mCharWidths[end], 0.0f); @@ -205,27 +276,87 @@ void LineBreaker::computeBreaksGreedy() { // All breaks but the last have been added in addCandidate already. size_t nCand = mCandidates.size(); if (nCand == 1 || mLastBreak != nCand - 1) { - mBreaks.push_back(mCandidates[nCand - 1].offset); - mWidths.push_back(mCandidates[nCand - 1].postBreak - mPreBreak); - mFlags.push_back(mFirstTabIndex < mBreaks.back()); - // don't need to update mFirstTabIndex or mBestScore, because we're done + pushBreak(mCandidates[nCand - 1].offset, mCandidates[nCand - 1].postBreak - mPreBreak, 0); + // don't need to update mBestScore, because we're done #if VERBOSE_DEBUG ALOGD("final break: %d %g", mBreaks.back(), mWidths.back()); #endif } } -void LineBreaker::computeBreaksOpt() { +// Follow "prev" links in mCandidates array, and copy to result arrays. +void LineBreaker::finishBreaksOptimal() { // clear existing greedy break result mBreaks.clear(); mWidths.clear(); mFlags.clear(); + size_t nCand = mCandidates.size(); + size_t prev; + for (size_t i = nCand - 1; i > 0; i = prev) { + prev = mCandidates[i].prev; + mBreaks.push_back(mCandidates[i].offset); + mWidths.push_back(mCandidates[i].postBreak - mCandidates[prev].preBreak); + mFlags.push_back(mCandidates[i].hyphenEdit); + } + std::reverse(mBreaks.begin(), mBreaks.end()); + std::reverse(mWidths.begin(), mWidths.end()); + std::reverse(mFlags.begin(), mFlags.end()); +} + +void LineBreaker::computeBreaksOptimal() { + size_t active = 0; + size_t nCand = mCandidates.size(); + for (size_t i = 1; i < nCand; i++) { + bool atEnd = i == nCand - 1; + float best = SCORE_INFTY; + size_t bestPrev = 0; + + size_t lineNumberLast = mCandidates[active].lineNumber; + float width = mLineWidths.getLineWidth(lineNumberLast); + ParaWidth leftEdge = mCandidates[i].postBreak - width; + float bestHope = 0; + + for (size_t j = active; j < i; j++) { + size_t lineNumber = mCandidates[j].lineNumber; + if (lineNumber != lineNumberLast) { + float widthNew = mLineWidths.getLineWidth(lineNumber); + if (widthNew != width) { + leftEdge = mCandidates[i].postBreak - width; + bestHope = 0; + width = widthNew; + } + lineNumberLast = lineNumber; + } + float jScore = mCandidates[j].score; + if (jScore + bestHope >= best) continue; + float delta = mCandidates[j].preBreak - leftEdge; + + float widthScore = computeScore(delta, atEnd); + if (delta < 0) { + active = j + 1; + } else { + bestHope = widthScore; + } + + float score = jScore + widthScore; + if (score <= best) { + best = score; + bestPrev = j; + } + } + mCandidates[i].score = best + mCandidates[i].penalty; + mCandidates[i].prev = bestPrev; + mCandidates[i].lineNumber = mCandidates[bestPrev].lineNumber + 1; + } + finishBreaksOptimal(); +} + +void LineBreaker::computeBreaksOptimalRect() { size_t active = 0; size_t nCand = mCandidates.size(); float width = mLineWidths.getLineWidth(0); - // TODO: actually support non-constant width for (size_t i = 1; i < nCand; i++) { - bool stretchIsFree = mStrategy != kBreakStrategy_Balanced && i == nCand - 1; + bool atEnd = i == nCand - 1; float best = SCORE_INFTY; size_t bestPrev = 0; @@ -235,17 +366,15 @@ void LineBreaker::computeBreaksOpt() { ParaWidth leftEdge = mCandidates[i].postBreak - width; for (size_t j = active; j < i; j++) { + // TODO performance: can break if bestHope >= best; worth it? float jScore = mCandidates[j].score; if (jScore + bestHope >= best) continue; float delta = mCandidates[j].preBreak - leftEdge; - // TODO: for justified text, refine with shrink/stretch - float widthScore; + float widthScore = computeScore(delta, atEnd); if (delta < 0) { - widthScore = SCORE_OVERFULL; active = j + 1; } else { - widthScore = stretchIsFree ? 0 : delta * delta; bestHope = widthScore; } @@ -258,23 +387,16 @@ void LineBreaker::computeBreaksOpt() { mCandidates[i].score = best + mCandidates[i].penalty; mCandidates[i].prev = bestPrev; } - size_t prev; - for (size_t i = nCand - 1; i > 0; i = prev) { - prev = mCandidates[i].prev; - mBreaks.push_back(mCandidates[i].offset); - mWidths.push_back(mCandidates[i].postBreak - mCandidates[prev].preBreak); - mFlags.push_back(0); - } - std::reverse(mBreaks.begin(), mBreaks.end()); - std::reverse(mWidths.begin(), mWidths.end()); - std::reverse(mFlags.begin(), mFlags.end()); + finishBreaksOptimal(); } size_t LineBreaker::computeBreaks() { if (mStrategy == kBreakStrategy_Greedy) { computeBreaksGreedy(); + } else if (mLineWidths.isConstant()) { + computeBreaksOptimalRect(); } else { - computeBreaksOpt(); + computeBreaksOptimal(); } return mBreaks.size(); } @@ -290,6 +412,8 @@ void LineBreaker::finish() { mTextBuf.shrink_to_fit(); mCharWidths.clear(); mCharWidths.shrink_to_fit(); + mHyphBuf.clear(); + mHyphBuf.shrink_to_fit(); mCandidates.shrink_to_fit(); mBreaks.shrink_to_fit(); mWidths.shrink_to_fit(); From 201d89470128e5b3fbb913cfca2c0b11b7713a88 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Tue, 14 Apr 2015 18:29:39 -0700 Subject: [PATCH 075/364] Add margins array to line widths object In order to support layout in non-rectangular regions, the LineWidths object needs to accept an arbitrary array of margins. This is implemented in addition to the existing firstWidthLineCount/restWidth mechanism for convenience, though using only arrays would have the same expressive power. Bug: 20182243 Change-Id: Iea96bca1a92012314ac27e617c67f306c1f1b2f2 --- .../src/flutter/include/minikin/LineBreaker.h | 18 ++++++++++++++++-- .../src/flutter/libs/minikin/LineBreaker.cpp | 5 +++++ 2 files changed, 21 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index 92e72e249c..eb501e7cc8 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -44,17 +44,29 @@ class LineWidths { mFirstWidthLineCount = firstWidthLineCount; mRestWidth = restWidth; } + void setMargins(const std::vector& margins) { + mMargins = margins; + } bool isConstant() const { // technically mFirstWidthLineCount == 0 would count too, but doesn't actually happen - return mRestWidth == mFirstWidth; + return mRestWidth == mFirstWidth && mMargins.empty(); } float getLineWidth(int line) const { - return (line < mFirstWidthLineCount) ? mFirstWidth : mRestWidth; + float width = (line < mFirstWidthLineCount) ? mFirstWidth : mRestWidth; + if (!mMargins.empty()) { + if ((size_t)line < mMargins.size()) { + width -= mMargins[line]; + } else { + width -= mMargins.back(); + } + } + return width; } private: float mFirstWidth; int mFirstWidthLineCount; float mRestWidth; + std::vector mMargins; }; class TabStops { @@ -120,6 +132,8 @@ class LineBreaker { void setLineWidths(float firstWidth, int firstWidthLineCount, float restWidth); + void setMargins(const std::vector& margins); + void setTabStops(const int* stops, size_t nStops, int tabWidth) { mTabStops.set(stops, nStops, tabWidth); } diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index f7f3fb3fd0..9298f77848 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -78,6 +78,11 @@ void LineBreaker::setLineWidths(float firstWidth, int firstWidthLineCount, float mLineWidths.setWidths(firstWidth, firstWidthLineCount, restWidth); } + +void LineBreaker::setMargins(const std::vector& margins) { + mLineWidths.setMargins(margins); +} + // This function determines whether a character is a space that disappears at end of line. // It is the Unicode set: [[:General_Category=Space_Separator:]-[:Line_Break=Glue:]] // Note: all such characters are in the BMP, so it's ok to use code units for this. From 6705d6ff2ad1aa43fae0b665aaca2482ae079763 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 15 Apr 2015 15:22:42 -0700 Subject: [PATCH 076/364] Rename "margins" to "indents" The name "margin" conflicts with another meaning, so we're making the name in the public api "idents" and the code consistent in naming. Change-Id: I9170116b4d972e4b25f0f319e78376310288eb41 --- .../src/flutter/include/minikin/LineBreaker.h | 18 +++++++++--------- .../src/flutter/libs/minikin/LineBreaker.cpp | 4 ++-- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index eb501e7cc8..ebe5dc4432 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -44,20 +44,20 @@ class LineWidths { mFirstWidthLineCount = firstWidthLineCount; mRestWidth = restWidth; } - void setMargins(const std::vector& margins) { - mMargins = margins; + void setIndents(const std::vector& indents) { + mIndents = indents; } bool isConstant() const { // technically mFirstWidthLineCount == 0 would count too, but doesn't actually happen - return mRestWidth == mFirstWidth && mMargins.empty(); + return mRestWidth == mFirstWidth && mIndents.empty(); } float getLineWidth(int line) const { float width = (line < mFirstWidthLineCount) ? mFirstWidth : mRestWidth; - if (!mMargins.empty()) { - if ((size_t)line < mMargins.size()) { - width -= mMargins[line]; + if (!mIndents.empty()) { + if ((size_t)line < mIndents.size()) { + width -= mIndents[line]; } else { - width -= mMargins.back(); + width -= mIndents.back(); } } return width; @@ -66,7 +66,7 @@ class LineWidths { float mFirstWidth; int mFirstWidthLineCount; float mRestWidth; - std::vector mMargins; + std::vector mIndents; }; class TabStops { @@ -132,7 +132,7 @@ class LineBreaker { void setLineWidths(float firstWidth, int firstWidthLineCount, float restWidth); - void setMargins(const std::vector& margins); + void setIndents(const std::vector& indents); void setTabStops(const int* stops, size_t nStops, int tabWidth) { mTabStops.set(stops, nStops, tabWidth); diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 9298f77848..f4201cb26b 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -79,8 +79,8 @@ void LineBreaker::setLineWidths(float firstWidth, int firstWidthLineCount, float } -void LineBreaker::setMargins(const std::vector& margins) { - mLineWidths.setMargins(margins); +void LineBreaker::setIndents(const std::vector& indents) { + mLineWidths.setIndents(indents); } // This function determines whether a character is a space that disappears at end of line. From 05e89cffd41e8d1562a1d51422958a08726f7dd8 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 6 Apr 2015 16:21:10 -0700 Subject: [PATCH 077/364] Add functions for measuring cursor positioning New functions for computing the correspondence between cursor position and advance, respecting grapheme boundaries. Change-Id: I620378d5f64cd74300cd43db522adeb555825dff --- engine/src/flutter/include/minikin/Layout.h | 6 +- .../src/flutter/include/minikin/Measurement.h | 31 +++++ engine/src/flutter/libs/minikin/Android.mk | 1 + .../flutter/libs/minikin/GraphemeBreak.cpp | 8 +- .../src/flutter/libs/minikin/Measurement.cpp | 116 ++++++++++++++++++ 5 files changed, 157 insertions(+), 5 deletions(-) create mode 100644 engine/src/flutter/include/minikin/Measurement.h create mode 100644 engine/src/flutter/libs/minikin/Measurement.cpp diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 543f553ce1..930407a52b 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -106,9 +106,13 @@ public: float getAdvance() const; // Get advances, copying into caller-provided buffer. The size of this - // buffer must match the length of the string (nchars arg to doLayout). + // buffer must match the length of the string (count arg to doLayout). void getAdvances(float* advances); + // The i parameter is an offset within the buf relative to start, it is < count, where + // start and count are the parameters to doLayout + float getCharAdvance(size_t i) const { return mAdvances[i]; } + void getBounds(MinikinRect* rect); // Purge all caches, useful in low memory conditions diff --git a/engine/src/flutter/include/minikin/Measurement.h b/engine/src/flutter/include/minikin/Measurement.h new file mode 100644 index 0000000000..fc47fa3162 --- /dev/null +++ b/engine/src/flutter/include/minikin/Measurement.h @@ -0,0 +1,31 @@ +/* + * 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. + */ + +#ifndef MINIKIN_MEASUREMENT_H +#define MINIKIN_MEASUREMENT_H + +#include + +namespace android { + +float getRunAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t count, size_t offset); + +size_t getOffsetForAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t count, + float advance); + +} + +#endif // MINIKIN_MEASUREMENT_H diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 34b535cabd..873f279f0c 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -25,6 +25,7 @@ LOCAL_SRC_FILES := \ Hyphenator.cpp \ Layout.cpp \ LineBreaker.cpp \ + Measurement.cpp \ MinikinInternal.cpp \ MinikinRefCounted.cpp \ MinikinFontFreeType.cpp \ diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index 5d8978d66f..f8f386c0de 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -41,7 +41,7 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co uint32_t c2 = 0; size_t offset_back = offset; U16_PREV(buf, start, offset_back, c1); - U16_NEXT(buf, offset, count, c2); + U16_NEXT(buf, offset, start + count, c2); int32_t p1 = u_getIntPropertyValue(c1, UCHAR_GRAPHEME_CLUSTER_BREAK); int32_t p2 = u_getIntPropertyValue(c2, UCHAR_GRAPHEME_CLUSTER_BREAK); // Rule GB3, CR x LF @@ -54,7 +54,7 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co } // Rule GB5, / (Control | CR | LF) if (p2 == U_GCB_CONTROL || p2 == U_GCB_CR || p2 == U_GCB_LF) { - // exclude zero-width control characters from breaking (tailoring of TR29) + // exclude zero-width control characters from breaking (tailoring of UAX #29) if (c2 == 0x00ad || (c2 >= 0x200b && c2 <= 0x200f) || (c2 >= 0x2028 && c2 <= 0x202e) @@ -83,12 +83,12 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co if (p2 == U_GCB_EXTEND || p2 == U_GCB_SPACING_MARK) { if (c2 == 0xe33) { // most other implementations break THAI CHARACTER SARA AM - // (tailoring of TR29) + // (tailoring of UAX #29) return true; } return false; } - // Cluster indic syllables togeter (tailoring of TR29) + // Cluster indic syllables together (tailoring of UAX #29) if (u_getIntPropertyValue(c1, UCHAR_CANONICAL_COMBINING_CLASS) == 9 // virama && u_getIntPropertyValue(c2, UCHAR_GENERAL_CATEGORY) == U_OTHER_LETTER) { return false; diff --git a/engine/src/flutter/libs/minikin/Measurement.cpp b/engine/src/flutter/libs/minikin/Measurement.cpp new file mode 100644 index 0000000000..21df5d8234 --- /dev/null +++ b/engine/src/flutter/libs/minikin/Measurement.cpp @@ -0,0 +1,116 @@ +/* + * 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. + */ + +#define LOG_TAG "Minikin" +#include + +#include +#include + +#include +#include + +namespace android { + +// These could be considered helper methods of layout, but need only be loosely coupled, so +// are separate. + +float getRunAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t count, + size_t offset) { + float advance = 0.0f; + size_t lastCluster = start; + float clusterWidth = 0.0f; + for (size_t i = start; i < offset; i++) { + float charAdvance = layout.getCharAdvance(i - start); + if (charAdvance != 0.0f) { + advance += charAdvance; + lastCluster = i; + clusterWidth = charAdvance; + } + } + if (offset < start + count && layout.getCharAdvance(offset) == 0.0f) { + // In the middle of a cluster, distribute width of cluster so that each grapheme cluster + // gets an equal share. + // TODO: get caret information out of font when that's available + size_t nextCluster; + for (nextCluster = offset + 1; nextCluster < start + count; nextCluster++) { + if (layout.getCharAdvance(nextCluster - start) != 0.0f) break; + } + int numGraphemeClusters = 0; + int numGraphemeClustersAfter = 0; + for (size_t i = lastCluster; i < nextCluster; i++) { + bool isAfter = i >= offset; + if (GraphemeBreak::isGraphemeBreak(buf, start, count, i)) { + numGraphemeClusters++; + if (isAfter) { + numGraphemeClustersAfter++; + } + } + } + if (numGraphemeClusters > 0) { + advance -= clusterWidth * numGraphemeClustersAfter / numGraphemeClusters; + } + } + return advance; +} + +/** + * Essentially the inverse of getRunAdvance. Compute the value of offset for which the + * measured caret comes closest to the provided advance param, and which is on a grapheme + * cluster boundary. + * + * The actual implementation fast-forwards through clusters to get "close", then does a finer-grain + * search within the cluster and grapheme breaks. + */ +size_t getOffsetForAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t count, + float advance) { + float x = 0.0f, xLastClusterStart = 0.0f, xSearchStart = 0.0f; + size_t lastClusterStart = start, searchStart = start; + for (size_t i = start; i < start + count; i++) { + if (GraphemeBreak::isGraphemeBreak(buf, start, count, i)) { + searchStart = lastClusterStart; + xSearchStart = xLastClusterStart; + } + float width = layout.getCharAdvance(i - start); + if (width != 0.0f) { + lastClusterStart = i; + xLastClusterStart = x; + x += width; + if (x > advance) { + break; + } + } + } + size_t best = searchStart; + float bestDist = FLT_MAX; + for (size_t i = searchStart; i <= start + count; i++) { + if (GraphemeBreak::isGraphemeBreak(buf, start, count, i)) { + // "getRunAdvance(layout, buf, start, count, bufSize, i) - advance" but more efficient + float delta = getRunAdvance(layout, buf, searchStart, count, i) + xSearchStart + - advance; + if (std::abs(delta) < bestDist) { + bestDist = std::abs(delta); + best = i; + } + if (delta >= 0.0f) { + break; + } + } + } + return best; +} + +} From d24df3eb94bf54e19d3e57163c180dfee01a0ba7 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 22 Apr 2015 15:31:29 -0700 Subject: [PATCH 078/364] Don't include trailing newline in width for line breaking In a paragraph with a trailing newline, the width of the newline character was included in the line width for breaking purposes, basically as if it were a non-breaking space. This caused a discrepancy, where Layout.getDesiredWidth() suggested that the text would fit in a single line, but StaticLayout would break it because of the added width of the newline character. The proposed fix is simply to consider newline to be a space that disappears at the end of a line. Bug: 20152308 Change-Id: I539574c5b8ea892c8ed6aca6c59e90ccdf74a680 --- engine/src/flutter/libs/minikin/LineBreaker.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index f4201cb26b..88190fff6f 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -84,11 +84,12 @@ void LineBreaker::setIndents(const std::vector& indents) { } // This function determines whether a character is a space that disappears at end of line. -// It is the Unicode set: [[:General_Category=Space_Separator:]-[:Line_Break=Glue:]] +// It is the Unicode set: [[:General_Category=Space_Separator:]-[:Line_Break=Glue:]], +// plus '\n'. // Note: all such characters are in the BMP, so it's ok to use code units for this. static bool isLineEndSpace(uint16_t c) { - return c == ' ' || c == 0x1680 || (0x2000 <= c && c <= 0x200A && c != 0x2007) || c == 0x205F || - c == 0x3000; + return c == '\n' || c == ' ' || c == 0x1680 || (0x2000 <= c && c <= 0x200A && c != 0x2007) || + c == 0x205F || c == 0x3000; } // Ordinarily, this method measures the text in the range given. However, when paint From 1be122da962f68ce6cfb0a10fd292f14b9afd1b4 Mon Sep 17 00:00:00 2001 From: John Reck Date: Thu, 16 Apr 2015 15:27:12 -0700 Subject: [PATCH 079/364] Move Bitmap to a different namespace namespace naming collision. Move minikin's Bitmap out of android:: and into minikin:: Change-Id: I5ae3925f81b848dc79576429ab55243b96f7fed2 --- engine/src/flutter/include/minikin/Layout.h | 10 ++- engine/src/flutter/libs/minikin/Layout.cpp | 82 +++++++++++---------- engine/src/flutter/sample/example.cpp | 8 +- 3 files changed, 53 insertions(+), 47 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 930407a52b..cdf4aac523 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -24,7 +24,7 @@ #include #include -namespace android { +namespace minikin { // The Bitmap class is for debugging. We'll probably move it out // of here into a separate lightweight software rendering module @@ -34,13 +34,17 @@ public: Bitmap(int width, int height); ~Bitmap(); void writePnm(std::ofstream& o) const; - void drawGlyph(const GlyphBitmap& bitmap, int x, int y); + void drawGlyph(const android::GlyphBitmap& bitmap, int x, int y); private: int width; int height; uint8_t* buf; }; +} // namespace minikin + +namespace android { + struct LayoutGlyph { // index into mFaces and mHbFonts vectors. We could imagine // moving this into a run length representation, because it's @@ -89,7 +93,7 @@ public: void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint); - void draw(Bitmap*, int x0, int y0, float size) const; + void draw(minikin::Bitmap*, int x0, int y0, float size) const; // Deprecated. Nont needed. Remove when callers are removed. static void init(); diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 28dac7f644..88baeac6f5 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -41,6 +41,48 @@ using std::string; using std::vector; +namespace minikin { + +Bitmap::Bitmap(int width, int height) : width(width), height(height) { + buf = new uint8_t[width * height](); +} + +Bitmap::~Bitmap() { + delete[] buf; +} + +void Bitmap::writePnm(std::ofstream &o) const { + o << "P5" << std::endl; + o << width << " " << height << std::endl; + o << "255" << std::endl; + o.write((const char *)buf, width * height); + o.close(); +} + +void Bitmap::drawGlyph(const android::GlyphBitmap& bitmap, int x, int y) { + int bmw = bitmap.width; + int bmh = bitmap.height; + x += bitmap.left; + y -= bitmap.top; + int x0 = std::max(0, x); + int x1 = std::min(width, x + bmw); + int y0 = std::max(0, y); + int y1 = std::min(height, y + bmh); + const unsigned char* src = bitmap.buffer + (y0 - y) * bmw + (x0 - x); + uint8_t* dst = buf + y0 * width; + for (int yy = y0; yy < y1; yy++) { + for (int xx = x0; xx < x1; xx++) { + int pixel = (int)dst[xx] + (int)src[xx - x]; + pixel = pixel > 0xff ? 0xff : pixel; + dst[xx] = pixel; + } + src += bmw; + dst += width; + } +} + +} // namespace minikin + namespace android { const int kDirection_Mask = 0x1; @@ -218,44 +260,6 @@ hash_t hash_type(const LayoutCacheKey& key) { return key.hash(); } -Bitmap::Bitmap(int width, int height) : width(width), height(height) { - buf = new uint8_t[width * height](); -} - -Bitmap::~Bitmap() { - delete[] buf; -} - -void Bitmap::writePnm(std::ofstream &o) const { - o << "P5" << std::endl; - o << width << " " << height << std::endl; - o << "255" << std::endl; - o.write((const char *)buf, width * height); - o.close(); -} - -void Bitmap::drawGlyph(const GlyphBitmap& bitmap, int x, int y) { - int bmw = bitmap.width; - int bmh = bitmap.height; - x += bitmap.left; - y -= bitmap.top; - int x0 = std::max(0, x); - int x1 = std::min(width, x + bmw); - int y0 = std::max(0, y); - int y1 = std::min(height, y + bmh); - const unsigned char* src = bitmap.buffer + (y0 - y) * bmw + (x0 - x); - uint8_t* dst = buf + y0 * width; - for (int yy = y0; yy < y1; yy++) { - for (int xx = x0; xx < x1; xx++) { - int pixel = (int)dst[xx] + (int)src[xx - x]; - pixel = pixel > 0xff ? 0xff : pixel; - dst[xx] = pixel; - } - src += bmw; - dst += width; - } -} - void MinikinRect::join(const MinikinRect& r) { if (isEmpty()) { set(r); @@ -814,7 +818,7 @@ void Layout::appendLayout(Layout* src, size_t start) { } } -void Layout::draw(Bitmap* surface, int x0, int y0, float size) const { +void Layout::draw(minikin::Bitmap* surface, int x0, int y0, float size) const { /* TODO: redo as MinikinPaint settings if (mProps.hasTag(minikinHinting)) { diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index 487357a47b..3fbfa7910e 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -28,8 +28,8 @@ #include using std::vector; - -namespace android { +using namespace android; +using namespace minikin; FT_Library library; // TODO: this should not be a global @@ -99,8 +99,6 @@ int runMinikinTest() { return 0; } -} - int main(int argc, const char** argv) { - return android::runMinikinTest(); + return runMinikinTest(); } From e92a3c62b5b6ae85516cca5a49920e225dd53d93 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Tue, 12 May 2015 14:35:24 -0700 Subject: [PATCH 080/364] Support hyphenation frequency in Minikin. Three hyphenation frequencies are now supported: kHyphenationFrequency_None, which turns off both automatic hyphenation and soft hyphens. kHyphenationFrequency_Normal, which has aconservative amount of hyphenation useful as a conservative default. kHyphenationFrequency_Full, which has a typographic-quality amount of hyphenation useful for running text and tight screens. Bug: 21038249 Change-Id: I2800f718c887c9389a1a059d7ec07d7fa2ca1dee --- engine/src/flutter/include/minikin/LineBreaker.h | 13 +++++++++++++ engine/src/flutter/libs/minikin/LineBreaker.cpp | 8 +++++++- 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index ebe5dc4432..36314fb511 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -36,6 +36,12 @@ enum BreakStrategy { kBreakStrategy_Balanced = 2 }; +enum HyphenationFrequency { + kHyphenationFrequency_None = 0, + kHyphenationFrequency_Normal = 1, + kHyphenationFrequency_Full = 2 +}; + // TODO: want to generalize to be able to handle array of line widths class LineWidths { public: @@ -142,6 +148,12 @@ class LineBreaker { void setStrategy(BreakStrategy strategy) { mStrategy = strategy; } + HyphenationFrequency getHyphenationFrequency() const { return mHyphenationFrequency; } + + void setHyphenationFrequency(HyphenationFrequency frequency) { + mHyphenationFrequency = frequency; + } + // TODO: this class is actually fairly close to being general and not tied to using // Minikin to do the shaping of the strings. The main thing that would need to be changed // is having some kind of callback (or virtual class, or maybe even template), which could @@ -218,6 +230,7 @@ class LineBreaker { // layout parameters BreakStrategy mStrategy = kBreakStrategy_Greedy; + HyphenationFrequency mHyphenationFrequency = kHyphenationFrequency_Normal; LineWidths mLineWidths; TabStops mTabStops; diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 88190fff6f..5eb077c5aa 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -113,6 +113,9 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa // a heuristic that seems to perform well hyphenPenalty = 0.5 * paint->size * paint->scaleX * mLineWidths.getLineWidth(0); + if (mHyphenationFrequency == kHyphenationFrequency_Normal) { + hyphenPenalty *= 4.0; // TODO: Replace with a better value after some testing + } } size_t current = (size_t)mBreakIterator->current(); @@ -140,7 +143,9 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa // Override ICU's treatment of soft hyphen as a break opportunity, because we want it // to be a hyphen break, with penalty and drawing behavior. if (c != CHAR_SOFT_HYPHEN) { - if (paint != nullptr && mHyphenator != nullptr && wordEnd > lastBreak) { + if (paint != nullptr && mHyphenator != nullptr && + mHyphenationFrequency != kHyphenationFrequency_None && + wordEnd > lastBreak) { mHyphenator->hyphenate(&mHyphBuf, &mTextBuf[lastBreak], wordEnd - lastBreak); #if VERBOSE_DEBUG std::string hyphenatedString; @@ -426,6 +431,7 @@ void LineBreaker::finish() { mFlags.shrink_to_fit(); } mStrategy = kBreakStrategy_Greedy; + mHyphenationFrequency = kHyphenationFrequency_Normal; } } // namespace android From e6fff385b6b966b15dc4901a2737ffc521985b9b Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 1 Jun 2015 11:22:07 -0700 Subject: [PATCH 081/364] Disable hyphenation for unreasonably long words Very long words cause O(n^2) behavior. These are unlikely to happen in real text, but do happen with synthetic strings, so in those cases we just disable hyphenation. Bug: 20790394 Change-Id: Idf957dd40b24efe1476f619f17093a48b5bc56f7 --- engine/src/flutter/libs/minikin/LineBreaker.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 5eb077c5aa..dbd6ea8206 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -37,6 +37,12 @@ const float SCORE_INFTY = std::numeric_limits::max(); const float SCORE_OVERFULL = 1e12f; const float SCORE_DESPERATE = 1e10f; +// Very long words trigger O(n^2) behavior in hyphenation, so we disable hyphenation for +// unreasonably long words. This is somewhat of a heuristic because extremely long words +// are possible in some languages. This does mean that very long real words can get +// broken by desperate breaks, with no hyphens. +const size_t LONGEST_HYPHENATED_WORD = 45; + // When the text buffer is within this limit, capacity of vectors is retained at finish(), // to avoid allocation. const size_t MAX_TEXT_BUF_RETAIN = 32678; @@ -145,7 +151,7 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa if (c != CHAR_SOFT_HYPHEN) { if (paint != nullptr && mHyphenator != nullptr && mHyphenationFrequency != kHyphenationFrequency_None && - wordEnd > lastBreak) { + wordEnd > lastBreak && wordEnd - lastBreak <= LONGEST_HYPHENATED_WORD) { mHyphenator->hyphenate(&mHyphBuf, &mTextBuf[lastBreak], wordEnd - lastBreak); #if VERBOSE_DEBUG std::string hyphenatedString; From b77d0bd01bfe7796be599667b38fa6dfd074d59a Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 1 Jun 2015 14:27:00 -0700 Subject: [PATCH 082/364] Use context start correctly in getRunAdvance We were not taking context start into account when deciding whether to split a ligature, which was causing inconsistent behavior. This patch consistently references the widths array relative to the start of the context. Bug: 21549197 Change-Id: I7c71e10c1af84354fefe782fc0b87120016e6555 --- engine/src/flutter/libs/minikin/Measurement.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/Measurement.cpp b/engine/src/flutter/libs/minikin/Measurement.cpp index 21df5d8234..98d2c01a39 100644 --- a/engine/src/flutter/libs/minikin/Measurement.cpp +++ b/engine/src/flutter/libs/minikin/Measurement.cpp @@ -41,7 +41,7 @@ float getRunAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t co clusterWidth = charAdvance; } } - if (offset < start + count && layout.getCharAdvance(offset) == 0.0f) { + if (offset < start + count && layout.getCharAdvance(offset - start) == 0.0f) { // In the middle of a cluster, distribute width of cluster so that each grapheme cluster // gets an equal share. // TODO: get caret information out of font when that's available From 19c69aef98ca76bd56917818ec013f1f7510f54e Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 8 Jun 2015 13:41:44 -0700 Subject: [PATCH 083/364] Increase hyphenation penalty for short last line Tuning for hyphenation parameters. We discourage hyphenation on the last line, but offset this penalty by also applying a penalty for each line, which optimizes for minimizing the number of lines. Thus, when hyphenation can reduce the number of lines, it increases the chance they're used. There's probably more tuning and refinement that can be done, but testing suggests that the tunable parameters are appropriate. Bug: 20883322 Change-Id: Ida7eaf8aced109e426694f5a386924a842d29c4b --- .../src/flutter/include/minikin/LineBreaker.h | 9 +- .../src/flutter/libs/minikin/LineBreaker.cpp | 112 +++++++----------- 2 files changed, 45 insertions(+), 76 deletions(-) diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index 36314fb511..e031fb3182 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -200,9 +200,6 @@ class LineBreaker { float currentLineWidth() const; - // compute shrink/stretch penalty for line - float computeScore(float delta, bool atEnd); - void addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, float penalty, uint8_t hyph); @@ -213,10 +210,7 @@ class LineBreaker { void computeBreaksGreedy(); - void computeBreaksOptimal(); - - // special case when LineWidth is constant (layout is rectangle) - void computeBreaksOptimalRect(); + void computeBreaksOptimal(bool isRectangular); void finishBreaksOptimal(); @@ -241,6 +235,7 @@ class LineBreaker { ParaWidth mWidth = 0; std::vector mCandidates; + float mLinePenalty = 0.0f; // the following are state for greedy breaker (updated while adding style runs) size_t mLastBreak; diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index dbd6ea8206..8275a6cc10 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -37,6 +37,13 @@ const float SCORE_INFTY = std::numeric_limits::max(); const float SCORE_OVERFULL = 1e12f; const float SCORE_DESPERATE = 1e10f; +// Multiplier for hyphen penalty on last line. +const float LAST_LINE_PENALTY_MULTIPLIER = 4.0f; +// Penalty assigned to each line break (to try to minimize number of lines) +// TODO: when we implement full justification (so spaces can shrink and stretch), this is +// probably not the most appropriate method. +const float LINE_PENALTY_MULTIPLIER = 2.0f; + // Very long words trigger O(n^2) behavior in hyphenation, so we disable hyphenation for // unreasonably long words. This is somewhat of a heuristic because extremely long words // are possible in some languages. This does mean that very long real words can get @@ -122,6 +129,8 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa if (mHyphenationFrequency == kHyphenationFrequency_Normal) { hyphenPenalty *= 4.0; // TODO: Replace with a better value after some testing } + + mLinePenalty = std::max(mLinePenalty, hyphenPenalty * LINE_PENALTY_MULTIPLIER); } size_t current = (size_t)mBreakIterator->current(); @@ -235,17 +244,6 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post addCandidate(cand); } -// TODO: for justified text, refine with shrink/stretch -float LineBreaker::computeScore(float delta, bool atEnd) { - if (delta < 0) { - return SCORE_OVERFULL; - } else if (atEnd && mStrategy != kBreakStrategy_Balanced) { - return 0.0; - } else { - return delta * delta; - } -} - // TODO performance: could avoid populating mCandidates if greedy only void LineBreaker::addCandidate(Candidate cand) { size_t candIndex = mCandidates.size(); @@ -320,55 +318,7 @@ void LineBreaker::finishBreaksOptimal() { std::reverse(mFlags.begin(), mFlags.end()); } -void LineBreaker::computeBreaksOptimal() { - size_t active = 0; - size_t nCand = mCandidates.size(); - for (size_t i = 1; i < nCand; i++) { - bool atEnd = i == nCand - 1; - float best = SCORE_INFTY; - size_t bestPrev = 0; - - size_t lineNumberLast = mCandidates[active].lineNumber; - float width = mLineWidths.getLineWidth(lineNumberLast); - ParaWidth leftEdge = mCandidates[i].postBreak - width; - float bestHope = 0; - - for (size_t j = active; j < i; j++) { - size_t lineNumber = mCandidates[j].lineNumber; - if (lineNumber != lineNumberLast) { - float widthNew = mLineWidths.getLineWidth(lineNumber); - if (widthNew != width) { - leftEdge = mCandidates[i].postBreak - width; - bestHope = 0; - width = widthNew; - } - lineNumberLast = lineNumber; - } - float jScore = mCandidates[j].score; - if (jScore + bestHope >= best) continue; - float delta = mCandidates[j].preBreak - leftEdge; - - float widthScore = computeScore(delta, atEnd); - if (delta < 0) { - active = j + 1; - } else { - bestHope = widthScore; - } - - float score = jScore + widthScore; - if (score <= best) { - best = score; - bestPrev = j; - } - } - mCandidates[i].score = best + mCandidates[i].penalty; - mCandidates[i].prev = bestPrev; - mCandidates[i].lineNumber = mCandidates[bestPrev].lineNumber + 1; - } - finishBreaksOptimal(); -} - -void LineBreaker::computeBreaksOptimalRect() { +void LineBreaker::computeBreaksOptimal(bool isRectangle) { size_t active = 0; size_t nCand = mCandidates.size(); float width = mLineWidths.getLineWidth(0); @@ -376,19 +326,43 @@ void LineBreaker::computeBreaksOptimalRect() { bool atEnd = i == nCand - 1; float best = SCORE_INFTY; size_t bestPrev = 0; + size_t lineNumberLast = 0; - // Width-based component of score increases as line gets shorter, so score will always be - // at least this. + if (!isRectangle) { + size_t lineNumberLast = mCandidates[active].lineNumber; + width = mLineWidths.getLineWidth(lineNumberLast); + } + ParaWidth leftEdge = mCandidates[i].postBreak - width; float bestHope = 0; - ParaWidth leftEdge = mCandidates[i].postBreak - width; for (size_t j = active; j < i; j++) { - // TODO performance: can break if bestHope >= best; worth it? + if (!isRectangle) { + size_t lineNumber = mCandidates[j].lineNumber; + if (lineNumber != lineNumberLast) { + float widthNew = mLineWidths.getLineWidth(lineNumber); + if (widthNew != width) { + leftEdge = mCandidates[i].postBreak - width; + bestHope = 0; + width = widthNew; + } + lineNumberLast = lineNumber; + } + } float jScore = mCandidates[j].score; if (jScore + bestHope >= best) continue; float delta = mCandidates[j].preBreak - leftEdge; - float widthScore = computeScore(delta, atEnd); + // compute width score for line + float widthScore = 0.0f; + if (delta < 0) { + widthScore = SCORE_OVERFULL; + } else if (atEnd && mStrategy != kBreakStrategy_Balanced) { + // increase penalty for hyphen on last line + widthScore = LAST_LINE_PENALTY_MULTIPLIER * mCandidates[j].penalty; + } else { + widthScore = delta * delta; + } + if (delta < 0) { active = j + 1; } else { @@ -401,8 +375,9 @@ void LineBreaker::computeBreaksOptimalRect() { bestPrev = j; } } - mCandidates[i].score = best + mCandidates[i].penalty; + mCandidates[i].score = best + mCandidates[i].penalty + mLinePenalty; mCandidates[i].prev = bestPrev; + mCandidates[i].lineNumber = mCandidates[bestPrev].lineNumber + 1; } finishBreaksOptimal(); } @@ -410,10 +385,8 @@ void LineBreaker::computeBreaksOptimalRect() { size_t LineBreaker::computeBreaks() { if (mStrategy == kBreakStrategy_Greedy) { computeBreaksGreedy(); - } else if (mLineWidths.isConstant()) { - computeBreaksOptimalRect(); } else { - computeBreaksOptimal(); + computeBreaksOptimal(mLineWidths.isConstant()); } return mBreaks.size(); } @@ -438,6 +411,7 @@ void LineBreaker::finish() { } mStrategy = kBreakStrategy_Greedy; mHyphenationFrequency = kHyphenationFrequency_Normal; + mLinePenalty = 0.0f; } } // namespace android From 8081d06133ad04200da70d8015a0027860bef706 Mon Sep 17 00:00:00 2001 From: Keisuke Kuroyanagi Date: Wed, 10 Jun 2015 17:45:46 +0900 Subject: [PATCH 084/364] Fix: getOffsetForAdvance can return worng offset. searchStart was passed to getRunAdvance, but it can be different from the start that has been used to initialize Layout object. As a result, wrong index could be used in getRunAdvance. Bug: 21744454 Change-Id: Ibe83cc50ed6f0da2a1532318bc224502be350699 --- .../src/flutter/libs/minikin/Measurement.cpp | 22 ++++++++++++------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Measurement.cpp b/engine/src/flutter/libs/minikin/Measurement.cpp index 98d2c01a39..0b68ac5f64 100644 --- a/engine/src/flutter/libs/minikin/Measurement.cpp +++ b/engine/src/flutter/libs/minikin/Measurement.cpp @@ -28,26 +28,26 @@ namespace android { // These could be considered helper methods of layout, but need only be loosely coupled, so // are separate. -float getRunAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t count, - size_t offset) { +static float getRunAdvance(Layout& layout, const uint16_t* buf, size_t layoutStart, size_t start, + size_t count, size_t offset) { float advance = 0.0f; size_t lastCluster = start; float clusterWidth = 0.0f; for (size_t i = start; i < offset; i++) { - float charAdvance = layout.getCharAdvance(i - start); + float charAdvance = layout.getCharAdvance(i - layoutStart); if (charAdvance != 0.0f) { advance += charAdvance; lastCluster = i; clusterWidth = charAdvance; } } - if (offset < start + count && layout.getCharAdvance(offset - start) == 0.0f) { + if (offset < start + count && layout.getCharAdvance(offset - layoutStart) == 0.0f) { // In the middle of a cluster, distribute width of cluster so that each grapheme cluster // gets an equal share. // TODO: get caret information out of font when that's available size_t nextCluster; for (nextCluster = offset + 1; nextCluster < start + count; nextCluster++) { - if (layout.getCharAdvance(nextCluster - start) != 0.0f) break; + if (layout.getCharAdvance(nextCluster - layoutStart) != 0.0f) break; } int numGraphemeClusters = 0; int numGraphemeClustersAfter = 0; @@ -67,6 +67,11 @@ float getRunAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t co return advance; } +float getRunAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t count, + size_t offset) { + return getRunAdvance(layout, buf, start, start, count, offset); +} + /** * Essentially the inverse of getRunAdvance. Compute the value of offset for which the * measured caret comes closest to the provided advance param, and which is on a grapheme @@ -98,9 +103,10 @@ size_t getOffsetForAdvance(Layout& layout, const uint16_t* buf, size_t start, si float bestDist = FLT_MAX; for (size_t i = searchStart; i <= start + count; i++) { if (GraphemeBreak::isGraphemeBreak(buf, start, count, i)) { - // "getRunAdvance(layout, buf, start, count, bufSize, i) - advance" but more efficient - float delta = getRunAdvance(layout, buf, searchStart, count, i) + xSearchStart - - advance; + // "getRunAdvance(layout, buf, start, count, i) - advance" but more efficient + float delta = getRunAdvance(layout, buf, start, searchStart, count - searchStart, i) + + + xSearchStart - advance; if (std::abs(delta) < bestDist) { bestDist = std::abs(delta); best = i; From 48e52a29af97d17be2248e51b9d6d8602c9d6ce3 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Fri, 12 Jun 2015 10:29:59 -0700 Subject: [PATCH 085/364] Use ASCII HYPHEN-MINUS when there's no HYPHEN in the font. Previously, we just assumed the font in use had a U+2010 HYPHEN character, resulting in a tofu (or an empty space) being shown when U+2010 was not supported in the font used to render the hyphenated word. Now we try to fallback to U+002D HYPHEN-MINUS, which has a very good chance of being available in at least any Latin font. We still show a tofu when neither character is supported, to intentionally alert that something is missing. Bug: 20497913 Bug: 21088552 Bug: 21570828 Change-Id: Iff69bbc38836c03495e9124502b5207c39270da2 --- engine/src/flutter/libs/minikin/Layout.cpp | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 88baeac6f5..17ce596bd6 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -729,7 +729,17 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t // TODO: check whether this is really the desired semantics. It could have the // effect of assigning the hyphen width to a nonspacing mark unsigned int lastCluster = srunend - 1; - hb_buffer_add(buffer, 0x2010, lastCluster); + + hb_codepoint_t hyphenChar = 0x2010; // HYPHEN + hb_codepoint_t glyph; + // Fallback to ASCII HYPHEN-MINUS if the font didn't have a glyph for HYPHEN. Note + // that we intentionally don't do anything special if the font doesn't have a + // HYPHEN-MINUS either, so a tofu could be shown, hinting towards something + // missing. + if (!hb_font_get_glyph(hbFont, hyphenChar, 0, &glyph)) { + hyphenChar = 0x002D; // HYPHEN-MINUS + } + hb_buffer_add(buffer, hyphenChar, lastCluster); } hb_shape(hbFont, buffer, features.empty() ? NULL : &features[0], features.size()); unsigned int numGlyphs; From e5cb2f787c4a388a723b8fb62980e2238c85faaa Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 24 Jun 2015 12:59:18 -0700 Subject: [PATCH 086/364] Separate additional penalty for last line with hyphen A recent change added a penalty for a hyphen at the last line break, which is visually undesirable. However, the penalty was assessed to "widthScore", which broke the assumption (used for another optimization) that widthScore increases monotonically. This patch separates the penalty into a different parameter, restoring the validity of the monotonicity assumption. Bug: 22066119 Change-Id: I6a47a350ef3ceee2f00ee430d6954d0c307227f0 --- engine/src/flutter/libs/minikin/LineBreaker.cpp | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 8275a6cc10..162d14b8af 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -353,12 +353,17 @@ void LineBreaker::computeBreaksOptimal(bool isRectangle) { float delta = mCandidates[j].preBreak - leftEdge; // compute width score for line + + // Note: the "bestHope" optimization makes the assumption that, when delta is + // non-negative, widthScore will increase monotonically as successive candidate + // breaks are considered. float widthScore = 0.0f; + float additionalPenalty = 0.0f; if (delta < 0) { widthScore = SCORE_OVERFULL; } else if (atEnd && mStrategy != kBreakStrategy_Balanced) { // increase penalty for hyphen on last line - widthScore = LAST_LINE_PENALTY_MULTIPLIER * mCandidates[j].penalty; + additionalPenalty = LAST_LINE_PENALTY_MULTIPLIER * mCandidates[j].penalty; } else { widthScore = delta * delta; } @@ -369,7 +374,7 @@ void LineBreaker::computeBreaksOptimal(bool isRectangle) { bestHope = widthScore; } - float score = jScore + widthScore; + float score = jScore + widthScore + additionalPenalty; if (score <= best) { best = score; bestPrev = j; @@ -378,6 +383,9 @@ void LineBreaker::computeBreaksOptimal(bool isRectangle) { mCandidates[i].score = best + mCandidates[i].penalty + mLinePenalty; mCandidates[i].prev = bestPrev; mCandidates[i].lineNumber = mCandidates[bestPrev].lineNumber + 1; +#ifdef VERBOSE_DEBUG + ALOGD("break %d: score=%g, prev=%d", i, mCandidates[i].score, mCandidates[i].prev); +#endif } finishBreaksOptimal(); } From 5704594913e26de179ca914f55aeb149c0984388 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Fri, 26 Jun 2015 11:15:17 -0700 Subject: [PATCH 087/364] Disable letterspacing for connected scripts The appearance of letterspacing with scripts with cursive connections is poor, so we simply disable letterspacing for those scripts. There may be some cases where some form of letterspacing is desirable, but this gives the highest likelihood that the final result will be good without requiring additional work from clients. Bug: 21935803 Change-Id: Ie25266249ac3a2605aa89ef5132e8edbe3a06d35 --- engine/src/flutter/libs/minikin/Layout.cpp | 47 +++++++++++++++++----- 1 file changed, 38 insertions(+), 9 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 17ce596bd6..0c8c4ca79e 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -514,6 +514,29 @@ static size_t getNextWordBreak(const uint16_t* chars, size_t offset, size_t len) return len; } +/** + * Disable certain scripts (mostly those with cursive connection) from having letterspacing + * applied. See https://github.com/behdad/harfbuzz/issues/64 for more details. + */ +static bool isScriptOkForLetterspacing(hb_script_t script) { + return !( + script == HB_SCRIPT_ARABIC || + script == HB_SCRIPT_NKO || + script == HB_SCRIPT_PSALTER_PAHLAVI || + script == HB_SCRIPT_MANDAIC || + script == HB_SCRIPT_MONGOLIAN || + script == HB_SCRIPT_PHAGS_PA || + script == HB_SCRIPT_DEVANAGARI || + script == HB_SCRIPT_BENGALI || + script == HB_SCRIPT_GURMUKHI || + script == HB_SCRIPT_MODI || + script == HB_SCRIPT_SHARADA || + script == HB_SCRIPT_SYLOTI_NAGRI || + script == HB_SCRIPT_TIRHUTA || + script == HB_SCRIPT_OGHAM + ); +} + void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint) { AutoMutex _l(gMinikinLock); @@ -678,15 +701,6 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t double size = ctx->paint.size; double scaleX = ctx->paint.scaleX; - double letterSpace = ctx->paint.letterSpacing * size * scaleX; - double letterSpaceHalfLeft; - if ((ctx->paint.paintFlags & LinearTextFlag) == 0) { - letterSpace = round(letterSpace); - letterSpaceHalfLeft = floor(letterSpace * 0.5); - } else { - letterSpaceHalfLeft = letterSpace * 0.5; - } - double letterSpaceHalfRight = letterSpace - letterSpaceHalfLeft; float x = mAdvance; float y = 0; @@ -716,6 +730,21 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t srunend = srunstart; hb_script_t script = getScriptRun(buf + start, run.end, &srunend); + double letterSpace = 0.0; + double letterSpaceHalfLeft = 0.0; + double letterSpaceHalfRight = 0.0; + + if (ctx->paint.letterSpacing != 0.0 && isScriptOkForLetterspacing(script)) { + letterSpace = ctx->paint.letterSpacing * size * scaleX; + if ((ctx->paint.paintFlags & LinearTextFlag) == 0) { + letterSpace = round(letterSpace); + letterSpaceHalfLeft = floor(letterSpace * 0.5); + } else { + letterSpaceHalfLeft = letterSpace * 0.5; + } + letterSpaceHalfRight = letterSpace - letterSpaceHalfLeft; + } + hb_buffer_clear_contents(buffer); hb_buffer_set_script(buffer, script); hb_buffer_set_direction(buffer, isRtl? HB_DIRECTION_RTL : HB_DIRECTION_LTR); From 8726aff8cf57aeccacff60cf0e5fb4a7330994c4 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 29 Jun 2015 14:21:10 -0700 Subject: [PATCH 088/364] Fix logspam and incorrect cluster offset An incorrect cluster offset calculation was causing a lot of log messages to appear. Separately, a confusion between #if and #ifdef was causing unintended logging of line breaks. This patch fixes both. Bug: 22178333 Change-Id: I2b3673ed66c784f5082fd127a8dc10bd3df6ed79 --- engine/src/flutter/libs/minikin/Layout.cpp | 2 +- engine/src/flutter/libs/minikin/LineBreaker.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 0c8c4ca79e..bac5fc7743 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -757,7 +757,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t if (ctx->paint.hyphenEdit.hasHyphen() && srunend > srunstart) { // TODO: check whether this is really the desired semantics. It could have the // effect of assigning the hyphen width to a nonspacing mark - unsigned int lastCluster = srunend - 1; + unsigned int lastCluster = start + srunend - 1; hb_codepoint_t hyphenChar = 0x2010; // HYPHEN hb_codepoint_t glyph; diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 162d14b8af..baf2dfa412 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -383,7 +383,7 @@ void LineBreaker::computeBreaksOptimal(bool isRectangle) { mCandidates[i].score = best + mCandidates[i].penalty + mLinePenalty; mCandidates[i].prev = bestPrev; mCandidates[i].lineNumber = mCandidates[bestPrev].lineNumber + 1; -#ifdef VERBOSE_DEBUG +#if VERBOSE_DEBUG ALOGD("break %d: score=%g, prev=%d", i, mCandidates[i].score, mCandidates[i].prev); #endif } From 1b3bfb262437625ca4e6efb93b7b90543d6b5ec3 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Tue, 30 Jun 2015 10:15:43 -0700 Subject: [PATCH 089/364] Allow clusters to start with zero-width characters The logic in getRunAdvance() assumed that any zero-width character was part of the preceding cluster, which is valid most of the time. However, characters such as ZWNBSP (U+FEFF) renders as a zero width glyph and is also a grapheme cluster boundary. This patch adds a clause to handle that case. Bug: 22121742 Change-Id: Iad79a7d988bded1ef05f0fd7905d20669ea22051 --- engine/src/flutter/libs/minikin/Measurement.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/Measurement.cpp b/engine/src/flutter/libs/minikin/Measurement.cpp index 0b68ac5f64..a7bc64bea1 100644 --- a/engine/src/flutter/libs/minikin/Measurement.cpp +++ b/engine/src/flutter/libs/minikin/Measurement.cpp @@ -41,7 +41,8 @@ static float getRunAdvance(Layout& layout, const uint16_t* buf, size_t layoutSta clusterWidth = charAdvance; } } - if (offset < start + count && layout.getCharAdvance(offset - layoutStart) == 0.0f) { + if (offset < start + count && layout.getCharAdvance(offset - layoutStart) == 0.0f && + !GraphemeBreak::isGraphemeBreak(buf, start, count, offset)) { // In the middle of a cluster, distribute width of cluster so that each grapheme cluster // gets an equal share. // TODO: get caret information out of font when that's available From 2685aef48e970518da4f3514ef1db4f74fef656e Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 9 Jul 2015 15:58:16 -0700 Subject: [PATCH 090/364] Add HyphenEdit to layout cache We bypass the word layout cache for "complex" cases, which includes things like OpenType features. We were counting a hyphen edit as such a case, but the problem is that we measure a _lot_ of these when doing layout with hyphenation. This patch adds plumbing for hyphen edits to the layout cache, so that word fragments with hyphens can be cached as well. Bug: 22378829 Change-Id: Idba4df4faa14f48a5faccc8a7a7955a36c19ef27 --- engine/src/flutter/include/minikin/MinikinFont.h | 4 ++-- engine/src/flutter/libs/minikin/Layout.cpp | 5 ++++- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index ee885f497c..7f65cd7b0a 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -35,6 +35,7 @@ public: HyphenEdit() : hyphen(0) { } HyphenEdit(uint32_t hyphenInt) : hyphen(hyphenInt) { } bool hasHyphen() const { return hyphen != 0; } + bool operator==(const HyphenEdit &other) const { return hyphen == other.hyphen; } private: uint32_t hyphen; }; @@ -48,8 +49,7 @@ struct MinikinPaint { fakery(), fontFeatureSettings() { } bool skipCache() const { - // TODO: add hyphen to cache - return !fontFeatureSettings.empty() || hyphenEdit.hasHyphen(); + return !fontFeatureSettings.empty(); } MinikinFont *font; diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index bac5fc7743..be29e3ca2a 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -110,7 +110,7 @@ public: mStart(start), mCount(count), mId(collection->getId()), mStyle(style), mSize(paint.size), mScaleX(paint.scaleX), mSkewX(paint.skewX), mLetterSpacing(paint.letterSpacing), - mPaintFlags(paint.paintFlags), mIsRtl(dir) { + mPaintFlags(paint.paintFlags), mHyphenEdit(paint.hyphenEdit), mIsRtl(dir) { } bool operator==(const LayoutCacheKey &other) const; hash_t hash() const; @@ -144,6 +144,7 @@ private: float mSkewX; float mLetterSpacing; int32_t mPaintFlags; + HyphenEdit mHyphenEdit; bool mIsRtl; // Note: any fields added to MinikinPaint must also be reflected here. // TODO: language matching (possibly integrate into style) @@ -236,6 +237,7 @@ bool LayoutCacheKey::operator==(const LayoutCacheKey& other) const { && mSkewX == other.mSkewX && mLetterSpacing == other.mLetterSpacing && mPaintFlags == other.mPaintFlags + && mHyphenEdit == other.mHyphenEdit && mIsRtl == other.mIsRtl && mNchars == other.mNchars && !memcmp(mChars, other.mChars, mNchars * sizeof(uint16_t)); @@ -251,6 +253,7 @@ hash_t LayoutCacheKey::hash() const { hash = JenkinsHashMix(hash, hash_type(mSkewX)); hash = JenkinsHashMix(hash, hash_type(mLetterSpacing)); hash = JenkinsHashMix(hash, hash_type(mPaintFlags)); + hash = JenkinsHashMix(hash, hash_type(mHyphenEdit.hasHyphen())); hash = JenkinsHashMix(hash, hash_type(mIsRtl)); hash = JenkinsHashMixShorts(hash, mChars, mNchars); return JenkinsHashWhiten(hash); From 9793a7eda48113bbcd7fa802c7c59bb997d0cf2a Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Tue, 14 Jul 2015 13:04:49 -0700 Subject: [PATCH 091/364] Avoid re-hyphenating already-hyphenated phrases. Previously, automatic hyphenation blindly took almost every line breaking opportunity as a word break, so words like "low-budget" were treated as two separate words, "low-", and "budget", each automatically hyphenated. This patch makes sure the subwords in already-hyphenated phrases are not passed to the automatic hyphenator, while keeping the possibility of a potential line break where a hyphen already exists. Bug: 22484266 Bug: 22287425 Change-Id: Ie46dbdd70e993d64a9b9cf44b4ae93b21459dbc2 --- engine/src/flutter/libs/minikin/LineBreaker.cpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index baf2dfa412..bf8be269b0 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -29,7 +29,9 @@ using std::vector; namespace android { const int CHAR_TAB = 0x0009; +const uint16_t CHAR_HYPHEN_MINUS = 0x002D; const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; +const uint16_t CHAR_HYPHEN = 0x2010; // Large scores in a hierarchy; we prefer desperate breaks to an overfull line. All these // constants are larger than any reasonable actual width score. @@ -138,6 +140,7 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa size_t lastBreak = start; ParaWidth lastBreakWidth = mWidth; ParaWidth postBreak = mWidth; + bool temporarilySkipHyphenation = false; for (size_t i = start; i < end; i++) { uint16_t c = mTextBuf[i]; if (c == CHAR_TAB) { @@ -158,8 +161,12 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa // Override ICU's treatment of soft hyphen as a break opportunity, because we want it // to be a hyphen break, with penalty and drawing behavior. if (c != CHAR_SOFT_HYPHEN) { + // TODO: Add a new type of HyphenEdit for breaks whose hyphen already exists, so + // we can pass the whole word down to Hyphenator like the soft hyphen case. + bool wordEndsInHyphen = (c == CHAR_HYPHEN_MINUS || c == CHAR_HYPHEN); if (paint != nullptr && mHyphenator != nullptr && mHyphenationFrequency != kHyphenationFrequency_None && + !wordEndsInHyphen && !temporarilySkipHyphenation && wordEnd > lastBreak && wordEnd - lastBreak <= LONGEST_HYPHENATED_WORD) { mHyphenator->hyphenate(&mHyphBuf, &mTextBuf[lastBreak], wordEnd - lastBreak); #if VERBOSE_DEBUG @@ -188,6 +195,8 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa } } } + // Skip hyphenating the next word if and only if the present word ends in a hyphen + temporarilySkipHyphenation = wordEndsInHyphen; // Skip break for zero-width characters. if (current == mTextBuf.size() || mCharWidths[current] > 0) { From de1bd61f00c6f2556ef95befafd2470a8bff2aa1 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Wed, 15 Jul 2015 10:59:59 -0700 Subject: [PATCH 092/364] Add missing hyphen-like characters. This adds various hyphen-like characters missed in the previous patch, that should disallow automatic hyphenation of words containing them. Bug: 22484266 Change-Id: Ie972cb50384dbe0aa1ab5ec50286b75f9877953a --- .../src/flutter/libs/minikin/LineBreaker.cpp | 22 ++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index bf8be269b0..72e5c183c6 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -29,9 +29,7 @@ using std::vector; namespace android { const int CHAR_TAB = 0x0009; -const uint16_t CHAR_HYPHEN_MINUS = 0x002D; const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; -const uint16_t CHAR_HYPHEN = 0x2010; // Large scores in a hierarchy; we prefer desperate breaks to an overfull line. All these // constants are larger than any reasonable actual width score. @@ -107,6 +105,24 @@ static bool isLineEndSpace(uint16_t c) { c == 0x205F || c == 0x3000; } +// This function determines whether a character is like U+2010 HYPHEN in +// line breaking and usage: a character immediately after which line breaks +// are allowed, but words containing it should not be automatically +// hyphenated. This is a curated set, created by manually inspecting all +// the characters that have the Unicode line breaking property of BA or HY +// and seeing which ones are hyphens. +static bool isLineBreakingHyphen(uint16_t c) { + return (c == 0x002D || // HYPHEN-MINUS + c == 0x058A || // ARMENIAN HYPHEN + c == 0x05BE || // HEBREW PUNCTUATION MAQAF + c == 0x1400 || // CANADIAN SYLLABICS HYPHEN + c == 0x2010 || // HYPHEN + c == 0x2013 || // EN DASH + c == 0x2027 || // HYPHENATION POINT + c == 0x2E17 || // DOUBLE OBLIQUE HYPHEN + c == 0x2E40); // DOUBLE HYPHEN +} + // Ordinarily, this method measures the text in the range given. However, when paint // is nullptr, it assumes the widths have already been calculated and stored in the // width buffer. @@ -163,7 +179,7 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa if (c != CHAR_SOFT_HYPHEN) { // TODO: Add a new type of HyphenEdit for breaks whose hyphen already exists, so // we can pass the whole word down to Hyphenator like the soft hyphen case. - bool wordEndsInHyphen = (c == CHAR_HYPHEN_MINUS || c == CHAR_HYPHEN); + bool wordEndsInHyphen = isLineBreakingHyphen(c); if (paint != nullptr && mHyphenator != nullptr && mHyphenationFrequency != kHyphenationFrequency_None && !wordEndsInHyphen && !temporarilySkipHyphenation && From 7f0d04161b1b8c4d7995c7a3d9dd3c3a44d3c56e Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Wed, 15 Jul 2015 12:19:19 -0700 Subject: [PATCH 093/364] Use ICU to lowercase words to hyphenate. Previously, the standard C tolower() function was used, which didn't support any characters beyond the basic ASCII letters. Bug: 22506121 Change-Id: Ibb81121caa29be44fbb59aa98891e9faafc57592 --- engine/src/flutter/libs/minikin/Hyphenator.cpp | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Hyphenator.cpp b/engine/src/flutter/libs/minikin/Hyphenator.cpp index c50b3861af..3eb151b9e0 100644 --- a/engine/src/flutter/libs/minikin/Hyphenator.cpp +++ b/engine/src/flutter/libs/minikin/Hyphenator.cpp @@ -16,9 +16,9 @@ #include #include -#include #include #include +#include // HACK: for reading pattern file #include @@ -95,8 +95,19 @@ void Hyphenator::hyphenate(vector* result, const uint16_t* word, size_t hyphenateSoft(result, word, len); return; } - // TODO: use locale-sensitive case folding from ICU. - c = tolower(c); + // TODO: This uses ICU's simple character to character lowercasing, which ignores + // the locale, and ignores cases when lowercasing a character results in more than + // one character. It should be fixed to consider the locale (in order for it to work + // correctly for Turkish and Azerbaijani), as well as support one-to-many, and + // many-to-many case conversions (including non-BMP cases). + if (c < 0x00C0) { // U+00C0 is the lowest uppercase non-ASCII character + // Convert uppercase ASCII to lowercase ASCII, but keep other characters as-is + if (0x0041 <= c && c <= 0x005A) { + c += 0x0020; + } + } else { + c = u_tolower(c); + } } auto search = node->succ.find(c); if (search != node->succ.end()) { From 8a83b1a4ef2876fc23ceb0499019d7022f72ee5d Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 20 Jul 2015 15:37:54 -0700 Subject: [PATCH 094/364] Consistently apply break opportunities in text spans It's essential not to apply a break opportunity within a replacement span, otherwise things can happen such as displaying the span twice. The old code tested this case based on zero-width characters. However, this test was both imprecise, and also in some cases read uninitialized values from the mCharWidths array, which in turn led to inconsistent line breaking of the same text. This patch applies all line break opportunities (as identified by ICU) within text (as opposed to replacement spans), and also applies break opportunities at the beginning and end of replacement spans, but avoids breaks within a replacement span. Bug: 20138621 Change-Id: I36baeb44d6808356649e1bb69ca57f093fc8c723 --- engine/src/flutter/libs/minikin/LineBreaker.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 72e5c183c6..a832ca20e2 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -214,8 +214,8 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa // Skip hyphenating the next word if and only if the present word ends in a hyphen temporarilySkipHyphenation = wordEndsInHyphen; - // Skip break for zero-width characters. - if (current == mTextBuf.size() || mCharWidths[current] > 0) { + // Skip break for zero-width characters inside replacement span + if (paint != nullptr || current == end || mCharWidths[current] > 0) { addWordBreak(current, mWidth, postBreak, 0.0, 0); } lastBreak = current; From 4d86b85e69d25382a06b3f19f4a84154ec85361d Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Tue, 21 Jul 2015 05:31:11 +0000 Subject: [PATCH 095/364] Revert "Allow clusters to start with zero-width characters" This reverts commit 1b3bfb262437625ca4e6efb93b7b90543d6b5ec3. Bug: 22589743 Bug: 22121742 Change-Id: I7b482ffb8a0ee174ddc804aa890de45bdbd758e3 --- engine/src/flutter/libs/minikin/Measurement.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Measurement.cpp b/engine/src/flutter/libs/minikin/Measurement.cpp index a7bc64bea1..0b68ac5f64 100644 --- a/engine/src/flutter/libs/minikin/Measurement.cpp +++ b/engine/src/flutter/libs/minikin/Measurement.cpp @@ -41,8 +41,7 @@ static float getRunAdvance(Layout& layout, const uint16_t* buf, size_t layoutSta clusterWidth = charAdvance; } } - if (offset < start + count && layout.getCharAdvance(offset - layoutStart) == 0.0f && - !GraphemeBreak::isGraphemeBreak(buf, start, count, offset)) { + if (offset < start + count && layout.getCharAdvance(offset - layoutStart) == 0.0f) { // In the middle of a cluster, distribute width of cluster so that each grapheme cluster // gets an equal share. // TODO: get caret information out of font when that's available From 2be7eeef688e8e5546aae9540683e37fa994927f Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 29 Jul 2015 13:03:50 -0700 Subject: [PATCH 096/364] Improve fallback where explicit variant is not given In computing scores for which fallback font to choose, a match of a variant given explicitly in the xml config file scores higher than a family with no explicit variant. One consequence is that U+2010 HYPHEN is chosen from the Naskh Arabic font in the fallback case. This patch scores families with no variants as a match (effectively the same as if the xml file specified both variants). Thus, it will choose the first matching font (Roboto), which is a better choice. This patch also revises the list of "sticky" characters to include various hyphens, so Arabic (and potentially other scripts) text that includes hyphens can access the script-specific variants matched to the underlying text. Bug: 22824219 Change-Id: I6ec1043037f89cad50ca99ac24c473395546bcdf --- engine/src/flutter/libs/minikin/FontCollection.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index e3911c5bd3..b4bfe313ba 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -122,7 +122,7 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, return family; } int score = lang.match(family->lang()) * 2; - if (variant != 0 && variant == family->variant()) { + if (family->variant() == 0 || family->variant() == variant) { score++; } if (score > bestScore) { @@ -152,10 +152,13 @@ const uint32_t NBSP = 0xa0; const uint32_t ZWJ = 0x200c; const uint32_t ZWNJ = 0x200d; const uint32_t KEYCAP = 0x20e3; +const uint32_t HYPHEN = 0x2010; +const uint32_t NB_HYPHEN = 0x2011; // Characters where we want to continue using existing font run instead of // recomputing the best match in the fallback list. -static const uint32_t stickyWhitelist[] = { '!', ',', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, KEYCAP }; +static const uint32_t stickyWhitelist[] = { '!', ',', '-', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, + KEYCAP, HYPHEN, NB_HYPHEN }; static bool isStickyWhitelisted(uint32_t c) { for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) { From 36a78d6d47a0b97e94ab358f2a38aaf6ac0e3945 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Thu, 6 Aug 2015 13:33:14 -0700 Subject: [PATCH 097/364] Gold plate grapheme cluster breaks. This tailors Unicode's Grapheme_Cluster_Break property to better classify characters currently with the Control property value. Also adds support for rule GB9b of UAX #29, needed since there are now characters we are tailoring to be Prepend. The rule was previously ommited in our implementation because there was no characters in the Prepend class. Bug: 15653110 Change-Id: If10da88df0980f7d676c8c0b950eda5fb8dbe741 --- .../flutter/libs/minikin/GraphemeBreak.cpp | 78 +++++++++++++++---- 1 file changed, 62 insertions(+), 16 deletions(-) diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index f8f386c0de..21da180b10 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -22,6 +22,48 @@ namespace android { +int32_t tailoredGraphemeClusterBreak(uint32_t c) { + // Characters defined as Control that we want to treat them as Extend. + // These are curated manually. + if (c == 0x00AD // SHY + || c == 0x061C // ALM + || c == 0x180E // MONGOLIAN VOWEL SEPARATOR + || c == 0x200B // ZWSP + || c == 0x200E // LRM + || c == 0x200F // RLM + || (0x202A <= c && c <= 0x202E) // LRE, RLE, PDF, LRO, RLO + || ((c | 0xF) == 0x206F) // WJ, invisible math operators, LRI, RLI, FSI, PDI, + // and the deprecated invisible format controls + || c == 0xFEFF // BOM + || ((c | 0x7F) == 0xE007F)) // recently undeprecated tag characters in Plane 14 + return U_GCB_EXTEND; + // UTC-approved characters for the Prepend class, per + // http://www.unicode.org/L2/L2015/15183r-graph-cluster-brk.txt + // These should be removed when our copy of ICU gets updated to Unicode 9.0 (~2016 or 2017). + else if ((0x0600 <= c && c <= 0x0605) // Arabic subtending marks + || c == 0x06DD // ARABIC SUBTENDING MARK + || c == 0x070F // SYRIAC ABBREVIATION MARK + || c == 0x0D4E // MALAYALAM LETTER DOT REPH + || c == 0x110BD // KAITHI NUMBER SIGN + || c == 0x111C2 // SHARADA SIGN JIHVAMULIYA + || c == 0x111C3) // SHARADA SIGN UPADHMANIYA + return U_GCB_PREPEND; + // THAI CHARACTER SARA AM is treated as a normal letter by most other implementations: they + // allow a grapheme break before it. + else if (c == 0x0E33) + return U_GCB_OTHER; + else + return u_getIntPropertyValue(c, UCHAR_GRAPHEME_CLUSTER_BREAK); +} + +// Returns true for all characters whose IndicSyllabicCategory is Pure_Killer. +// From http://www.unicode.org/Public/8.0.0/ucd/IndicSyllabicCategory.txt +bool isPureKiller(uint32_t c) { + return (c == 0x0E3A || c == 0x0E4E || c == 0x0F84 || c == 0x103A || c == 0x1714 || c == 0x1734 + || c == 0x17D1 || c == 0x1BAA || c == 0x1BF2 || c == 0x1BF3 || c == 0xA806 + || c == 0xA953 || c == 0xABED || c == 0x11134 || c == 0x112EA || c == 0x1172B); +} + bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t count, size_t offset) { // This implementation closely follows Unicode Standard Annex #29 on @@ -42,8 +84,8 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co size_t offset_back = offset; U16_PREV(buf, start, offset_back, c1); U16_NEXT(buf, offset, start + count, c2); - int32_t p1 = u_getIntPropertyValue(c1, UCHAR_GRAPHEME_CLUSTER_BREAK); - int32_t p2 = u_getIntPropertyValue(c2, UCHAR_GRAPHEME_CLUSTER_BREAK); + int32_t p1 = tailoredGraphemeClusterBreak(c1); + int32_t p2 = tailoredGraphemeClusterBreak(c2); // Rule GB3, CR x LF if (p1 == U_GCB_CR && p2 == U_GCB_LF) { return false; @@ -54,13 +96,6 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co } // Rule GB5, / (Control | CR | LF) if (p2 == U_GCB_CONTROL || p2 == U_GCB_CR || p2 == U_GCB_LF) { - // exclude zero-width control characters from breaking (tailoring of UAX #29) - if (c2 == 0x00ad - || (c2 >= 0x200b && c2 <= 0x200f) - || (c2 >= 0x2028 && c2 <= 0x202e) - || (c2 >= 0x2060 && c2 <= 0x206f)) { - return false; - } return true; } // Rule GB6, L x ( L | V | LV | LVT ) @@ -76,20 +111,31 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co return false; } // Rule GB8a, Regional_Indicator x Regional_Indicator + // + // Known limitation: This is overly conservative, and returns no grapheme breaks between two + // flags, such as in the character sequence "U+1F1FA U+1F1F8 [potential break] U+1F1FA U+1F1F8". + // Also, it assumes that all combinations of Regional Indicators produce a flag, where they + // don't. + // + // There is no easy solution for doing this correctly, except for querying the font and doing + // some lookback. if (p1 == U_GCB_REGIONAL_INDICATOR && p2 == U_GCB_REGIONAL_INDICATOR) { return false; } - // Rule GB9, x Extend; Rule GB9a, x SpacingMark - if (p2 == U_GCB_EXTEND || p2 == U_GCB_SPACING_MARK) { - if (c2 == 0xe33) { - // most other implementations break THAI CHARACTER SARA AM - // (tailoring of UAX #29) - return true; - } + // Rule GB9, x Extend; Rule GB9a, x SpacingMark; Rule GB9b, Prepend x + if (p2 == U_GCB_EXTEND || p2 == U_GCB_SPACING_MARK || p1 == U_GCB_PREPEND) { return false; } // Cluster indic syllables together (tailoring of UAX #29) + // Known limitation: this is overly conservative, and assumes that the virama may form a + // conjunct with the following letter, which doesn't always happen. + // + // There is no easy solution to do this correctly. Even querying the font does not help (with + // the current font technoloies), since the font may be creating the conjunct using multiple + // glyphs, while the user may be perceiving that sequence of glyphs as one conjunct or one + // letter. if (u_getIntPropertyValue(c1, UCHAR_CANONICAL_COMBINING_CLASS) == 9 // virama + && !isPureKiller(c1) && u_getIntPropertyValue(c2, UCHAR_GENERAL_CATEGORY) == U_OTHER_LETTER) { return false; } From 92603d1527ba3c15d395e0c52c600684bd6099f6 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Fri, 7 Aug 2015 21:37:37 -0700 Subject: [PATCH 098/364] Support three-letter language codes in FontLanguage. Also handle the case of weird language code that we don't understand properly better, by treating them not equal to each other. Change-Id: Iaccb251fa38d700932f6eadac254d3d1fa09b3ea --- .../src/flutter/include/minikin/FontFamily.h | 13 +++-- .../src/flutter/libs/minikin/FontFamily.cpp | 57 ++++++++++++------- 2 files changed, 45 insertions(+), 25 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 7bdff6eb4f..d21a20af71 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -40,7 +40,9 @@ public: // Parse from string FontLanguage(const char* buf, size_t size); - bool operator==(const FontLanguage other) const { return mBits == other.mBits; } + bool operator==(const FontLanguage other) const { + return mBits != kUnsupportedLanguage && mBits == other.mBits; + } operator bool() const { return mBits != 0; } std::string getString() const; @@ -53,10 +55,11 @@ private: uint32_t bits() const { return mBits; } - static const uint32_t kBaseLangMask = 0xffff; - static const uint32_t kScriptMask = (1 << 18) - (1 << 16); - static const uint32_t kHansFlag = 1 << 16; - static const uint32_t kHantFlag = 1 << 17; + static const uint32_t kUnsupportedLanguage = 0xFFFFFFFFu; + static const uint32_t kBaseLangMask = 0xFFFFFFu; + static const uint32_t kScriptMask = (1u << 26) - (1u << 24); + static const uint32_t kHansFlag = 1u << 24; + static const uint32_t kHantFlag = 1u << 25; uint32_t mBits; }; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index da7320bce5..c70cf88023 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -40,7 +40,14 @@ FontLanguage::FontLanguage(const char* buf, size_t size) { if (c == '-' || c == '_') break; } if (i == 2) { - bits = (uint8_t(buf[0]) << 8) | uint8_t(buf[1]); + bits = uint8_t(buf[0]) | (uint8_t(buf[1]) << 8); + } else if (i == 3) { + bits = uint8_t(buf[0]) | (uint8_t(buf[1]) << 8) | (uint8_t(buf[2]) << 16); + } else { + mBits = kUnsupportedLanguage; + // We don't understand anything other than two-letter or three-letter + // language codes, so we skip parsing the rest of the string. + return; } size_t next; for (i++; i < size; i = next + 1) { @@ -62,28 +69,38 @@ FontLanguage::FontLanguage(const char* buf, size_t size) { } std::string FontLanguage::getString() const { - char buf[16]; - size_t i = 0; - if (mBits & kBaseLangMask) { - buf[i++] = (mBits >> 8) & 0xFFu; - buf[i++] = mBits & 0xFFu; - } - if (mBits & kScriptMask) { - if (!i) - buf[i++] = 'x'; - buf[i++] = '-'; - buf[i++] = 'H'; - buf[i++] = 'a'; - buf[i++] = 'n'; - if (mBits & kHansFlag) - buf[i++] = 's'; - else - buf[i++] = 't'; - } - return std::string(buf, i); + if (mBits == kUnsupportedLanguage) { + return "und"; + } + char buf[16]; + size_t i = 0; + if (mBits & kBaseLangMask) { + buf[i++] = mBits & 0xFFu; + buf[i++] = (mBits >> 8) & 0xFFu; + char third_letter = (mBits >> 16) & 0xFFu; + if (third_letter != 0) buf[i++] = third_letter; + } + if (mBits & kScriptMask) { + if (!i) { + // This should not happen, but as it apparently has, we fill the language code part + // with "und". + buf[i++] = 'u'; + buf[i++] = 'n'; + buf[i++] = 'd'; + } + buf[i++] = '-'; + buf[i++] = 'H'; + buf[i++] = 'a'; + buf[i++] = 'n'; + buf[i++] = (mBits & kHansFlag) ? 's' : 't'; + } + return std::string(buf, i); } int FontLanguage::match(const FontLanguage other) const { + if (mBits == kUnsupportedLanguage || other.mBits == kUnsupportedLanguage) + return 0; + int result = 0; if ((mBits & kBaseLangMask) == (other.mBits & kBaseLangMask)) { result++; From f1919543373951d4fa2dab862d463ad1ecf3e204 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Tue, 11 Aug 2015 16:27:06 -0700 Subject: [PATCH 099/364] Clean up use of printf() in Layout.cpp. Reported externally at https://code.google.com/p/android/issues/detail?id=167715. Bug: 21498085 Change-Id: I73f22de03b0151ce31a6b3070d051a2a701b33d2 --- engine/src/flutter/libs/minikin/Layout.cpp | 26 +++++++++++++--------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index be29e3ca2a..1b1ad1f296 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -18,7 +18,6 @@ #include #include -#include // for debugging #include #include @@ -302,8 +301,10 @@ hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { return 0; } ok = font->GetTable(tag, reinterpret_cast(buffer), &length); - printf("referenceTable %c%c%c%c length=%d %d\n", +#ifdef VERBOSE_DEBUG + ALOGD("referenceTable %c%c%c%c length=%d %d", (tag >>24) & 0xff, (tag>>16)&0xff, (tag>>8)&0xff, tag&0xff, length, ok); +#endif if (!ok) { free(buffer); return 0; @@ -717,9 +718,8 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t ctx->paint.font = mFaces[font_ix].font; ctx->paint.fakery = mFaces[font_ix].fakery; hb_font_t* hbFont = ctx->hbFonts[font_ix]; -#ifdef VERBOSE - std::cout << "Run " << run_ix << ", font " << font_ix << - " [" << run.start << ":" << run.end << "]" << std::endl; +#ifdef VERBOSE_DEBUG + ALOGD("Run %u, font %d [%d:%d]", run_ix, font_ix, run.start, run.end); #endif hb_font_set_ppem(hbFont, size * scaleX, size); @@ -783,10 +783,14 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t x += letterSpaceHalfLeft; } for (unsigned int i = 0; i < numGlyphs; i++) { - #ifdef VERBOSE - std::cout << positions[i].x_advance << " " << positions[i].y_advance << " " << positions[i].x_offset << " " << positions[i].y_offset << std::endl; std::cout << "DoLayout " << info[i].codepoint << - ": " << HBFixedToFloat(positions[i].x_advance) << "; " << positions[i].x_offset << ", " << positions[i].y_offset << std::endl; - #endif +#ifdef VERBOSE_DEBUG + ALOGD("%d %d %d %d", + positions[i].x_advance, positions[i].y_advance, + positions[i].x_offset, positions[i].y_offset); + ALOGD("DoLayout %u: %f; %d, %d", + info[i].codepoint, HBFixedToFloat(positions[i].x_advance), + positions[i].x_offset, positions[i].y_offset); +#endif if (i > 0 && info[i - 1].cluster != info[i].cluster) { mAdvances[info[i - 1].cluster - start] += letterSpaceHalfRight; mAdvances[info[i].cluster - start] += letterSpaceHalfLeft; @@ -877,8 +881,10 @@ void Layout::draw(minikin::Bitmap* surface, int x0, int y0, float size) const { MinikinPaint paint; paint.size = size; bool ok = face->Render(glyph.glyph_id, paint, &glyphBitmap); - printf("glyphBitmap.width=%d, glyphBitmap.height=%d (%d, %d) x=%f, y=%f, ok=%d\n", +#ifdef VERBOSE_DEBUG + ALOGD("glyphBitmap.width=%d, glyphBitmap.height=%d (%d, %d) x=%f, y=%f, ok=%d", glyphBitmap.width, glyphBitmap.height, glyphBitmap.left, glyphBitmap.top, glyph.x, glyph.y, ok); +#endif if (ok) { surface->drawGlyph(glyphBitmap, x0 + int(floor(glyph.x + 0.5)), y0 + int(floor(glyph.y + 0.5))); From 4f1a8688721c4c20524cb7c8e5b68e3865dbbe63 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 12 Aug 2015 11:29:39 -0700 Subject: [PATCH 100/364] Add basic unit tests for Minikin Initial unit tests for Minikin functionality. Also fixes an incorrect Hangul case (uncovered in testing), and improves handling of broken UTF-16. Change-Id: I69b441d8e3b19ed06abcc56f13271abadf3d1010 --- engine/src/flutter/libs/minikin/Android.mk | 26 +++- .../flutter/libs/minikin/GraphemeBreak.cpp | 14 +- engine/src/flutter/tests/Android.mk | 41 ++++++ .../src/flutter/tests/GraphemeBreakTests.cpp | 130 ++++++++++++++++++ engine/src/flutter/tests/UnicodeUtils.cpp | 96 +++++++++++++ engine/src/flutter/tests/UnicodeUtils.h | 18 +++ engine/src/flutter/tests/how_to_run.txt | 4 + 7 files changed, 316 insertions(+), 13 deletions(-) create mode 100644 engine/src/flutter/tests/Android.mk create mode 100644 engine/src/flutter/tests/GraphemeBreakTests.cpp create mode 100644 engine/src/flutter/tests/UnicodeUtils.cpp create mode 100644 engine/src/flutter/tests/UnicodeUtils.h create mode 100644 engine/src/flutter/tests/how_to_run.txt diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 873f279f0c..e2b588c19c 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -16,7 +16,7 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) -LOCAL_SRC_FILES := \ +minikin_src_files := \ AnalyzeStyle.cpp \ CmapCoverage.cpp \ FontCollection.cpp \ @@ -31,20 +31,34 @@ LOCAL_SRC_FILES := \ MinikinFontFreeType.cpp \ SparseBitSet.cpp -LOCAL_MODULE := libminikin - -LOCAL_C_INCLUDES += \ +minikin_c_includes := \ external/harfbuzz_ng/src \ external/freetype/include \ frameworks/minikin/include -LOCAL_SHARED_LIBRARIES := \ +minikin_shared_libraries := \ libharfbuzz_ng \ libft2 \ liblog \ - libpng \ libz \ libicuuc \ libutils +LOCAL_MODULE := libminikin +LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include +LOCAL_SRC_FILES := $(minikin_src_files) +LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) + include $(BUILD_SHARED_LIBRARY) + +include $(CLEAR_VARS) + +LOCAL_MODULE := libminikin +LOCAL_MODULE_TAGS := optional +LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include +LOCAL_SRC_FILES := $(minikin_src_files) +LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) + +include $(BUILD_STATIC_LIBRARY) diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index 21da180b10..eca74b178c 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -71,13 +71,13 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co // implementing a tailored version of extended grapheme clusters. // The GB rules refer to section 3.1.1, Grapheme Cluster Boundary Rules. - // Rule GB1, sot /; Rule GB2, / eot + // Rule GB1, sot ÷; Rule GB2, ÷ eot if (offset <= start || offset >= start + count) { return true; } if (U16_IS_TRAIL(buf[offset])) { - // Don't break a surrogate pair - return false; + // Don't break a surrogate pair, but a lonely trailing surrogate pair is a break + return !U16_IS_LEAD(buf[offset - 1]); } uint32_t c1 = 0; uint32_t c2 = 0; @@ -90,11 +90,11 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co if (p1 == U_GCB_CR && p2 == U_GCB_LF) { return false; } - // Rule GB4, (Control | CR | LF) / + // Rule GB4, (Control | CR | LF) ÷ if (p1 == U_GCB_CONTROL || p1 == U_GCB_CR || p1 == U_GCB_LF) { return true; } - // Rule GB5, / (Control | CR | LF) + // Rule GB5, ÷ (Control | CR | LF) if (p2 == U_GCB_CONTROL || p2 == U_GCB_CR || p2 == U_GCB_LF) { return true; } @@ -107,7 +107,7 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co return false; } // Rule GB8, ( LVT | T ) x T - if ((p1 == U_GCB_L || p1 == U_GCB_T) && p2 == U_GCB_T) { + if ((p1 == U_GCB_LVT || p1 == U_GCB_T) && p2 == U_GCB_T) { return false; } // Rule GB8a, Regional_Indicator x Regional_Indicator @@ -139,7 +139,7 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co && u_getIntPropertyValue(c2, UCHAR_GENERAL_CATEGORY) == U_OTHER_LETTER) { return false; } - // Rule GB10, Any / Any + // Rule GB10, Any ÷ Any return true; } diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk new file mode 100644 index 0000000000..ebce0eace3 --- /dev/null +++ b/engine/src/flutter/tests/Android.mk @@ -0,0 +1,41 @@ +# 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. + +# see how_to_run.txt for instructions on running these tests + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_MODULE := minikin_tests +LOCAL_MODULE_TAGS := tests + +LOCAL_STATIC_LIBRARIES := libminikin + +# Shared libraries which are dependencies of minikin; these are not automatically +# pulled in by the build system (and thus sadly must be repeated). + +LOCAL_SHARED_LIBRARIES := \ + libharfbuzz_ng \ + libft2 \ + liblog \ + libz \ + libicuuc \ + libutils + +LOCAL_SRC_FILES += \ + GraphemeBreakTests.cpp \ + UnicodeUtils.cpp + +include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/GraphemeBreakTests.cpp b/engine/src/flutter/tests/GraphemeBreakTests.cpp new file mode 100644 index 0000000000..6eda4da9fd --- /dev/null +++ b/engine/src/flutter/tests/GraphemeBreakTests.cpp @@ -0,0 +1,130 @@ +/* + * 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. + */ + +#include +#include +#include + +using namespace android; + +bool IsBreak(const char* src) { + const size_t BUF_SIZE = 256; + uint16_t buf[BUF_SIZE]; + size_t offset; + size_t size; + ParseUnicode(buf, BUF_SIZE, src, &size, &offset); + return GraphemeBreak::isGraphemeBreak(buf, 0, size, offset); +} + +TEST(GraphemeBreak, utf16) { + EXPECT_FALSE(IsBreak("U+D83C | U+DC31")); // emoji, U+1F431 + + // tests for invalid UTF-16 + EXPECT_TRUE(IsBreak("U+D800 | U+D800")); // two leading surrogates + EXPECT_TRUE(IsBreak("U+DC00 | U+DC00")); // two trailing surrogates + EXPECT_TRUE(IsBreak("'a' | U+D800")); // lonely leading surrogate + EXPECT_TRUE(IsBreak("U+DC00 | 'a'")); // lonely trailing surrogate + EXPECT_TRUE(IsBreak("U+D800 | 'a'")); // leading surrogate followed by non-surrogate + EXPECT_TRUE(IsBreak("'a' | U+DC00")); // non-surrogate followed by trailing surrogate +} + +TEST(GraphemeBreak, rules) { + // Rule GB1, sot ÷; Rule GB2, ÷ eot + EXPECT_TRUE(IsBreak("| 'a'")); + EXPECT_TRUE(IsBreak("'a' |")); + + // Rule GB3, CR x LF + EXPECT_FALSE(IsBreak("U+000D | U+000A")); // CR x LF + + // Rule GB4, (Control | CR | LF) ÷ + EXPECT_TRUE(IsBreak("'a' | U+2028")); // Line separator + EXPECT_TRUE(IsBreak("'a' | U+000D")); // LF + EXPECT_TRUE(IsBreak("'a' | U+000A")); // CR + + // Rule GB5, ÷ (Control | CR | LF) + EXPECT_TRUE(IsBreak("U+2028 | 'a'")); // Line separator + EXPECT_TRUE(IsBreak("U+000D | 'a'")); // LF + EXPECT_TRUE(IsBreak("U+000A | 'a'")); // CR + + // Rule GB6, L x ( L | V | LV | LVT ) + EXPECT_FALSE(IsBreak("U+1100 | U+1100")); // L x L + EXPECT_FALSE(IsBreak("U+1100 | U+1161")); // L x V + EXPECT_FALSE(IsBreak("U+1100 | U+AC00")); // L x LV + EXPECT_FALSE(IsBreak("U+1100 | U+AC01")); // L x LVT + + // Rule GB7, ( LV | V ) x ( V | T ) + EXPECT_FALSE(IsBreak("U+AC00 | U+1161")); // LV x V + EXPECT_FALSE(IsBreak("U+1161 | U+1161")); // V x V + EXPECT_FALSE(IsBreak("U+AC00 | U+11A8")); // LV x T + EXPECT_FALSE(IsBreak("U+1161 | U+11A8")); // V x T + + // Rule GB8, ( LVT | T ) x T + EXPECT_FALSE(IsBreak("U+AC01 | U+11A8")); // LVT x T + EXPECT_FALSE(IsBreak("U+11A8 | U+11A8")); // T x T + + // Other hangul pairs not counted above _are_ breaks (GB10) + EXPECT_TRUE(IsBreak("U+AC00 | U+1100")); // LV x L + EXPECT_TRUE(IsBreak("U+AC01 | U+1100")); // LVT x L + EXPECT_TRUE(IsBreak("U+11A8 | U+1100")); // T x L + EXPECT_TRUE(IsBreak("U+11A8 | U+AC00")); // T x LV + EXPECT_TRUE(IsBreak("U+11A8 | U+AC01")); // T x LVT + + // Rule GB8a, Regional_Indicator x Regional_Indicator + EXPECT_FALSE(IsBreak("U+1F1FA | U+1F1F8")); + + // Rule GB9, x Extend + EXPECT_FALSE(IsBreak("'a' | U+0301")); // combining accent + // Rule GB9a, x SpacingMark + EXPECT_FALSE(IsBreak("U+0915 | U+093E")); // KA, AA (spacing mark) + // Rule GB9b, Prepend x + // see tailoring test for prepend, as current ICU doesn't have any characters in the class + + // Rule GB10, Any ÷ Any + EXPECT_TRUE(IsBreak("'a' | 'b'")); + EXPECT_TRUE(IsBreak("'f' | 'i'")); // probable ligature + EXPECT_TRUE(IsBreak("U+0644 | U+0627")); // probable ligature, lam + alef + EXPECT_TRUE(IsBreak("U+4E00 | U+4E00")); // CJK ideographs + EXPECT_TRUE(IsBreak("'a' | U+1F1FA U+1F1F8")); // Regional indicator pair (flag) + EXPECT_TRUE(IsBreak("U+1F1FA U+1F1F8 | 'a'")); // Regional indicator pair (flag) +} + +TEST(GraphemeBreak, tailoring) { + // control characters that we interpret as "extend" + EXPECT_FALSE(IsBreak("'a' | U+00AD")); // soft hyphen + EXPECT_FALSE(IsBreak("'a' | U+200B")); // zwsp + EXPECT_FALSE(IsBreak("'a' | U+200E")); // lrm + EXPECT_FALSE(IsBreak("'a' | U+202A")); // lre + EXPECT_FALSE(IsBreak("'a' | U+E0041")); // tag character + + // UTC-approved characters for the Prepend class + EXPECT_FALSE(IsBreak("U+06DD | U+0661")); // arabic subtending mark + digit one + + EXPECT_TRUE(IsBreak("U+0E01 | U+0E33")); // Thai sara am + + // virama is not a grapheme break, but "pure killer" is + EXPECT_FALSE(IsBreak("U+0915 | U+094D U+0915")); // Devanagari ka+virama+ka + EXPECT_FALSE(IsBreak("U+0915 U+094D | U+0915")); // Devanagari ka+virama+ka + EXPECT_FALSE(IsBreak("U+0E01 | U+0E3A U+0E01")); // thai phinthu = pure killer + EXPECT_TRUE(IsBreak("U+0E01 U+0E3A | U+0E01")); // thai phinthu = pure killer +} + +TEST(GraphemeBreak, offsets) { + uint16_t string[] = { 0x0041, 0x06DD, 0x0045, 0x0301, 0x0049, 0x0301 }; + EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(string, 2, 3, 2)); + EXPECT_FALSE(GraphemeBreak::isGraphemeBreak(string, 2, 3, 3)); + EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(string, 2, 3, 4)); + EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(string, 2, 3, 5)); +} diff --git a/engine/src/flutter/tests/UnicodeUtils.cpp b/engine/src/flutter/tests/UnicodeUtils.cpp new file mode 100644 index 0000000000..501fc9f480 --- /dev/null +++ b/engine/src/flutter/tests/UnicodeUtils.cpp @@ -0,0 +1,96 @@ +/* + * 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. + */ + +#include +#include +#include + +// src is of the form "U+1F431 | 'h' 'i'". Position of "|" gets saved to offset if non-null. +// Size is returned in an out parameter because gtest needs a void return for ASSERT to work. +void ParseUnicode(uint16_t* buf, size_t buf_size, const char* src, size_t* result_size, + size_t* offset) { + size_t input_ix = 0; + size_t output_ix = 0; + bool seen_offset = false; + + while (src[input_ix] != 0) { + switch (src[input_ix]) { + case '\'': + // single ASCII char + ASSERT_LT(src[input_ix], 0x80); + input_ix++; + ASSERT_NE(src[input_ix], 0); + ASSERT_LT(output_ix, buf_size); + buf[output_ix++] = (uint16_t)src[input_ix++]; + ASSERT_EQ(src[input_ix], '\''); + input_ix++; + break; + case 'u': + case 'U': { + // Unicode codepoint in hex syntax + input_ix++; + ASSERT_EQ(src[input_ix], '+'); + input_ix++; + char* endptr = (char*)src + input_ix; + unsigned long int codepoint = strtoul(src + input_ix, &endptr, 16); + size_t num_hex_digits = endptr - (src + input_ix); + ASSERT_GE(num_hex_digits, 4u); // also triggers on invalid number syntax, digits = 0 + ASSERT_LE(num_hex_digits, 6u); + ASSERT_LE(codepoint, 0x10FFFFu); + input_ix += num_hex_digits; + if (U16_LENGTH(codepoint) == 1) { + ASSERT_LE(output_ix + 1, buf_size); + buf[output_ix++] = codepoint; + } else { + // UTF-16 encoding + ASSERT_LE(output_ix + 2, buf_size); + buf[output_ix++] = U16_LEAD(codepoint); + buf[output_ix++] = U16_TRAIL(codepoint); + } + break; + } + case ' ': + input_ix++; + break; + case '|': + ASSERT_FALSE(seen_offset); + ASSERT_NE(offset, nullptr); + *offset = output_ix; + seen_offset = true; + input_ix++; + break; + default: + FAIL(); // unexpected character + } + } + ASSERT_NE(result_size, nullptr); + *result_size = output_ix; + ASSERT_TRUE(seen_offset || offset == nullptr); +} + +TEST(UnicodeUtils, parse) { + const size_t BUF_SIZE = 256; + uint16_t buf[BUF_SIZE]; + size_t offset; + size_t size; + ParseUnicode(buf, BUF_SIZE, "U+000D U+1F431 | 'a'", &size, &offset); + EXPECT_EQ(size, 4u); + EXPECT_EQ(offset, 3u); + EXPECT_EQ(buf[0], 0x000D); + EXPECT_EQ(buf[1], 0xD83D); + EXPECT_EQ(buf[2], 0xDC31); + EXPECT_EQ(buf[3], 'a'); +} diff --git a/engine/src/flutter/tests/UnicodeUtils.h b/engine/src/flutter/tests/UnicodeUtils.h new file mode 100644 index 0000000000..4f1b06a2fc --- /dev/null +++ b/engine/src/flutter/tests/UnicodeUtils.h @@ -0,0 +1,18 @@ +/* + * 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. + */ + + void ParseUnicode(uint16_t* buf, size_t buf_size, const char* src, size_t* result_size, + size_t* offset); diff --git a/engine/src/flutter/tests/how_to_run.txt b/engine/src/flutter/tests/how_to_run.txt new file mode 100644 index 0000000000..a6b7952855 --- /dev/null +++ b/engine/src/flutter/tests/how_to_run.txt @@ -0,0 +1,4 @@ +mmm -j8 frameworks/minikin/tests && +adb push $OUT/data/nativetest/minikin_tests/minikin_tests \ + /data/nativetest/minikin_tests/minikin_tests && +adb shell /data/nativetest/minikin_tests/minikin_tests From f09cf789ef140f47d02554d7aec74a5c1c42f9f4 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 25 Aug 2015 12:06:46 -0700 Subject: [PATCH 101/364] Update word breaker to be aware tone mark and variation selector. This CL does: 1. Move the getNextWordBreak/getPrevWordBreak function to a separate source file. 2. Adding "ForCache" suffix for function name for making clear these function is for layout cache. 3. Introduce unit tests for them. Bug: 11256006 Change-Id: I4138751a4570915f1a0d6c8921f89700f8ec7f35 --- engine/src/flutter/libs/minikin/Android.mk | 1 + engine/src/flutter/libs/minikin/Layout.cpp | 60 +-- .../src/flutter/libs/minikin/LayoutUtils.cpp | 76 +++ engine/src/flutter/libs/minikin/LayoutUtils.h | 42 ++ engine/src/flutter/tests/Android.mk | 3 + engine/src/flutter/tests/LayoutUtilsTest.cpp | 510 ++++++++++++++++++ 6 files changed, 638 insertions(+), 54 deletions(-) create mode 100644 engine/src/flutter/libs/minikin/LayoutUtils.cpp create mode 100644 engine/src/flutter/libs/minikin/LayoutUtils.h create mode 100644 engine/src/flutter/tests/LayoutUtilsTest.cpp diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index e2b588c19c..765a3ddfd7 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -24,6 +24,7 @@ minikin_src_files := \ GraphemeBreak.cpp \ Hyphenator.cpp \ Layout.cpp \ + LayoutUtils.cpp \ LineBreaker.cpp \ Measurement.cpp \ MinikinInternal.cpp \ diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 1b1ad1f296..b995a144cf 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -33,6 +33,7 @@ #include #include +#include "LayoutUtils.h" #include "MinikinInternal.h" #include #include @@ -468,56 +469,6 @@ static hb_script_t getScriptRun(const uint16_t* chars, size_t len, ssize_t* iter return current_script; } -/** - * For the purpose of layout, a word break is a boundary with no - * kerning or complex script processing. This is necessarily a - * heuristic, but should be accurate most of the time. - */ -static bool isWordBreak(int c) { - if (c == ' ' || (c >= 0x2000 && c <= 0x200a) || c == 0x3000) { - // spaces - return true; - } - if ((c >= 0x3400 && c <= 0x9fff)) { - // CJK ideographs (and yijing hexagram symbols) - return true; - } - // Note: kana is not included, as sophisticated fonts may kern kana - return false; -} - -/** - * Return offset of previous word break. It is either < offset or == 0. - */ -static size_t getPrevWordBreak(const uint16_t* chars, size_t offset) { - if (offset == 0) return 0; - if (isWordBreak(chars[offset - 1])) { - return offset - 1; - } - for (size_t i = offset - 1; i > 0; i--) { - if (isWordBreak(chars[i - 1])) { - return i; - } - } - return 0; -} - -/** - * Return offset of next word break. It is either > offset or == len. - */ -static size_t getNextWordBreak(const uint16_t* chars, size_t offset, size_t len) { - if (offset >= len) return len; - if (isWordBreak(chars[offset])) { - return offset + 1; - } - for (size_t i = offset + 1; i < len; i++) { - if (isWordBreak(chars[i])) { - return i; - } - } - return len; -} - /** * Disable certain scripts (mostly those with cursive connection) from having letterspacing * applied. See https://github.com/behdad/harfbuzz/issues/64 for more details. @@ -615,10 +566,11 @@ void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, HyphenEdit hyphen = ctx->paint.hyphenEdit; if (!isRtl) { // left to right - size_t wordstart = start == bufSize ? start : getPrevWordBreak(buf, start + 1); + size_t wordstart = + start == bufSize ? start : getPrevWordBreakForCache(buf, start + 1, bufSize); size_t wordend; for (size_t iter = start; iter < start + count; iter = wordend) { - wordend = getNextWordBreak(buf, iter, bufSize); + wordend = getNextWordBreakForCache(buf, iter, bufSize); // Only apply hyphen to the last word in the string. ctx->paint.hyphenEdit = wordend >= start + count ? hyphen : HyphenEdit(); size_t wordcount = std::min(start + count, wordend) - iter; @@ -630,9 +582,9 @@ void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, // right to left size_t wordstart; size_t end = start + count; - size_t wordend = end == 0 ? 0 : getNextWordBreak(buf, end - 1, bufSize); + size_t wordend = end == 0 ? 0 : getNextWordBreakForCache(buf, end - 1, bufSize); for (size_t iter = end; iter > start; iter = wordstart) { - wordstart = getPrevWordBreak(buf, iter); + wordstart = getPrevWordBreakForCache(buf, iter, bufSize); // Only apply hyphen to the last (leftmost) word in the string. ctx->paint.hyphenEdit = iter == end ? hyphen : HyphenEdit(); size_t bufStart = std::max(start, wordstart); diff --git a/engine/src/flutter/libs/minikin/LayoutUtils.cpp b/engine/src/flutter/libs/minikin/LayoutUtils.cpp new file mode 100644 index 0000000000..418268286c --- /dev/null +++ b/engine/src/flutter/libs/minikin/LayoutUtils.cpp @@ -0,0 +1,76 @@ +/* + * 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. + */ + +#define LOG_TAG "Minikin" + +#include "LayoutUtils.h" + +/** + * For the purpose of layout, a word break is a boundary with no + * kerning or complex script processing. This is necessarily a + * heuristic, but should be accurate most of the time. + */ +static bool isWordBreakAfter(int c) { + if (c == ' ' || (c >= 0x2000 && c <= 0x200a) || c == 0x3000) { + // spaces + return true; + } + // Note: kana is not included, as sophisticated fonts may kern kana + return false; +} + +static bool isWordBreakBefore(int c) { + // CJK ideographs (and yijing hexagram symbols) + return isWordBreakAfter(c) || (c >= 0x3400 && c <= 0x9fff); +} + +/** + * Return offset of previous word break. It is either < offset or == 0. + */ +size_t getPrevWordBreakForCache( + const uint16_t* chars, size_t offset, size_t len) { + if (offset == 0) return 0; + if (offset > len) offset = len; + if (isWordBreakBefore(chars[offset - 1])) { + return offset - 1; + } + for (size_t i = offset - 1; i > 0; i--) { + if (isWordBreakBefore(chars[i]) || isWordBreakAfter(chars[i - 1])) { + return i; + } + } + return 0; +} + +/** + * Return offset of next word break. It is either > offset or == len. + */ +size_t getNextWordBreakForCache( + const uint16_t* chars, size_t offset, size_t len) { + if (offset >= len) return len; + if (isWordBreakAfter(chars[offset])) { + return offset + 1; + } + for (size_t i = offset + 1; i < len; i++) { + // No need to check isWordBreakAfter(chars[i - 1]) since it is checked + // in previous iteration. Note that isWordBreakBefore returns true + // whenever isWordBreakAfter returns true. + if (isWordBreakBefore(chars[i])) { + return i; + } + } + return len; +} diff --git a/engine/src/flutter/libs/minikin/LayoutUtils.h b/engine/src/flutter/libs/minikin/LayoutUtils.h new file mode 100644 index 0000000000..83ddd0a255 --- /dev/null +++ b/engine/src/flutter/libs/minikin/LayoutUtils.h @@ -0,0 +1,42 @@ +/* + * 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. + */ + +#ifndef MINIKIN_LAYOUT_UTILS_H +#define MINIKIN_LAYOUT_UTILS_H + +#include + +/** + * Return offset of previous word break. It is either < offset or == 0. + * + * For the purpose of layout, a word break is a boundary with no + * kerning or complex script processing. This is necessarily a + * heuristic, but should be accurate most of the time. + */ +size_t getPrevWordBreakForCache( + const uint16_t* chars, size_t offset, size_t len); + +/** + * Return offset of next word break. It is either > offset or == len. + * + * For the purpose of layout, a word break is a boundary with no + * kerning or complex script processing. This is necessarily a + * heuristic, but should be accurate most of the time. + */ +size_t getNextWordBreakForCache( + const uint16_t* chars, size_t offset, size_t len); + +#endif // MINIKIN_LAYOUT_UTILS_H diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index ebce0eace3..00847e3b2a 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -36,6 +36,9 @@ LOCAL_SHARED_LIBRARIES := \ LOCAL_SRC_FILES += \ GraphemeBreakTests.cpp \ + LayoutUtilsTest.cpp \ UnicodeUtils.cpp +LOCAL_C_INCLUDES := $(LOCAL_PATH)/../libs/minikin/ + include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/LayoutUtilsTest.cpp b/engine/src/flutter/tests/LayoutUtilsTest.cpp new file mode 100644 index 0000000000..f4fbb18107 --- /dev/null +++ b/engine/src/flutter/tests/LayoutUtilsTest.cpp @@ -0,0 +1,510 @@ +/* + * 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. + */ + +#include +#include + +#include "LayoutUtils.h" + +namespace { + +void ExpectNextWordBreakForCache(size_t offset_in, const char* query_str) { + const size_t BUF_SIZE = 256U; + uint16_t buf[BUF_SIZE]; + size_t expected_breakpoint = 0U; + size_t size = 0U; + + ParseUnicode(buf, BUF_SIZE, query_str, &size, &expected_breakpoint); + EXPECT_EQ(expected_breakpoint, + getNextWordBreakForCache(buf, offset_in, size)) + << "Expected position is [" << query_str << "] from offset " << offset_in; +} + +void ExpectPrevWordBreakForCache(size_t offset_in, const char* query_str) { + const size_t BUF_SIZE = 256U; + uint16_t buf[BUF_SIZE]; + size_t expected_breakpoint = 0U; + size_t size = 0U; + + ParseUnicode(buf, BUF_SIZE, query_str, &size, &expected_breakpoint); + EXPECT_EQ(expected_breakpoint, + getPrevWordBreakForCache(buf, offset_in, size)) + << "Expected position is [" << query_str << "] from offset " << offset_in; +} + +TEST(WordBreakTest, goNextWordBreakTest) { + ExpectNextWordBreakForCache(0, "|"); + + // Continue for spaces. + ExpectNextWordBreakForCache(0, "'a' 'b' 'c' 'd' |"); + ExpectNextWordBreakForCache(1, "'a' 'b' 'c' 'd' |"); + ExpectNextWordBreakForCache(2, "'a' 'b' 'c' 'd' |"); + ExpectNextWordBreakForCache(3, "'a' 'b' 'c' 'd' |"); + ExpectNextWordBreakForCache(4, "'a' 'b' 'c' 'd' |"); + ExpectNextWordBreakForCache(1000, "'a' 'b' 'c' 'd' |"); + + // Space makes word break. + ExpectNextWordBreakForCache(0, "'a' 'b' | U+0020 'c' 'd'"); + ExpectNextWordBreakForCache(1, "'a' 'b' | U+0020 'c' 'd'"); + ExpectNextWordBreakForCache(2, "'a' 'b' U+0020 | 'c' 'd'"); + ExpectNextWordBreakForCache(3, "'a' 'b' U+0020 'c' 'd' |"); + ExpectNextWordBreakForCache(4, "'a' 'b' U+0020 'c' 'd' |"); + ExpectNextWordBreakForCache(5, "'a' 'b' U+0020 'c' 'd' |"); + ExpectNextWordBreakForCache(1000, "'a' 'b' U+0020 'c' 'd' |"); + + ExpectNextWordBreakForCache(0, "'a' 'b' | U+2000 'c' 'd'"); + ExpectNextWordBreakForCache(1, "'a' 'b' | U+2000 'c' 'd'"); + ExpectNextWordBreakForCache(2, "'a' 'b' U+2000 | 'c' 'd'"); + ExpectNextWordBreakForCache(3, "'a' 'b' U+2000 'c' 'd' |"); + ExpectNextWordBreakForCache(4, "'a' 'b' U+2000 'c' 'd' |"); + ExpectNextWordBreakForCache(5, "'a' 'b' U+2000 'c' 'd' |"); + ExpectNextWordBreakForCache(1000, "'a' 'b' U+2000 'c' 'd' |"); + + ExpectNextWordBreakForCache(0, "'a' 'b' | U+2000 U+2000 'c' 'd'"); + ExpectNextWordBreakForCache(1, "'a' 'b' | U+2000 U+2000 'c' 'd'"); + ExpectNextWordBreakForCache(2, "'a' 'b' U+2000 | U+2000 'c' 'd'"); + ExpectNextWordBreakForCache(3, "'a' 'b' U+2000 U+2000 | 'c' 'd'"); + ExpectNextWordBreakForCache(4, "'a' 'b' U+2000 U+2000 'c' 'd' |"); + ExpectNextWordBreakForCache(5, "'a' 'b' U+2000 U+2000 'c' 'd' |"); + ExpectNextWordBreakForCache(6, "'a' 'b' U+2000 U+2000 'c' 'd' |"); + ExpectNextWordBreakForCache(1000, "'a' 'b' U+2000 U+2000 'c' 'd' |"); + + // CJK ideographs makes word break. + ExpectNextWordBreakForCache(0, "U+4E00 | U+4E00 U+4E00 U+4E00 U+4E00"); + ExpectNextWordBreakForCache(1, "U+4E00 U+4E00 | U+4E00 U+4E00 U+4E00"); + ExpectNextWordBreakForCache(2, "U+4E00 U+4E00 U+4E00 | U+4E00 U+4E00"); + ExpectNextWordBreakForCache(3, "U+4E00 U+4E00 U+4E00 U+4E00 | U+4E00"); + ExpectNextWordBreakForCache(4, "U+4E00 U+4E00 U+4E00 U+4E00 U+4E00 |"); + ExpectNextWordBreakForCache(5, "U+4E00 U+4E00 U+4E00 U+4E00 U+4E00 |"); + ExpectNextWordBreakForCache(1000, + "U+4E00 U+4E00 U+4E00 U+4E00 U+4E00 |"); + + ExpectNextWordBreakForCache(0, "U+4E00 | U+4E8C U+4E09 U+56DB U+4E94"); + ExpectNextWordBreakForCache(1, "U+4E00 U+4E8C | U+4E09 U+56DB U+4E94"); + ExpectNextWordBreakForCache(2, "U+4E00 U+4E8C U+4E09 | U+56DB U+4E94"); + ExpectNextWordBreakForCache(3, "U+4E00 U+4E8C U+4E09 U+56DB | U+4E94"); + ExpectNextWordBreakForCache(4, "U+4E00 U+4E8C U+4E09 U+56DB U+4E94 |"); + ExpectNextWordBreakForCache(5, "U+4E00 U+4E8C U+4E09 U+56DB U+4E94 |"); + ExpectNextWordBreakForCache(1000, + "U+4E00 U+4E8C U+4E09 U+56DB U+4E94 |"); + + ExpectNextWordBreakForCache(0, "U+4E00 'a' 'b' | U+2000 'c' U+4E00"); + ExpectNextWordBreakForCache(1, "U+4E00 'a' 'b' | U+2000 'c' U+4E00"); + ExpectNextWordBreakForCache(2, "U+4E00 'a' 'b' | U+2000 'c' U+4E00"); + ExpectNextWordBreakForCache(3, "U+4E00 'a' 'b' U+2000 | 'c' U+4E00"); + ExpectNextWordBreakForCache(4, "U+4E00 'a' 'b' U+2000 'c' | U+4E00"); + ExpectNextWordBreakForCache(5, "U+4E00 'a' 'b' U+2000 'c' U+4E00 |"); + ExpectNextWordBreakForCache(1000, "U+4E00 'a' 'b' U+2000 'c' U+4E00 |"); + + // Continue if trailing characters is Unicode combining characters. + ExpectNextWordBreakForCache(0, "U+4E00 U+0332 | U+4E00"); + ExpectNextWordBreakForCache(1, "U+4E00 U+0332 | U+4E00"); + ExpectNextWordBreakForCache(2, "U+4E00 U+0332 U+4E00 |"); + ExpectNextWordBreakForCache(3, "U+4E00 U+0332 U+4E00 |"); + ExpectNextWordBreakForCache(1000, "U+4E00 U+0332 U+4E00 |"); + + // Surrogate pairs. + ExpectNextWordBreakForCache(0, "U+1F60D U+1F618 |"); + ExpectNextWordBreakForCache(1, "U+1F60D U+1F618 |"); + ExpectNextWordBreakForCache(2, "U+1F60D U+1F618 |"); + ExpectNextWordBreakForCache(3, "U+1F60D U+1F618 |"); + ExpectNextWordBreakForCache(4, "U+1F60D U+1F618 |"); + ExpectNextWordBreakForCache(1000, "U+1F60D U+1F618 |"); + + // Broken surrogate pairs. + // U+D84D is leading surrogate but there is no trailing surrogate for it. + ExpectNextWordBreakForCache(0, "U+D84D U+1F618 |"); + ExpectNextWordBreakForCache(1, "U+D84D U+1F618 |"); + ExpectNextWordBreakForCache(2, "U+D84D U+1F618 |"); + ExpectNextWordBreakForCache(3, "U+D84D U+1F618 |"); + ExpectNextWordBreakForCache(1000, "U+D84D U+1F618 |"); + + ExpectNextWordBreakForCache(0, "U+1F618 U+D84D |"); + ExpectNextWordBreakForCache(1, "U+1F618 U+D84D |"); + ExpectNextWordBreakForCache(2, "U+1F618 U+D84D |"); + ExpectNextWordBreakForCache(3, "U+1F618 U+D84D |"); + ExpectNextWordBreakForCache(1000, "U+1F618 U+D84D |"); + + // U+DE0D is trailing surrogate but there is no leading surrogate for it. + ExpectNextWordBreakForCache(0, "U+DE0D U+1F618 |"); + ExpectNextWordBreakForCache(1, "U+DE0D U+1F618 |"); + ExpectNextWordBreakForCache(2, "U+DE0D U+1F618 |"); + ExpectNextWordBreakForCache(3, "U+DE0D U+1F618 |"); + ExpectNextWordBreakForCache(1000, "U+DE0D U+1F618 |"); + + ExpectNextWordBreakForCache(0, "U+1F618 U+DE0D |"); + ExpectNextWordBreakForCache(1, "U+1F618 U+DE0D |"); + ExpectNextWordBreakForCache(2, "U+1F618 U+DE0D |"); + ExpectNextWordBreakForCache(3, "U+1F618 U+DE0D |"); + ExpectNextWordBreakForCache(1000, "U+1F618 U+DE0D |"); + + // Regional indicator pair. U+1F1FA U+1F1F8 is US national flag. + ExpectNextWordBreakForCache(0, "U+1F1FA U+1F1F8 |"); + ExpectNextWordBreakForCache(1, "U+1F1FA U+1F1F8 |"); + ExpectNextWordBreakForCache(2, "U+1F1FA U+1F1F8 |"); + ExpectNextWordBreakForCache(1000, "U+1F1FA U+1F1F8 |"); + + // Tone marks. + // CJK ideographic char + Tone mark + CJK ideographic char + ExpectNextWordBreakForCache(0, "U+4444 U+302D | U+4444"); + ExpectNextWordBreakForCache(1, "U+4444 U+302D | U+4444"); + ExpectNextWordBreakForCache(2, "U+4444 U+302D U+4444 |"); + ExpectNextWordBreakForCache(3, "U+4444 U+302D U+4444 |"); + ExpectNextWordBreakForCache(1000, "U+4444 U+302D U+4444 |"); + + // Variation Selectors. + // CJK Ideographic char + Variation Selector(VS1) + CJK Ideographic char + ExpectNextWordBreakForCache(0, "U+845B U+FE00 | U+845B"); + ExpectNextWordBreakForCache(1, "U+845B U+FE00 | U+845B"); + ExpectNextWordBreakForCache(2, "U+845B U+FE00 U+845B |"); + ExpectNextWordBreakForCache(3, "U+845B U+FE00 U+845B |"); + ExpectNextWordBreakForCache(1000, "U+845B U+FE00 U+845B |"); + + // CJK Ideographic char + Variation Selector(VS17) + CJK Ideographic char + ExpectNextWordBreakForCache(0, "U+845B U+E0100 | U+845B"); + ExpectNextWordBreakForCache(1, "U+845B U+E0100 | U+845B"); + ExpectNextWordBreakForCache(2, "U+845B U+E0100 | U+845B"); + ExpectNextWordBreakForCache(3, "U+845B U+E0100 U+845B |"); + ExpectNextWordBreakForCache(4, "U+845B U+E0100 U+845B |"); + ExpectNextWordBreakForCache(5, "U+845B U+E0100 U+845B |"); + ExpectNextWordBreakForCache(1000, "U+845B U+E0100 U+845B |"); + + // CJK ideographic char + Tone mark + Variation Character(VS1) + ExpectNextWordBreakForCache(0, "U+4444 U+302D U+FE00 | U+4444"); + ExpectNextWordBreakForCache(1, "U+4444 U+302D U+FE00 | U+4444"); + ExpectNextWordBreakForCache(2, "U+4444 U+302D U+FE00 | U+4444"); + ExpectNextWordBreakForCache(3, "U+4444 U+302D U+FE00 U+4444 |"); + ExpectNextWordBreakForCache(4, "U+4444 U+302D U+FE00 U+4444 |"); + ExpectNextWordBreakForCache(1000, "U+4444 U+302D U+FE00 U+4444 |"); + + // CJK ideographic char + Tone mark + Variation Character(VS17) + ExpectNextWordBreakForCache(0, "U+4444 U+302D U+E0100 | U+4444"); + ExpectNextWordBreakForCache(1, "U+4444 U+302D U+E0100 | U+4444"); + ExpectNextWordBreakForCache(2, "U+4444 U+302D U+E0100 | U+4444"); + ExpectNextWordBreakForCache(3, "U+4444 U+302D U+E0100 | U+4444"); + ExpectNextWordBreakForCache(4, "U+4444 U+302D U+E0100 U+4444 |"); + ExpectNextWordBreakForCache(5, "U+4444 U+302D U+E0100 U+4444 |"); + ExpectNextWordBreakForCache(1000, "U+4444 U+302D U+E0100 U+4444 |"); + + // CJK ideographic char + Variation Character(VS1) + Tone mark + ExpectNextWordBreakForCache(0, "U+4444 U+FE00 U+302D | U+4444"); + ExpectNextWordBreakForCache(1, "U+4444 U+FE00 U+302D | U+4444"); + ExpectNextWordBreakForCache(2, "U+4444 U+FE00 U+302D | U+4444"); + ExpectNextWordBreakForCache(3, "U+4444 U+FE00 U+302D U+4444 |"); + ExpectNextWordBreakForCache(4, "U+4444 U+FE00 U+302D U+4444 |"); + ExpectNextWordBreakForCache(1000, "U+4444 U+FE00 U+302D U+4444 |"); + + // CJK ideographic char + Variation Character(VS17) + Tone mark + ExpectNextWordBreakForCache(0, "U+4444 U+E0100 U+302D | U+4444"); + ExpectNextWordBreakForCache(1, "U+4444 U+E0100 U+302D | U+4444"); + ExpectNextWordBreakForCache(2, "U+4444 U+E0100 U+302D | U+4444"); + ExpectNextWordBreakForCache(3, "U+4444 U+E0100 U+302D | U+4444"); + ExpectNextWordBreakForCache(4, "U+4444 U+E0100 U+302D U+4444 |"); + ExpectNextWordBreakForCache(5, "U+4444 U+E0100 U+302D U+4444 |"); + ExpectNextWordBreakForCache(1000, "U+4444 U+E0100 U+302D U+4444 |"); + + // Following test cases are unusual usage of variation selectors and tone + // marks for caching up the further behavior changes, e.g. index of bounds + // or crashes. Please feel free to update the test expectations if the + // behavior change makes sense to you. + + // Isolated Tone marks and Variation Selectors + ExpectNextWordBreakForCache(0, "U+FE00 |"); + ExpectNextWordBreakForCache(1, "U+FE00 |"); + ExpectNextWordBreakForCache(1000, "U+FE00 |"); + ExpectNextWordBreakForCache(0, "U+E0100 |"); + ExpectNextWordBreakForCache(1000, "U+E0100 |"); + ExpectNextWordBreakForCache(0, "U+302D |"); + ExpectNextWordBreakForCache(1000, "U+302D |"); + + // CJK Ideographic char + Variation Selector(VS1) + Variation Selector(VS1) + ExpectNextWordBreakForCache(0, "U+845B U+FE00 U+FE00 | U+845B"); + ExpectNextWordBreakForCache(1, "U+845B U+FE00 U+FE00 | U+845B"); + ExpectNextWordBreakForCache(2, "U+845B U+FE00 U+FE00 | U+845B"); + ExpectNextWordBreakForCache(3, "U+845B U+FE00 U+FE00 U+845B |"); + ExpectNextWordBreakForCache(4, "U+845B U+FE00 U+FE00 U+845B |"); + ExpectNextWordBreakForCache(1000, "U+845B U+FE00 U+FE00 U+845B |"); + + // CJK Ideographic char + Variation Selector(VS17) + Variation Selector(VS17) + ExpectNextWordBreakForCache(0, "U+845B U+E0100 U+E0100 | U+845B"); + ExpectNextWordBreakForCache(1, "U+845B U+E0100 U+E0100 | U+845B"); + ExpectNextWordBreakForCache(2, "U+845B U+E0100 U+E0100 | U+845B"); + ExpectNextWordBreakForCache(3, "U+845B U+E0100 U+E0100 | U+845B"); + ExpectNextWordBreakForCache(4, "U+845B U+E0100 U+E0100 | U+845B"); + ExpectNextWordBreakForCache(5, "U+845B U+E0100 U+E0100 U+845B |"); + ExpectNextWordBreakForCache(6, "U+845B U+E0100 U+E0100 U+845B |"); + ExpectNextWordBreakForCache(1000, + "U+845B U+E0100 U+E0100 U+845B |"); + + // CJK Ideographic char + Variation Selector(VS1) + Variation Selector(VS17) + ExpectNextWordBreakForCache(0, "U+845B U+FE00 U+E0100 | U+845B"); + ExpectNextWordBreakForCache(1, "U+845B U+FE00 U+E0100 | U+845B"); + ExpectNextWordBreakForCache(2, "U+845B U+FE00 U+E0100 | U+845B"); + ExpectNextWordBreakForCache(3, "U+845B U+FE00 U+E0100 | U+845B"); + ExpectNextWordBreakForCache(4, "U+845B U+FE00 U+E0100 U+845B |"); + ExpectNextWordBreakForCache(5, "U+845B U+FE00 U+E0100 U+845B |"); + ExpectNextWordBreakForCache(1000, "U+845B U+FE00 U+E0100 U+845B |"); + + // CJK Ideographic char + Variation Selector(VS17) + Variation Selector(VS1) + ExpectNextWordBreakForCache(0, "U+845B U+E0100 U+FE00 | U+845B"); + ExpectNextWordBreakForCache(1, "U+845B U+E0100 U+FE00 | U+845B"); + ExpectNextWordBreakForCache(2, "U+845B U+E0100 U+FE00 | U+845B"); + ExpectNextWordBreakForCache(3, "U+845B U+E0100 U+FE00 | U+845B"); + ExpectNextWordBreakForCache(4, "U+845B U+E0100 U+FE00 U+845B |"); + ExpectNextWordBreakForCache(5, "U+845B U+E0100 U+FE00 U+845B |"); + ExpectNextWordBreakForCache(1000, "U+845B U+E0100 U+FE00 U+845B |"); + + // Tone mark. + Tone mark + ExpectNextWordBreakForCache(0, "U+4444 U+302D U+302D | U+4444"); + ExpectNextWordBreakForCache(1, "U+4444 U+302D U+302D | U+4444"); + ExpectNextWordBreakForCache(2, "U+4444 U+302D U+302D | U+4444"); + ExpectNextWordBreakForCache(3, "U+4444 U+302D U+302D U+4444 |"); + ExpectNextWordBreakForCache(4, "U+4444 U+302D U+302D U+4444 |"); + ExpectNextWordBreakForCache(1000, "U+4444 U+302D U+302D U+4444 |"); +} + +TEST(WordBreakTest, goPrevWordBreakTest) { + ExpectPrevWordBreakForCache(0, "|"); + + // Continue for spaces. + ExpectPrevWordBreakForCache(0, "| 'a' 'b' 'c' 'd'"); + ExpectPrevWordBreakForCache(1, "| 'a' 'b' 'c' 'd'"); + ExpectPrevWordBreakForCache(2, "| 'a' 'b' 'c' 'd'"); + ExpectPrevWordBreakForCache(3, "| 'a' 'b' 'c' 'd'"); + ExpectPrevWordBreakForCache(4, "| 'a' 'b' 'c' 'd'"); + ExpectPrevWordBreakForCache(1000, "| 'a' 'b' 'c' 'd'"); + + // Space makes word break. + ExpectPrevWordBreakForCache(0, "| 'a' 'b' U+0020 'c' 'd'"); + ExpectPrevWordBreakForCache(1, "| 'a' 'b' U+0020 'c' 'd'"); + ExpectPrevWordBreakForCache(2, "| 'a' 'b' U+0020 'c' 'd'"); + ExpectPrevWordBreakForCache(3, "'a' 'b' | U+0020 'c' 'd'"); + ExpectPrevWordBreakForCache(4, "'a' 'b' U+0020 | 'c' 'd'"); + ExpectPrevWordBreakForCache(5, "'a' 'b' U+0020 | 'c' 'd'"); + ExpectPrevWordBreakForCache(1000, "'a' 'b' U+0020 | 'c' 'd'"); + + ExpectPrevWordBreakForCache(0, "| 'a' 'b' U+2000 'c' 'd'"); + ExpectPrevWordBreakForCache(1, "| 'a' 'b' U+2000 'c' 'd'"); + ExpectPrevWordBreakForCache(2, "| 'a' 'b' U+2000 'c' 'd'"); + ExpectPrevWordBreakForCache(3, "'a' 'b' | U+2000 'c' 'd'"); + ExpectPrevWordBreakForCache(4, "'a' 'b' U+2000 | 'c' 'd'"); + ExpectPrevWordBreakForCache(5, "'a' 'b' U+2000 | 'c' 'd'"); + ExpectPrevWordBreakForCache(1000, "'a' 'b' U+2000 | 'c' 'd'"); + + ExpectPrevWordBreakForCache(0, "| 'a' 'b' U+2000 U+2000 'c' 'd'"); + ExpectPrevWordBreakForCache(1, "| 'a' 'b' U+2000 U+2000 'c' 'd'"); + ExpectPrevWordBreakForCache(2, "| 'a' 'b' U+2000 U+2000 'c' 'd'"); + ExpectPrevWordBreakForCache(3, "'a' 'b' | U+2000 U+2000 'c' 'd'"); + ExpectPrevWordBreakForCache(4, "'a' 'b' U+2000 | U+2000 'c' 'd'"); + ExpectPrevWordBreakForCache(5, "'a' 'b' U+2000 U+2000 | 'c' 'd'"); + ExpectPrevWordBreakForCache(6, "'a' 'b' U+2000 U+2000 | 'c' 'd'"); + ExpectPrevWordBreakForCache(1000, "'a' 'b' U+2000 U+2000 | 'c' 'd'"); + + // CJK ideographs makes word break. + ExpectPrevWordBreakForCache(0, "| U+4E00 U+4E00 U+4E00 U+4E00 U+4E00"); + ExpectPrevWordBreakForCache(1, "| U+4E00 U+4E00 U+4E00 U+4E00 U+4E00"); + ExpectPrevWordBreakForCache(2, "U+4E00 | U+4E00 U+4E00 U+4E00 U+4E00"); + ExpectPrevWordBreakForCache(3, "U+4E00 U+4E00 | U+4E00 U+4E00 U+4E00"); + ExpectPrevWordBreakForCache(4, "U+4E00 U+4E00 U+4E00 | U+4E00 U+4E00"); + ExpectPrevWordBreakForCache(5, "U+4E00 U+4E00 U+4E00 U+4E00 | U+4E00"); + ExpectPrevWordBreakForCache(1000, "U+4E00 U+4E00 U+4E00 U+4E00 | U+4E00"); + + ExpectPrevWordBreakForCache(0, "| U+4E00 U+4E8C U+4E09 U+56DB U+4E94"); + ExpectPrevWordBreakForCache(1, "| U+4E00 U+4E8C U+4E09 U+56DB U+4E94"); + ExpectPrevWordBreakForCache(2, "U+4E00 | U+4E8C U+4E09 U+56DB U+4E94"); + ExpectPrevWordBreakForCache(3, "U+4E00 U+4E8C | U+4E09 U+56DB U+4E94"); + ExpectPrevWordBreakForCache(4, "U+4E00 U+4E8C U+4E09 | U+56DB U+4E94"); + ExpectPrevWordBreakForCache(5, "U+4E00 U+4E8C U+4E09 U+56DB | U+4E94"); + ExpectPrevWordBreakForCache(1000, "U+4E00 U+4E8C U+4E09 U+56DB | U+4E94"); + + // Mixed case. + ExpectPrevWordBreakForCache(0, "| U+4E00 'a' 'b' U+2000 'c' U+4E00"); + ExpectPrevWordBreakForCache(1, "| U+4E00 'a' 'b' U+2000 'c' U+4E00"); + ExpectPrevWordBreakForCache(2, "| U+4E00 'a' 'b' U+2000 'c' U+4E00"); + ExpectPrevWordBreakForCache(3, "| U+4E00 'a' 'b' U+2000 'c' U+4E00"); + ExpectPrevWordBreakForCache(4, "U+4E00 'a' 'b' | U+2000 'c' U+4E00"); + ExpectPrevWordBreakForCache(5, "U+4E00 'a' 'b' U+2000 | 'c' U+4E00"); + ExpectPrevWordBreakForCache(6, "U+4E00 'a' 'b' U+2000 'c' | U+4E00"); + ExpectPrevWordBreakForCache(1000, "U+4E00 'a' 'b' U+2000 'c' | U+4E00"); + + // Continue if trailing characters is Unicode combining characters. + ExpectPrevWordBreakForCache(0, "| U+4E00 U+0332 U+4E00"); + ExpectPrevWordBreakForCache(1, "| U+4E00 U+0332 U+4E00"); + ExpectPrevWordBreakForCache(2, "| U+4E00 U+0332 U+4E00"); + ExpectPrevWordBreakForCache(3, "U+4E00 U+0332 | U+4E00"); + ExpectPrevWordBreakForCache(1000, "U+4E00 U+0332 | U+4E00"); + + // Surrogate pairs. + ExpectPrevWordBreakForCache(0, "| U+1F60D U+1F618"); + ExpectPrevWordBreakForCache(1, "| U+1F60D U+1F618"); + ExpectPrevWordBreakForCache(2, "| U+1F60D U+1F618"); + ExpectPrevWordBreakForCache(3, "| U+1F60D U+1F618"); + ExpectPrevWordBreakForCache(4, "| U+1F60D U+1F618"); + ExpectPrevWordBreakForCache(1000, "| U+1F60D U+1F618"); + + // Broken surrogate pairs. + // U+D84D is leading surrogate but there is no trailing surrogate for it. + ExpectPrevWordBreakForCache(0, "| U+D84D U+1F618"); + ExpectPrevWordBreakForCache(1, "| U+D84D U+1F618"); + ExpectPrevWordBreakForCache(2, "| U+D84D U+1F618"); + ExpectPrevWordBreakForCache(3, "| U+D84D U+1F618"); + ExpectPrevWordBreakForCache(1000, "| U+D84D U+1F618"); + + ExpectPrevWordBreakForCache(0, "| U+1F618 U+D84D"); + ExpectPrevWordBreakForCache(1, "| U+1F618 U+D84D"); + ExpectPrevWordBreakForCache(2, "| U+1F618 U+D84D"); + ExpectPrevWordBreakForCache(3, "| U+1F618 U+D84D"); + ExpectPrevWordBreakForCache(1000, "| U+1F618 U+D84D"); + + // U+DE0D is trailing surrogate but there is no leading surrogate for it. + ExpectPrevWordBreakForCache(0, "| U+DE0D U+1F618"); + ExpectPrevWordBreakForCache(1, "| U+DE0D U+1F618"); + ExpectPrevWordBreakForCache(2, "| U+DE0D U+1F618"); + ExpectPrevWordBreakForCache(3, "| U+DE0D U+1F618"); + ExpectPrevWordBreakForCache(1000, "| U+DE0D U+1F618"); + + ExpectPrevWordBreakForCache(0, "| U+1F618 U+DE0D"); + ExpectPrevWordBreakForCache(1, "| U+1F618 U+DE0D"); + ExpectPrevWordBreakForCache(2, "| U+1F618 U+DE0D"); + ExpectPrevWordBreakForCache(3, "| U+1F618 U+DE0D"); + ExpectPrevWordBreakForCache(1000, "| U+1F618 U+DE0D"); + + // Regional indicator pair. U+1F1FA U+1F1F8 is US national flag. + ExpectPrevWordBreakForCache(0, "| U+1F1FA U+1F1F8"); + ExpectPrevWordBreakForCache(1, "| U+1F1FA U+1F1F8"); + ExpectPrevWordBreakForCache(2, "| U+1F1FA U+1F1F8"); + ExpectPrevWordBreakForCache(1000, "| U+1F1FA U+1F1F8"); + + // Tone marks. + // CJK ideographic char + Tone mark + CJK ideographic char + ExpectPrevWordBreakForCache(0, "| U+4444 U+302D U+4444"); + ExpectPrevWordBreakForCache(1, "| U+4444 U+302D U+4444"); + ExpectPrevWordBreakForCache(2, "| U+4444 U+302D U+4444"); + ExpectPrevWordBreakForCache(3, "U+4444 U+302D | U+4444"); + ExpectPrevWordBreakForCache(1000, "U+4444 U+302D | U+4444"); + + // Variation Selectors. + // CJK Ideographic char + Variation Selector(VS1) + CJK Ideographic char + ExpectPrevWordBreakForCache(0, "| U+845B U+FE00 U+845B"); + ExpectPrevWordBreakForCache(1, "| U+845B U+FE00 U+845B"); + ExpectPrevWordBreakForCache(2, "| U+845B U+FE00 U+845B"); + ExpectPrevWordBreakForCache(3, "U+845B U+FE00 | U+845B"); + ExpectPrevWordBreakForCache(1000, "U+845B U+FE00 | U+845B"); + + // CJK Ideographic char + Variation Selector(VS17) + CJK Ideographic char + ExpectPrevWordBreakForCache(0, "| U+845B U+E0100 U+845B"); + ExpectPrevWordBreakForCache(1, "| U+845B U+E0100 U+845B"); + ExpectPrevWordBreakForCache(2, "| U+845B U+E0100 U+845B"); + ExpectPrevWordBreakForCache(3, "| U+845B U+E0100 U+845B"); + ExpectPrevWordBreakForCache(4, "U+845B U+E0100 | U+845B"); + ExpectPrevWordBreakForCache(5, "U+845B U+E0100 | U+845B"); + ExpectPrevWordBreakForCache(1000, "U+845B U+E0100 | U+845B"); + + // CJK ideographic char + Tone mark + Variation Character(VS1) + ExpectPrevWordBreakForCache(0, "| U+4444 U+302D U+FE00 U+4444"); + ExpectPrevWordBreakForCache(1, "| U+4444 U+302D U+FE00 U+4444"); + ExpectPrevWordBreakForCache(2, "| U+4444 U+302D U+FE00 U+4444"); + ExpectPrevWordBreakForCache(3, "| U+4444 U+302D U+FE00 U+4444"); + ExpectPrevWordBreakForCache(4, "U+4444 U+302D U+FE00 | U+4444"); + ExpectPrevWordBreakForCache(1000, "U+4444 U+302D U+FE00 | U+4444"); + + // CJK ideographic char + Tone mark + Variation Character(VS17) + ExpectPrevWordBreakForCache(0, "| U+4444 U+302D U+E0100 U+4444"); + ExpectPrevWordBreakForCache(1, "| U+4444 U+302D U+E0100 U+4444"); + ExpectPrevWordBreakForCache(2, "| U+4444 U+302D U+E0100 U+4444"); + ExpectPrevWordBreakForCache(3, "| U+4444 U+302D U+E0100 U+4444"); + ExpectPrevWordBreakForCache(4, "| U+4444 U+302D U+E0100 U+4444"); + ExpectPrevWordBreakForCache(5, "U+4444 U+302D U+E0100 | U+4444"); + ExpectPrevWordBreakForCache(1000, "U+4444 U+302D U+E0100 | U+4444"); + + // CJK ideographic char + Variation Character(VS1) + Tone mark + ExpectPrevWordBreakForCache(0, "| U+4444 U+FE00 U+302D U+4444"); + ExpectPrevWordBreakForCache(1, "| U+4444 U+FE00 U+302D U+4444"); + ExpectPrevWordBreakForCache(2, "| U+4444 U+FE00 U+302D U+4444"); + ExpectPrevWordBreakForCache(3, "| U+4444 U+FE00 U+302D U+4444"); + ExpectPrevWordBreakForCache(4, "U+4444 U+FE00 U+302D | U+4444"); + ExpectPrevWordBreakForCache(1000, "U+4444 U+FE00 U+302D | U+4444"); + + // CJK ideographic char + Variation Character(VS17) + Tone mark + ExpectPrevWordBreakForCache(0, "| U+4444 U+E0100 U+302D U+4444"); + ExpectPrevWordBreakForCache(1, "| U+4444 U+E0100 U+302D U+4444"); + ExpectPrevWordBreakForCache(2, "| U+4444 U+E0100 U+302D U+4444"); + ExpectPrevWordBreakForCache(3, "| U+4444 U+E0100 U+302D U+4444"); + ExpectPrevWordBreakForCache(4, "| U+4444 U+E0100 U+302D U+4444"); + ExpectPrevWordBreakForCache(5, "U+4444 U+E0100 U+302D | U+4444"); + ExpectPrevWordBreakForCache(1000, "U+4444 U+E0100 U+302D | U+4444"); + + // Following test cases are unusual usage of variation selectors and tone + // marks for caching up the further behavior changes, e.g. index of bounds + // or crashes. Please feel free to update the test expectations if the + // behavior change makes sense to you. + + // Isolated Tone marks and Variation Selectors + ExpectPrevWordBreakForCache(0, "| U+FE00"); + ExpectPrevWordBreakForCache(1, "| U+FE00"); + ExpectPrevWordBreakForCache(1000, "| U+FE00"); + ExpectPrevWordBreakForCache(0, "| U+E0100"); + ExpectPrevWordBreakForCache(1000, "| U+E0100"); + ExpectPrevWordBreakForCache(0, "| U+302D"); + ExpectPrevWordBreakForCache(1000, "| U+302D"); + + // CJK Ideographic char + Variation Selector(VS1) + Variation Selector(VS1) + ExpectPrevWordBreakForCache(0, "| U+845B U+FE00 U+FE00 U+845B"); + ExpectPrevWordBreakForCache(1, "| U+845B U+FE00 U+FE00 U+845B"); + ExpectPrevWordBreakForCache(2, "| U+845B U+FE00 U+FE00 U+845B"); + ExpectPrevWordBreakForCache(3, "| U+845B U+FE00 U+FE00 U+845B"); + ExpectPrevWordBreakForCache(4, "U+845B U+FE00 U+FE00 | U+845B"); + ExpectPrevWordBreakForCache(1000, "U+845B U+FE00 U+FE00 | U+845B"); + + // CJK Ideographic char + Variation Selector(VS17) + Variation Selector(VS17) + ExpectPrevWordBreakForCache(0, "| U+845B U+E0100 U+E0100 U+845B"); + ExpectPrevWordBreakForCache(1, "| U+845B U+E0100 U+E0100 U+845B"); + ExpectPrevWordBreakForCache(2, "| U+845B U+E0100 U+E0100 U+845B"); + ExpectPrevWordBreakForCache(3, "| U+845B U+E0100 U+E0100 U+845B"); + ExpectPrevWordBreakForCache(4, "| U+845B U+E0100 U+E0100 U+845B"); + ExpectPrevWordBreakForCache(5, "| U+845B U+E0100 U+E0100 U+845B"); + ExpectPrevWordBreakForCache(6, "U+845B U+E0100 U+E0100 | U+845B"); + ExpectPrevWordBreakForCache(1000, + "U+845B U+E0100 U+E0100 | U+845B"); + + // CJK Ideographic char + Variation Selector(VS1) + Variation Selector(VS17) + ExpectPrevWordBreakForCache(0, "| U+845B U+FE00 U+E0100 U+845B"); + ExpectPrevWordBreakForCache(1, "| U+845B U+FE00 U+E0100 U+845B"); + ExpectPrevWordBreakForCache(2, "| U+845B U+FE00 U+E0100 U+845B"); + ExpectPrevWordBreakForCache(3, "| U+845B U+FE00 U+E0100 U+845B"); + ExpectPrevWordBreakForCache(4, "| U+845B U+FE00 U+E0100 U+845B"); + ExpectPrevWordBreakForCache(5, "U+845B U+FE00 U+E0100 | U+845B"); + ExpectPrevWordBreakForCache(1000, "U+845B U+FE00 U+E0100 | U+845B"); + + // CJK Ideographic char + Variation Selector(VS17) + Variation Selector(VS1) + ExpectPrevWordBreakForCache(0, "| U+845B U+E0100 U+FE00 U+845B"); + ExpectPrevWordBreakForCache(1, "| U+845B U+E0100 U+FE00 U+845B"); + ExpectPrevWordBreakForCache(2, "| U+845B U+E0100 U+FE00 U+845B"); + ExpectPrevWordBreakForCache(3, "| U+845B U+E0100 U+FE00 U+845B"); + ExpectPrevWordBreakForCache(4, "| U+845B U+E0100 U+FE00 U+845B"); + ExpectPrevWordBreakForCache(5, "U+845B U+E0100 U+FE00 | U+845B"); + ExpectPrevWordBreakForCache(1000, "U+845B U+E0100 U+FE00 | U+845B"); + + // Tone mark. + Tone mark + ExpectPrevWordBreakForCache(0, "| U+4444 U+302D U+302D U+4444"); + ExpectPrevWordBreakForCache(1, "| U+4444 U+302D U+302D U+4444"); + ExpectPrevWordBreakForCache(2, "| U+4444 U+302D U+302D U+4444"); + ExpectPrevWordBreakForCache(3, "| U+4444 U+302D U+302D U+4444"); + ExpectPrevWordBreakForCache(4, "U+4444 U+302D U+302D | U+4444"); + ExpectPrevWordBreakForCache(1000, "U+4444 U+302D U+302D | U+4444"); +} + +} // namespace From 0345da636e985fd6975642099cb7ba4b05b4e3a6 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 1 Sep 2015 15:16:19 +0900 Subject: [PATCH 102/364] Resolve glyph ID by HarfBuzz function. Currently codepoint to glyph ID resolution is done through MinikinFont interface. To support variation selector, use HarfBuzz API instead of calling this interface since one of its implementation Skia doesn't support variation selector. On the other hand, we don't want to get glyph horizontal advance values by HarfBuzz since HarfBuzz doesn't return correct values when the hinting is active. Thus, use ot_font as a parent font and override glyph_h_advance/glyph_h_origin functions as is. With this change, MinikinFont::GetGlyph is no longer necessary but not removing in this CL for easy reverting since removing interface requires multi-repository commit. This is a base work of b/11256006 and this patch doesn't provide any user visible changes. Bug: 11256006 Change-Id: I061172c0b674bb649ce8bc013ffecf38708bdc41 --- engine/src/flutter/libs/minikin/Layout.cpp | 24 +++++++++------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index b995a144cf..eaa2b7d2e1 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -32,6 +32,7 @@ #include #include +#include #include "LayoutUtils.h" #include "MinikinInternal.h" @@ -314,18 +315,6 @@ hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { HB_MEMORY_MODE_WRITABLE, buffer, free); } -static hb_bool_t harfbuzzGetGlyph(hb_font_t* hbFont, void* fontData, hb_codepoint_t unicode, hb_codepoint_t variationSelector, hb_codepoint_t* glyph, void* userData) -{ - MinikinPaint* paint = reinterpret_cast(fontData); - MinikinFont* font = paint->font; - uint32_t glyph_id; - bool ok = font->GetGlyph(unicode, &glyph_id); - if (ok) { - *glyph = glyph_id; - } - return ok; -} - static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, void* userData) { MinikinPaint* paint = reinterpret_cast(fontData); @@ -346,7 +335,6 @@ hb_font_funcs_t* getHbFontFuncs() { if (hbFontFuncs == 0) { hbFontFuncs = hb_font_funcs_create(); - hb_font_funcs_set_glyph_func(hbFontFuncs, harfbuzzGetGlyph, 0, 0); hb_font_funcs_set_glyph_h_advance_func(hbFontFuncs, harfbuzzGetGlyphHorizontalAdvance, 0, 0); hb_font_funcs_set_glyph_h_origin_func(hbFontFuncs, harfbuzzGetGlyphHorizontalOrigin, 0, 0); hb_font_funcs_make_immutable(hbFontFuncs); @@ -367,7 +355,15 @@ static hb_face_t* getHbFace(MinikinFont* minikinFont) { static hb_font_t* create_hb_font(MinikinFont* minikinFont, MinikinPaint* minikinPaint) { hb_face_t* face = getHbFace(minikinFont); - hb_font_t* font = hb_font_create(face); + hb_font_t* parent_font = hb_font_create(face); + hb_ot_font_set_funcs(parent_font); + + unsigned int upem = hb_face_get_upem(face); + hb_font_set_scale(parent_font, upem, upem); + + hb_font_t* font = hb_font_create_sub_font(parent_font); + hb_font_destroy(parent_font); + hb_font_set_funcs(font, getHbFontFuncs(), minikinPaint, 0); return font; } From 5debe07231d79a17821af4ded508970398b65c0e Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Wed, 16 Sep 2015 20:31:35 +0900 Subject: [PATCH 103/364] Introduce unit tests for FontCollection::itemize. Introduced tests depend on installed font list in running device. I verified these test passed on Nexus 5(hammerhead), Nexus 6(shamu) and Nexus 9(volantis). Bug: 11256006 Bug: 17759267 Change-Id: I6f806370e17f6c6d3dad8df0cb70bb475a827873 --- engine/src/flutter/tests/Android.mk | 20 +- .../tests/FontCollectionItemizeTest.cpp | 343 ++++++++++++++++++ engine/src/flutter/tests/FontTestUtils.cpp | 81 +++++ engine/src/flutter/tests/FontTestUtils.h | 30 ++ .../src/flutter/tests/MinikinFontForTest.cpp | 62 ++++ engine/src/flutter/tests/MinikinFontForTest.h | 38 ++ 6 files changed, 569 insertions(+), 5 deletions(-) create mode 100644 engine/src/flutter/tests/FontCollectionItemizeTest.cpp create mode 100644 engine/src/flutter/tests/FontTestUtils.cpp create mode 100644 engine/src/flutter/tests/FontTestUtils.h create mode 100644 engine/src/flutter/tests/MinikinFontForTest.cpp create mode 100644 engine/src/flutter/tests/MinikinFontForTest.h diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index 00847e3b2a..680cbe9349 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -27,18 +27,28 @@ LOCAL_STATIC_LIBRARIES := libminikin # pulled in by the build system (and thus sadly must be repeated). LOCAL_SHARED_LIBRARIES := \ - libharfbuzz_ng \ + libskia \ libft2 \ - liblog \ - libz \ + libharfbuzz_ng \ libicuuc \ - libutils + liblog \ + libutils \ + libz + +LOCAL_STATIC_LIBRARIES += \ + libxml2 LOCAL_SRC_FILES += \ + FontCollectionItemizeTest.cpp \ + FontTestUtils.cpp \ + MinikinFontForTest.cpp \ GraphemeBreakTests.cpp \ LayoutUtilsTest.cpp \ UnicodeUtils.cpp -LOCAL_C_INCLUDES := $(LOCAL_PATH)/../libs/minikin/ +LOCAL_C_INCLUDES := \ + $(LOCAL_PATH)/../libs/minikin/ \ + external/libxml2/include \ + external/skia/src/core \ include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp new file mode 100644 index 0000000000..cabc967984 --- /dev/null +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -0,0 +1,343 @@ +/* + * 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. + */ + +#include + +#include "FontTestUtils.h" +#include "MinikinFontForTest.h" +#include "UnicodeUtils.h" + +using android::FontCollection; +using android::FontLanguage; +using android::FontStyle; + +const char kEmojiFont[] = "/system/fonts/NotoColorEmoji.ttf"; +const char kJAFont[] = "/system/fonts/NotoSansJP-Regular.otf"; +const char kKOFont[] = "/system/fonts/NotoSansKR-Regular.otf"; +const char kLatinBoldFont[] = "/system/fonts/Roboto-Bold.ttf"; +const char kLatinBoldItalicFont[] = "/system/fonts/Roboto-BoldItalic.ttf"; +const char kLatinFont[] = "/system/fonts/Roboto-Regular.ttf"; +const char kLatinItalicFont[] = "/system/fonts/Roboto-Italic.ttf"; +const char kZH_HansFont[] = "/system/fonts/NotoSansSC-Regular.otf"; +const char kZH_HantFont[] = "/system/fonts/NotoSansTC-Regular.otf"; + +// Utility function for calling itemize function. +void itemize(FontCollection* collection, const char* str, FontStyle style, + std::vector* result) { + const size_t BUF_SIZE = 256; + uint16_t buf[BUF_SIZE]; + size_t len; + + result->clear(); + ParseUnicode(buf, BUF_SIZE, str, &len, NULL); + collection->itemize(buf, len, style, result); +} + +// Utility function to obtain font path associated with run. +const std::string& getFontPath(const FontCollection::Run& run) { + return ((MinikinFontForTest*)run.fakedFont.font)->fontPath(); +} + +TEST(FontCollectionItemizeTest, itemize_latin) { + std::unique_ptr collection = getFontCollection(); + std::vector runs; + + const FontStyle kRegularStyle = FontStyle(); + const FontStyle kItalicStyle = FontStyle(4, true); + const FontStyle kBoldStyle = FontStyle(7, false); + const FontStyle kBoldItalicStyle = FontStyle(7, true); + + itemize(collection.get(), "'a' 'b' 'c' 'd' 'e'", kRegularStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + itemize(collection.get(), "'a' 'b' 'c' 'd' 'e'", kItalicStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kLatinItalicFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + itemize(collection.get(), "'a' 'b' 'c' 'd' 'e'", kBoldStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kLatinBoldFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + itemize(collection.get(), "'a' 'b' 'c' 'd' 'e'", kBoldItalicStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kLatinBoldItalicFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + // Continue if the specific characters (e.g. hyphen, comma, etc.) is + // followed. + itemize(collection.get(), "'a' ',' '-' 'd' '!'", kRegularStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + itemize(collection.get(), "'a' ',' '-' 'd' '!'", kRegularStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + // U+0301(COMBINING ACUTE ACCENT) must be in the same run with preceding + // chars if the font supports it. + itemize(collection.get(), "'a' U+0301", kRegularStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); +} + +TEST(FontCollectionItemizeTest, itemize_emoji) { + std::unique_ptr collection = getFontCollection(); + std::vector runs; + + itemize(collection.get(), "U+1F469 U+1F467", FontStyle(), &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(4, runs[0].end); + EXPECT_EQ(kEmojiFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + // U+20E3(COMBINING ENCLOSING KEYCAP) must be in the same run with preceding + // character if the font supports. + itemize(collection.get(), "'0' U+20E3", FontStyle(), &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kEmojiFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + // Currently there is no fonts which has a glyph for 'a' + U+20E3, so they + // are splitted into two. + itemize(collection.get(), "'a' U+20E3", FontStyle(), &runs); + ASSERT_EQ(2U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + EXPECT_EQ(1, runs[1].start); + EXPECT_EQ(2, runs[1].end); + EXPECT_EQ(kEmojiFont, getFontPath(runs[1])); + EXPECT_FALSE(runs[1].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[1].fakedFont.fakery.isFakeItalic()); +} + +TEST(FontCollectionItemizeTest, itemize_non_latin) { + std::unique_ptr collection = getFontCollection(); + std::vector runs; + + FontStyle kJAStyle = FontStyle(FontLanguage("ja_JP", 5)); + FontStyle kUSStyle = FontStyle(FontLanguage("en_US", 5)); + FontStyle kZH_HansStyle = FontStyle(FontLanguage("zh_Hans", 7)); + + // All Japanese Hiragana characters. + itemize(collection.get(), "U+3042 U+3044 U+3046 U+3048 U+304A", kUSStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + // All Korean Hangul characters. + itemize(collection.get(), "U+B300 U+D55C U+BBFC U+AD6D", kUSStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(4, runs[0].end); + EXPECT_EQ(kKOFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + // All Han characters ja, zh-Hans font having. + // Japanese font should be selected if the specified language is Japanese. + itemize(collection.get(), "U+81ED U+82B1 U+5FCD", kJAStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(3, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + // Simplified Chinese font should be selected if the specified language is Simplified + // Chinese. + itemize(collection.get(), "U+81ED U+82B1 U+5FCD", kZH_HansStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(3, runs[0].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + // Fallbacks to other fonts if there is no glyph in the specified language's + // font. There is no character U+4F60 in Japanese. + itemize(collection.get(), "U+81ED U+4F60 U+5FCD", kJAStyle, &runs); + ASSERT_EQ(3U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + EXPECT_EQ(1, runs[1].start); + EXPECT_EQ(2, runs[1].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[1])); + EXPECT_FALSE(runs[1].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[1].fakedFont.fakery.isFakeItalic()); + + EXPECT_EQ(2, runs[2].start); + EXPECT_EQ(3, runs[2].end); + EXPECT_EQ(kJAFont, getFontPath(runs[2])); + EXPECT_FALSE(runs[2].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[2].fakedFont.fakery.isFakeItalic()); + + // Tone mark. + itemize(collection.get(), "U+4444 U+302D", FontStyle(), &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); +} + +TEST(FontCollectionItemizeTest, itemize_mixed) { + std::unique_ptr collection = getFontCollection(); + std::vector runs; + + FontStyle kUSStyle = FontStyle(FontLanguage("en_US", 5)); + + itemize(collection.get(), "'a' U+4F60 'b' U+4F60 'c'", kUSStyle, &runs); + ASSERT_EQ(5U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + EXPECT_EQ(1, runs[1].start); + EXPECT_EQ(2, runs[1].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[1])); + EXPECT_FALSE(runs[1].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[1].fakedFont.fakery.isFakeItalic()); + + EXPECT_EQ(2, runs[2].start); + EXPECT_EQ(3, runs[2].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[2])); + EXPECT_FALSE(runs[2].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[2].fakedFont.fakery.isFakeItalic()); + + EXPECT_EQ(3, runs[3].start); + EXPECT_EQ(4, runs[3].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[3])); + EXPECT_FALSE(runs[3].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[3].fakedFont.fakery.isFakeItalic()); + + EXPECT_EQ(4, runs[4].start); + EXPECT_EQ(5, runs[4].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[4])); + EXPECT_FALSE(runs[4].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[4].fakedFont.fakery.isFakeItalic()); +} + +TEST(FontCollectionItemizeTest, itemize_no_crash) { + std::unique_ptr collection = getFontCollection(); + std::vector runs; + + // Broken Surrogate pairs. Check only not crashing. + itemize(collection.get(), "'a' U+D83D 'a'", FontStyle(), &runs); + itemize(collection.get(), "'a' U+DC69 'a'", FontStyle(), &runs); + itemize(collection.get(), "'a' U+D83D U+D83D 'a'", FontStyle(), &runs); + itemize(collection.get(), "'a' U+DC69 U+DC69 'a'", FontStyle(), &runs); + + // Isolated variation selector. Check only not crashing. + itemize(collection.get(), "U+FE00 U+FE00", FontStyle(), &runs); + itemize(collection.get(), "U+E0100 U+E0100", FontStyle(), &runs); + itemize(collection.get(), "U+FE00 U+E0100", FontStyle(), &runs); + itemize(collection.get(), "U+E0100 U+FE00", FontStyle(), &runs); + + // Tone mark only. Check only not crashing. + itemize(collection.get(), "U+302D", FontStyle(), &runs); + itemize(collection.get(), "U+302D U+302D", FontStyle(), &runs); + + // Tone mark and variation selector mixed. Check only not crashing. + itemize(collection.get(), "U+FE00 U+302D U+E0100", FontStyle(), &runs); +} + +TEST(FontCollectionItemizeTest, itemize_fakery) { + std::unique_ptr collection = getFontCollection(); + std::vector runs; + + FontStyle kJABoldStyle = FontStyle(FontLanguage("ja_JP", 5), 0, 7, false); + FontStyle kJAItalicStyle = FontStyle(FontLanguage("ja_JP", 5), 0, 5, true); + FontStyle kJABoldItalicStyle = FontStyle(FontLanguage("ja_JP", 5), 0, 7, true); + + // Currently there is no italic or bold font for Japanese. FontFakery has + // the differences between desired and actual font style. + + // All Japanese Hiragana characters. + itemize(collection.get(), "U+3042 U+3044 U+3046 U+3048 U+304A", kJABoldStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + EXPECT_TRUE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + // All Japanese Hiragana characters. + itemize(collection.get(), "U+3042 U+3044 U+3046 U+3048 U+304A", kJAItalicStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_TRUE(runs[0].fakedFont.fakery.isFakeItalic()); + + // All Japanese Hiragana characters. + itemize(collection.get(), "U+3042 U+3044 U+3046 U+3048 U+304A", kJABoldItalicStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + EXPECT_TRUE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_TRUE(runs[0].fakedFont.fakery.isFakeItalic()); +} + +// TODO(11256006): Add Variation Selector test cases once it is supported. diff --git a/engine/src/flutter/tests/FontTestUtils.cpp b/engine/src/flutter/tests/FontTestUtils.cpp new file mode 100644 index 0000000000..e5d6c2a448 --- /dev/null +++ b/engine/src/flutter/tests/FontTestUtils.cpp @@ -0,0 +1,81 @@ +/* + * 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. + */ + +#include + +#include +#include + +#include "MinikinFontForTest.h" + +const char kFontDir[] = "/system/fonts/"; +const char kFontXml[] = "/system/etc/fonts.xml"; + +std::unique_ptr getFontCollection() { + xmlDoc* doc = xmlReadFile(kFontXml, NULL, 0); + xmlNode* familySet = xmlDocGetRootElement(doc); + + std::vector families; + for (xmlNode* familyNode = familySet->children; familyNode; familyNode = familyNode->next) { + if (xmlStrcmp(familyNode->name, (const xmlChar*)"family") != 0) { + continue; + } + + xmlChar* variantXmlch = xmlGetProp(familyNode, (const xmlChar*)"variant"); + int variant = android::VARIANT_DEFAULT; + if (variantXmlch) { + if (xmlStrcmp(variantXmlch, (const xmlChar*)"elegant") == 0) { + variant = android::VARIANT_ELEGANT; + } else if (xmlStrcmp(variantXmlch, (const xmlChar*)"compact") == 0) { + variant = android::VARIANT_COMPACT; + } + } + + xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); + + android::FontFamily* family = new android::FontFamily( + android::FontLanguage((const char*)lang, xmlStrlen(lang)), variant); + + for (xmlNode* fontNode = familyNode->children; fontNode; fontNode = fontNode->next) { + if (xmlStrcmp(fontNode->name, (const xmlChar*)"font") != 0) { + continue; + } + + int weight = atoi((const char*)(xmlGetProp(fontNode, (const xmlChar*)"weight"))) / 100; + bool italic = xmlStrcmp( + xmlGetProp(fontNode, (const xmlChar*)"style"), (const xmlChar*)"italic") == 0; + + xmlChar* fontFileName = xmlNodeListGetString(doc, fontNode->xmlChildrenNode, 1); + std::string fontPath = kFontDir + std::string((const char*)fontFileName); + xmlFree(fontFileName); + + if (access(fontPath.c_str(), R_OK) != 0) { + // Skip not accessible fonts. + continue; + } + + family->addFont(new MinikinFontForTest(fontPath), android::FontStyle(weight, italic)); + } + families.push_back(family); + } + xmlFreeDoc(doc); + + std::unique_ptr r(new android::FontCollection(families)); + for (size_t i = 0; i < families.size(); ++i) { + families[i]->Unref(); + } + return r; +} diff --git a/engine/src/flutter/tests/FontTestUtils.h b/engine/src/flutter/tests/FontTestUtils.h new file mode 100644 index 0000000000..d53956f2d5 --- /dev/null +++ b/engine/src/flutter/tests/FontTestUtils.h @@ -0,0 +1,30 @@ +/* + * 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. + */ + +#ifndef MINIKIN_FONT_TEST_UTILS_H +#define MINIKIN_FONT_TEST_UTILS_H + +#include + +/** + * Returns FontCollection from installed fonts. + * + * This function reads /system/etc/fonts.xml and make font families and + * collections of them. MinikinFontForTest is used for FontFamily creation. + */ +std::unique_ptr getFontCollection(); + +#endif // MINIKIN_FONT_TEST_UTILS_H diff --git a/engine/src/flutter/tests/MinikinFontForTest.cpp b/engine/src/flutter/tests/MinikinFontForTest.cpp new file mode 100644 index 0000000000..2d29e805aa --- /dev/null +++ b/engine/src/flutter/tests/MinikinFontForTest.cpp @@ -0,0 +1,62 @@ +/* + * 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. + */ + +#include "MinikinFontForTest.h" + +#include + +#include + +#include + +MinikinFontForTest::MinikinFontForTest(const std::string& font_path) : mFontPath(font_path) { + mTypeface = SkTypeface::CreateFromFile(font_path.c_str()); +} + +MinikinFontForTest::~MinikinFontForTest() { +} + +bool MinikinFontForTest::GetGlyph(uint32_t codepoint, uint32_t *glyph) const { + LOG_ALWAYS_FATAL("MinikinFontForTest::GetGlyph is not yet implemented"); + return false; +} + +float MinikinFontForTest::GetHorizontalAdvance( + uint32_t glyph_id, const android::MinikinPaint &paint) const { + LOG_ALWAYS_FATAL("MinikinFontForTest::GetHorizontalAdvance is not yet implemented"); + return 0.0f; +} + +void MinikinFontForTest::GetBounds(android::MinikinRect* bounds, uint32_t glyph_id, + const android::MinikinPaint& paint) const { + LOG_ALWAYS_FATAL("MinikinFontForTest::GetBounds is not yet implemented"); +} + +bool MinikinFontForTest::GetTable(uint32_t tag, uint8_t *buf, size_t *size) { + if (buf == NULL) { + const size_t tableSize = mTypeface->getTableSize(tag); + *size = tableSize; + return tableSize != 0; + } else { + const size_t actualSize = mTypeface->getTableData(tag, 0, *size, buf); + *size = actualSize; + return actualSize != 0; + } +} + +int32_t MinikinFontForTest::GetUniqueId() const { + return mTypeface->uniqueID(); +} diff --git a/engine/src/flutter/tests/MinikinFontForTest.h b/engine/src/flutter/tests/MinikinFontForTest.h new file mode 100644 index 0000000000..ecebb7e2b8 --- /dev/null +++ b/engine/src/flutter/tests/MinikinFontForTest.h @@ -0,0 +1,38 @@ +/* + * 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. + */ + +#include + +class SkTypeface; + +class MinikinFontForTest : public android::MinikinFont { +public: + explicit MinikinFontForTest(const std::string& font_path); + ~MinikinFontForTest(); + + // MinikinFont overrides. + bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const; + float GetHorizontalAdvance(uint32_t glyph_id, const android::MinikinPaint &paint) const; + void GetBounds(android::MinikinRect* bounds, uint32_t glyph_id, + const android::MinikinPaint& paint) const; + bool GetTable(uint32_t tag, uint8_t *buf, size_t *size); + int32_t GetUniqueId() const; + + const std::string& fontPath() const { return mFontPath; } +private: + SkTypeface *mTypeface; + const std::string mFontPath; +}; From f6aa09df276fbf0fef6381fa61318ab84c71d1af Mon Sep 17 00:00:00 2001 From: Keisuke Kuroyanagi Date: Wed, 23 Sep 2015 16:27:07 -0700 Subject: [PATCH 104/364] Refactoring: Introduce helper class to iterate runs. This doesn't change current behavior. It's a preparation for the following CLs. Bug: 22408712 Change-Id: Ic018422254aa3904655f499194caad74f0c0fc5d --- engine/src/flutter/include/minikin/Layout.h | 2 +- engine/src/flutter/libs/minikin/Layout.cpp | 199 ++++++++++++++------ 2 files changed, 146 insertions(+), 55 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index cdf4aac523..83eb963b71 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -129,7 +129,7 @@ private: int findFace(FakedFont face, LayoutContext* ctx); // Lay out a single bidi run - void doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + void doLayoutRunCached(const uint16_t* buf, size_t runStart, size_t runLength, size_t bufSize, bool isRtl, LayoutContext* ctx, size_t dstStart); // Lay out a single word diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index eaa2b7d2e1..8b5a47b048 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -488,6 +488,148 @@ static bool isScriptOkForLetterspacing(hb_script_t script) { ); } +class BidiText { +public: + class Iter { + public: + struct RunInfo { + int32_t mRunStart; + int32_t mRunLength; + bool mIsRtl; + }; + + Iter(UBiDi* bidi, size_t start, size_t end, size_t runIndex, size_t runCount, bool isRtl); + + bool operator!= (const Iter& other) const { + return mIsEnd != other.mIsEnd || mNextRunIndex != other.mNextRunIndex + || mBidi != other.mBidi; + } + + const RunInfo& operator* () const { + return mRunInfo; + } + + const Iter& operator++ () { + updateRunInfo(); + return *this; + } + + private: + UBiDi* const mBidi; + bool mIsEnd; + size_t mNextRunIndex; + const size_t mRunCount; + const int32_t mStart; + const int32_t mEnd; + RunInfo mRunInfo; + + void updateRunInfo(); + }; + + BidiText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags); + + ~BidiText() { + if (mBidi) { + ubidi_close(mBidi); + } + } + + Iter begin () const { + return Iter(mBidi, mStart, mEnd, 0, mRunCount, mIsRtl); + } + + Iter end() const { + return Iter(mBidi, mStart, mEnd, mRunCount, mRunCount, mIsRtl); + } + +private: + const size_t mStart; + const size_t mEnd; + const size_t mBufSize; + UBiDi* mBidi; + size_t mRunCount; + bool mIsRtl; + + DISALLOW_COPY_AND_ASSIGN(BidiText); +}; + +BidiText::Iter::Iter(UBiDi* bidi, size_t start, size_t end, size_t runIndex, size_t runCount, + bool isRtl) + : mBidi(bidi), mIsEnd(runIndex == runCount), mNextRunIndex(runIndex), mRunCount(runCount), + mStart(start), mEnd(end), mRunInfo() { + if (mRunCount == 1) { + mRunInfo.mRunStart = start; + mRunInfo.mRunLength = end - start; + mRunInfo.mIsRtl = isRtl; + mNextRunIndex = mRunCount; + return; + } + updateRunInfo(); +} + +void BidiText::Iter::updateRunInfo() { + if (mNextRunIndex == mRunCount) { + // All runs have been iterated. + mIsEnd = true; + return; + } + int32_t startRun = -1; + int32_t lengthRun = -1; + const UBiDiDirection runDir = ubidi_getVisualRun(mBidi, mNextRunIndex, &startRun, &lengthRun); + mNextRunIndex++; + if (startRun == -1 || lengthRun == -1) { + ALOGE("invalid visual run"); + // skip the invalid run. + updateRunInfo(); + return; + } + const int32_t runEnd = std::min(startRun + lengthRun, mEnd); + mRunInfo.mRunStart = std::max(startRun, mStart); + mRunInfo.mRunLength = runEnd - mRunInfo.mRunStart; + if (mRunInfo.mRunLength <= 0) { + // skip the empty run. + updateRunInfo(); + return; + } + mRunInfo.mIsRtl = (runDir == UBIDI_RTL); +} + +BidiText::BidiText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags) + : mStart(start), mEnd(start + count), mBufSize(bufSize), mBidi(NULL), mRunCount(1), + mIsRtl((bidiFlags & kDirection_Mask) != 0) { + if (bidiFlags == kBidi_Force_LTR || bidiFlags == kBidi_Force_RTL) { + // force single run. + return; + } + mBidi = ubidi_open(); + if (!mBidi) { + ALOGE("error creating bidi object"); + return; + } + UErrorCode status = U_ZERO_ERROR; + UBiDiLevel bidiReq = bidiFlags; + if (bidiFlags == kBidi_Default_LTR) { + bidiReq = UBIDI_DEFAULT_LTR; + } else if (bidiFlags == kBidi_Default_RTL) { + bidiReq = UBIDI_DEFAULT_RTL; + } + ubidi_setPara(mBidi, buf, mBufSize, bidiReq, NULL, &status); + if (!U_SUCCESS(status)) { + ALOGE("error calling ubidi_setPara, status = %d", status); + return; + } + const int paraDir = ubidi_getParaLevel(mBidi) & kDirection_Mask; + const ssize_t rc = ubidi_countRuns(mBidi, &status); + if (!U_SUCCESS(status) || rc < 0) { + ALOGW("error counting bidi runs, status = %d", status); + } + if (!U_SUCCESS(status) || rc <= 1) { + mIsRtl = (paraDir == kBidi_RTL); + return; + } + mRunCount = rc; +} + void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint) { AutoMutex _l(gMinikinLock); @@ -496,63 +638,12 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu ctx.style = style; ctx.paint = paint; - bool isRtl = (bidiFlags & kDirection_Mask) != 0; - bool doSingleRun = true; - reset(); mAdvances.resize(count, 0); - if (!(bidiFlags == kBidi_Force_LTR || bidiFlags == kBidi_Force_RTL)) { - UBiDi* bidi = ubidi_open(); - if (bidi) { - UErrorCode status = U_ZERO_ERROR; - UBiDiLevel bidiReq = bidiFlags; - if (bidiFlags == kBidi_Default_LTR) { - bidiReq = UBIDI_DEFAULT_LTR; - } else if (bidiFlags == kBidi_Default_RTL) { - bidiReq = UBIDI_DEFAULT_RTL; - } - ubidi_setPara(bidi, buf, bufSize, bidiReq, NULL, &status); - if (U_SUCCESS(status)) { - int paraDir = ubidi_getParaLevel(bidi) & kDirection_Mask; - ssize_t rc = ubidi_countRuns(bidi, &status); - if (!U_SUCCESS(status) || rc < 0) { - ALOGW("error counting bidi runs, status = %d", status); - } - if (!U_SUCCESS(status) || rc <= 1) { - isRtl = (paraDir == kBidi_RTL); - } else { - doSingleRun = false; - // iterate through runs - for (ssize_t i = 0; i < (ssize_t)rc; i++) { - int32_t startRun = -1; - int32_t lengthRun = -1; - UBiDiDirection runDir = ubidi_getVisualRun(bidi, i, &startRun, &lengthRun); - if (startRun == -1 || lengthRun == -1) { - ALOGE("invalid visual run"); - // skip the invalid run - continue; - } - int32_t endRun = std::min(startRun + lengthRun, int32_t(start + count)); - startRun = std::max(startRun, int32_t(start)); - lengthRun = endRun - startRun; - if (lengthRun > 0) { - isRtl = (runDir == UBIDI_RTL); - doLayoutRunCached(buf, startRun, lengthRun, bufSize, isRtl, &ctx, - start); - } - } - } - } else { - ALOGE("error calling ubidi_setPara, status = %d", status); - } - ubidi_close(bidi); - } else { - ALOGE("error creating bidi object"); - } - } - if (doSingleRun) { - doLayoutRunCached(buf, start, count, bufSize, isRtl, &ctx, start); + for (const BidiText::Iter::RunInfo& runInfo : BidiText(buf, start, count, bufSize, bidiFlags)) { + doLayoutRunCached(buf, runInfo.mRunStart, runInfo.mRunLength, bufSize, runInfo.mIsRtl, &ctx, + start); } ctx.clearHbFonts(); } From 52dfb07bdec36b58a91a2f38b87c2eb111e299e3 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 17 Sep 2015 17:12:13 +0900 Subject: [PATCH 105/364] Extract hb_face_t object cache mechanism from Layout.cpp. This CL does following things: - Extract hb_face_t object cache mechanism from Layout.cpp to be able to use it from other cpp file, especially from FontFamily.cpp. To address Bug 11256006 and Bug 17759267, need to touch hb_face_t from FontFamily. - Make hb_face_t cache mechanism thread-safe. - Add unit tests for HbFaceCache test cases. Bug: 11256006 Bug: 17759267 Change-Id: Ic183634ef34326793bd9a32167236611d0af34d6 --- engine/src/flutter/libs/minikin/Android.mk | 1 + .../src/flutter/libs/minikin/HbFaceCache.cpp | 119 +++++++++++++++++ engine/src/flutter/libs/minikin/HbFaceCache.h | 29 +++++ engine/src/flutter/libs/minikin/Layout.cpp | 58 +-------- .../flutter/libs/minikin/MinikinInternal.cpp | 6 + .../flutter/libs/minikin/MinikinInternal.h | 3 + engine/src/flutter/tests/Android.mk | 4 +- engine/src/flutter/tests/HbFaceCacheTest.cpp | 123 ++++++++++++++++++ 8 files changed, 287 insertions(+), 56 deletions(-) create mode 100644 engine/src/flutter/libs/minikin/HbFaceCache.cpp create mode 100644 engine/src/flutter/libs/minikin/HbFaceCache.h create mode 100644 engine/src/flutter/tests/HbFaceCacheTest.cpp diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 765a3ddfd7..fab5586e37 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -22,6 +22,7 @@ minikin_src_files := \ FontCollection.cpp \ FontFamily.cpp \ GraphemeBreak.cpp \ + HbFaceCache.cpp \ Hyphenator.cpp \ Layout.cpp \ LayoutUtils.cpp \ diff --git a/engine/src/flutter/libs/minikin/HbFaceCache.cpp b/engine/src/flutter/libs/minikin/HbFaceCache.cpp new file mode 100644 index 0000000000..fde2fa869f --- /dev/null +++ b/engine/src/flutter/libs/minikin/HbFaceCache.cpp @@ -0,0 +1,119 @@ +/* + * 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. + */ + +#define LOG_TAG "Minikin" + +#include "HbFaceCache.h" + +#include +#include + +#include +#include "MinikinInternal.h" + +namespace android { + +static hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { + MinikinFont* font = reinterpret_cast(userData); + size_t length = 0; + bool ok = font->GetTable(tag, NULL, &length); + if (!ok) { + return 0; + } + char* buffer = reinterpret_cast(malloc(length)); + if (!buffer) { + return 0; + } + ok = font->GetTable(tag, reinterpret_cast(buffer), &length); +#ifdef VERBOSE_DEBUG + ALOGD("referenceTable %c%c%c%c length=%d %d", + (tag >>24)&0xff, (tag>>16)&0xff, (tag>>8)&0xff, tag&0xff, length, ok); +#endif + if (!ok) { + free(buffer); + return 0; + } + return hb_blob_create(const_cast(buffer), length, + HB_MEMORY_MODE_WRITABLE, buffer, free); +} + +static unsigned int disabledDecomposeCompatibility( + hb_unicode_funcs_t*, hb_codepoint_t, hb_codepoint_t*, void*) { + return 0; +} + +class HbFaceCache : private OnEntryRemoved { +public: + HbFaceCache() : mCache(kMaxEntries) { + mCache.setOnEntryRemovedListener(this); + } + + // callback for OnEntryRemoved + void operator()(int32_t& key, hb_face_t*& value) { + hb_face_destroy(value); + } + + hb_face_t* get(int32_t fontId) { + return mCache.get(fontId); + } + + void put(int32_t fontId, hb_face_t* face) { + mCache.put(fontId, face); + } + + void clear() { + mCache.clear(); + } + +private: + static const size_t kMaxEntries = 100; + + LruCache mCache; +}; + +HbFaceCache* getFaceCacheLocked() { + assertMinikinLocked(); + static HbFaceCache* cache = nullptr; + if (cache == nullptr) { + cache = new HbFaceCache(); + } + return cache; +} + +void purgeHbFaceCacheLocked() { + assertMinikinLocked(); + getFaceCacheLocked()->clear(); +} + +hb_face_t* getHbFaceLocked(MinikinFont* minikinFont) { + assertMinikinLocked(); + if (minikinFont == nullptr) { + return nullptr; + } + + HbFaceCache* faceCache = getFaceCacheLocked(); + const int32_t fontId = minikinFont->GetUniqueId(); + hb_face_t* face = faceCache->get(fontId); + if (face != nullptr) { + return face; + } + + face = hb_face_create_for_tables(referenceTable, minikinFont, nullptr); + faceCache->put(fontId, face); + return face; +} + +} // namespace android diff --git a/engine/src/flutter/libs/minikin/HbFaceCache.h b/engine/src/flutter/libs/minikin/HbFaceCache.h new file mode 100644 index 0000000000..8ee38c3603 --- /dev/null +++ b/engine/src/flutter/libs/minikin/HbFaceCache.h @@ -0,0 +1,29 @@ +/* + * 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. + */ + +#ifndef MINIKIN_HBFACE_CACHE_H +#define MINIKIN_HBFACE_CACHE_H + +struct hb_face_t; + +namespace android { +class MinikinFont; + +void purgeHbFaceCacheLocked(); +hb_face_t* getHbFaceLocked(MinikinFont* minikinFont); + +} // namespace android +#endif // MINIKIN_HBFACE_CACHE_H diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index eaa2b7d2e1..65a8a7520b 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -35,6 +35,7 @@ #include #include "LayoutUtils.h" +#include "HbFaceCache.h" #include "MinikinInternal.h" #include #include @@ -188,22 +189,6 @@ private: static const size_t kMaxEntries = 5000; }; -class HbFaceCache : private OnEntryRemoved { -public: - HbFaceCache() : mCache(kMaxEntries) { - mCache.setOnEntryRemovedListener(this); - } - - // callback for OnEntryRemoved - void operator()(int32_t& key, hb_face_t*& value) { - hb_face_destroy(value); - } - - LruCache mCache; -private: - static const size_t kMaxEntries = 100; -}; - static unsigned int disabledDecomposeCompatibility(hb_unicode_funcs_t*, hb_codepoint_t, hb_codepoint_t*, void*) { return 0; @@ -223,7 +208,6 @@ public: hb_buffer_t* hbBuffer; hb_unicode_funcs_t* unicodeFunctions; LayoutCache layoutCache; - HbFaceCache hbFaceCache; }; ANDROID_SINGLETON_STATIC_INSTANCE(LayoutEngine); @@ -291,30 +275,6 @@ void Layout::setFontCollection(const FontCollection* collection) { mCollection = collection; } -hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { - MinikinFont* font = reinterpret_cast(userData); - size_t length = 0; - bool ok = font->GetTable(tag, NULL, &length); - if (!ok) { - return 0; - } - char* buffer = reinterpret_cast(malloc(length)); - if (!buffer) { - return 0; - } - ok = font->GetTable(tag, reinterpret_cast(buffer), &length); -#ifdef VERBOSE_DEBUG - ALOGD("referenceTable %c%c%c%c length=%d %d", - (tag >>24) & 0xff, (tag>>16)&0xff, (tag>>8)&0xff, tag&0xff, length, ok); -#endif - if (!ok) { - free(buffer); - return 0; - } - return hb_blob_create(const_cast(buffer), length, - HB_MEMORY_MODE_WRITABLE, buffer, free); -} - static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, void* userData) { MinikinPaint* paint = reinterpret_cast(fontData); @@ -342,19 +302,8 @@ hb_font_funcs_t* getHbFontFuncs() { return hbFontFuncs; } -static hb_face_t* getHbFace(MinikinFont* minikinFont) { - HbFaceCache& cache = LayoutEngine::getInstance().hbFaceCache; - int32_t fontId = minikinFont->GetUniqueId(); - hb_face_t* face = cache.mCache.get(fontId); - if (face == NULL) { - face = hb_face_create_for_tables(referenceTable, minikinFont, NULL); - cache.mCache.put(fontId, face); - } - return face; -} - static hb_font_t* create_hb_font(MinikinFont* minikinFont, MinikinPaint* minikinPaint) { - hb_face_t* face = getHbFace(minikinFont); + hb_face_t* face = getHbFaceLocked(minikinFont); hb_font_t* parent_font = hb_font_create(face); hb_ot_font_set_funcs(parent_font); @@ -885,8 +834,7 @@ void Layout::purgeCaches() { AutoMutex _l(gMinikinLock); LayoutCache& layoutCache = LayoutEngine::getInstance().layoutCache; layoutCache.clear(); - HbFaceCache& hbCache = LayoutEngine::getInstance().hbFaceCache; - hbCache.mCache.clear(); + purgeHbFaceCacheLocked(); } } // namespace android diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 71c8649b1e..5a21ef9862 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -18,8 +18,14 @@ #include "MinikinInternal.h" +#include + namespace android { Mutex gMinikinLock; +void assertMinikinLocked() { + LOG_FATAL_IF(gMinikinLock.tryLock() == 0); +} + } diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index b8430df550..34a95bb3d1 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -29,6 +29,9 @@ namespace android { extern Mutex gMinikinLock; +// Aborts if gMinikinLock is not acquired. Do nothing on the release build. +void assertMinikinLocked(); + } #endif // MINIKIN_INTERNAL_H diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index 680cbe9349..b4d5e91bc3 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -43,12 +43,14 @@ LOCAL_SRC_FILES += \ FontTestUtils.cpp \ MinikinFontForTest.cpp \ GraphemeBreakTests.cpp \ + HbFaceCacheTest.cpp \ LayoutUtilsTest.cpp \ UnicodeUtils.cpp LOCAL_C_INCLUDES := \ $(LOCAL_PATH)/../libs/minikin/ \ + external/harfbuzz_ng/src \ external/libxml2/include \ - external/skia/src/core \ + external/skia/src/core include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/HbFaceCacheTest.cpp b/engine/src/flutter/tests/HbFaceCacheTest.cpp new file mode 100644 index 0000000000..1b63073851 --- /dev/null +++ b/engine/src/flutter/tests/HbFaceCacheTest.cpp @@ -0,0 +1,123 @@ +/* + * 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. + */ + +#include + +#include "HbFaceCache.h" + +#include +#include +#include + +#include "MinikinInternal.h" +#include + +namespace android { +namespace { + +// A mock implementation of MinikinFont. The passed integer value will be +// returned in GetUniqueId(). +class MockMinikinFont : public MinikinFont { +public: + MockMinikinFont(int32_t id) : mId(id) { + } + + virtual bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const { + LOG_ALWAYS_FATAL("MockMinikinFont::GetGlyph is not implemented."); + return false; + } + + virtual float GetHorizontalAdvance( + uint32_t glyph_id, const MinikinPaint &paint) const { + LOG_ALWAYS_FATAL("MockMinikinFont::GetHorizontalAdvance is not implemented."); + return 0.0f; + } + + virtual void GetBounds(MinikinRect* bounds, uint32_t glyph_id, + const MinikinPaint &paint) const { + LOG_ALWAYS_FATAL("MockMinikinFont::GetBounds is not implemented."); + } + + virtual bool GetTable(uint32_t tag, uint8_t *buf, size_t *size) { + LOG_ALWAYS_FATAL("MockMinikinFont::GetTable is not implemented."); + return false; + } + + virtual int32_t GetUniqueId() const { + return mId; + } + +private: + int32_t mId; +}; + +class HbFaceCacheTest : public testing::Test { +public: + virtual void TearDown() { + AutoMutex _l(gMinikinLock); + purgeHbFaceCacheLocked(); + } +}; + +TEST_F(HbFaceCacheTest, getHbFaceLockedTest) { + AutoMutex _l(gMinikinLock); + + MockMinikinFont fontA(1); + MockMinikinFont fontB(2); + MockMinikinFont fontC(2); + + // Never return NULL. + EXPECT_TRUE(getHbFaceLocked(&fontA)); + EXPECT_TRUE(getHbFaceLocked(&fontB)); + EXPECT_TRUE(getHbFaceLocked(&fontC)); + + // Must return same object if same font object is passed. + EXPECT_EQ(getHbFaceLocked(&fontA), getHbFaceLocked(&fontA)); + EXPECT_EQ(getHbFaceLocked(&fontB), getHbFaceLocked(&fontB)); + EXPECT_EQ(getHbFaceLocked(&fontC), getHbFaceLocked(&fontC)); + + // Different object must be returned if the passed minikinFont has different ID. + EXPECT_NE(getHbFaceLocked(&fontA), getHbFaceLocked(&fontB)); + EXPECT_NE(getHbFaceLocked(&fontA), getHbFaceLocked(&fontC)); + + // Same object must be returned if the minikinFont has same Id. + EXPECT_EQ(getHbFaceLocked(&fontB), getHbFaceLocked(&fontC)); +} + +TEST_F(HbFaceCacheTest, purgeCacheTest) { + AutoMutex _l(gMinikinLock); + MockMinikinFont font(1); + + hb_face_t* face = getHbFaceLocked(&font); + EXPECT_TRUE(face); + + // Set user data to identify the face object. + hb_user_data_key_t key; + void* data = (void*)0xdeadbeef; + hb_face_set_user_data(face, &key, data, NULL, false); + EXPECT_EQ(data, hb_face_get_user_data(face, &key)); + + purgeHbFaceCacheLocked(); + + // By checking user data, confirm that the object after purge is different from previously + // created one. Do not compare the returned pointer here since memory allocator may assign + // same region for new object. + face = getHbFaceLocked(&font); + EXPECT_EQ(nullptr, hb_face_get_user_data(face, &key)); +} + +} // namespace +} // namespace android From 96df754284ff81f0a25e7edd486bf7bd85a59fdf Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 27 Aug 2015 13:50:00 -0700 Subject: [PATCH 106/364] Binary format for hyphenation patterns In the current state, hyphenation in all languages than Sanskrit seems to work (case-folding edge cases). Thus, we just disable Sanskrit. Packed tries are implemented, but not the finite state machine (space/speed tradeoff). This commit contains a throw-away test app, which runs on the host. I think I want to replace it with unit tests, but I'm including it in the CL because it's useful during development. Bug: 21562869 Bug: 21826930 Bug: 23317038 Bug: 23317904 Change-Id: I7479a565a4a062fa319651c2c14c0fa18c5ceaea --- engine/src/flutter/app/Android.mk | 36 ++ engine/src/flutter/app/HyphTool.cpp | 62 ++ engine/src/flutter/doc/hyb_file_format.md | 135 +++++ .../src/flutter/include/minikin/Hyphenator.h | 41 +- engine/src/flutter/libs/minikin/Android.mk | 14 + .../src/flutter/libs/minikin/Hyphenator.cpp | 276 +++++---- engine/src/flutter/tools/mk_hyb_file.py | 567 ++++++++++++++++++ 7 files changed, 1019 insertions(+), 112 deletions(-) create mode 100644 engine/src/flutter/app/Android.mk create mode 100644 engine/src/flutter/app/HyphTool.cpp create mode 100644 engine/src/flutter/doc/hyb_file_format.md create mode 100755 engine/src/flutter/tools/mk_hyb_file.py diff --git a/engine/src/flutter/app/Android.mk b/engine/src/flutter/app/Android.mk new file mode 100644 index 0000000000..2038683027 --- /dev/null +++ b/engine/src/flutter/app/Android.mk @@ -0,0 +1,36 @@ +# 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. + +# see how_to_run.txt for instructions on running these tests + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_MODULE := hyphtool +LOCAL_MODULE_TAGS := optional + +LOCAL_STATIC_LIBRARIES := libminikin_host + +# Shared libraries which are dependencies of minikin; these are not automatically +# pulled in by the build system (and thus sadly must be repeated). + +LOCAL_SHARED_LIBRARIES := \ + liblog \ + libicuuc-host + +LOCAL_SRC_FILES += \ + HyphTool.cpp + +include $(BUILD_HOST_EXECUTABLE) diff --git a/engine/src/flutter/app/HyphTool.cpp b/engine/src/flutter/app/HyphTool.cpp new file mode 100644 index 0000000000..730abadcba --- /dev/null +++ b/engine/src/flutter/app/HyphTool.cpp @@ -0,0 +1,62 @@ +#include +#include +#include + +#include "utils/Log.h" + +#include +#include + +using android::Hyphenator; + +Hyphenator* loadHybFile(const char* fn) { + struct stat statbuf; + int status = stat(fn, &statbuf); + if (status < 0) { + fprintf(stderr, "error opening %s\n", fn); + return nullptr; + } + size_t size = statbuf.st_size; + FILE* f = fopen(fn, "rb"); + if (f == NULL) { + fprintf(stderr, "error opening %s\n", fn); + return nullptr; + } + uint8_t* buf = new uint8_t[size]; + size_t read_size = fread(buf, 1, size, f); + if (read_size < size) { + fprintf(stderr, "error reading %s\n", fn); + delete[] buf; + return nullptr; + } + return Hyphenator::loadBinary(buf); +} + +int main(int argc, char** argv) { + Hyphenator* hyph = loadHybFile("/tmp/en.hyb"); // should also be configurable + std::vector result; + std::vector word; + if (argc < 2) { + fprintf(stderr, "usage: hyphtool word\n"); + return 1; + } + char* asciiword = argv[1]; + size_t len = strlen(asciiword); + for (size_t i = 0; i < len; i++) { + uint32_t c = asciiword[i]; + if (c == '-') { + c = 0x00AD; + } + // ASCII (or possibly ISO Latin 1), but kinda painful to do utf conversion :( + word.push_back(c); + } + hyph->hyphenate(&result, word.data(), word.size()); + for (size_t i = 0; i < len; i++) { + if (result[i] != 0) { + printf("-"); + } + printf("%c", word[i]); + } + printf("\n"); + return 0; +} diff --git a/engine/src/flutter/doc/hyb_file_format.md b/engine/src/flutter/doc/hyb_file_format.md new file mode 100644 index 0000000000..3065a6f5cc --- /dev/null +++ b/engine/src/flutter/doc/hyb_file_format.md @@ -0,0 +1,135 @@ +# Hyb (hyphenation pattern binary) file format + +The hyb file format is how hyphenation patterns are stored in the system image. + +Goals include: + +* Concise (system image space is at a premium) +* Usable when mmap'ed, so it doesn't take significant physical RAM +* Fast to compute +* Simple + +It is _not_ intended as an interchange format, so there is no attempt to make the format +extensible or facilitate backward and forward compatibility. + +Further, at some point we will probably pack patterns for multiple languages into a single +physical file, to reduce number of open mmap'ed files. This document doesn't cover that. + +## Theoretical basis + +At heart, the file contains packed tries with suffix compression, actually quite similar +to the implementation in TeX. + +The file contains three sections. The first section represents the "alphabet," including +case folding. It is effectively a map from Unicode code point to a small integer. + +The second section contains the trie in packed form. It is an array of 3-tuples, packed +into a 32 bit integer. Each (suffix-compressed) trie node has a unique index within this +array, and the pattern field in the tuple is the pattern for that node. Further, each edge +in the trie has an entry in the array, and the character and link fields in the tuple +represent the label and destination of the edge. The packing strategy is as in +[Word Hy-phen-a-tion by Com-put-er](http://www.tug.org/docs/liang/liang-thesis.pdf) by +Franklin Mark Liang. + +The trie representation is similar but not identical to the "double-array trie". +The fundamental operation of lookup of the edge from `s` to `t` with label `c` is +to compare `c == character[s + c]`, and if so, `t = link[s + c]`. + +The third section contains the pattern strings. This section is in two parts: first, +an array with a 3-tuple for each pattern (length, number of trailing 0's, and offset +into the string pool); and second, the string pool. Each pattern is encoded as a byte +(packing 2 per byte would be possible but the space savings would not be signficant). + +As much as possible of the file is represented as 32 bit integers, as that is especially +efficent to access. All are little-endian (this could be revised if the code ever needs +to be ported to big-endian systems). + +## Header + +``` +uint32_t magic == 0x62ad7968 +uint32_t version = 0 +uint32_t alphabet_offset (in bytes) +uint32_t trie_offset (in bytes) +uint32_t pattern_offset (in bytes) +uint32_t file_size (in bytes) +``` + +Offsets are from the front of the file, and in bytes. + +## Alphabet + +The alphabet table comes in two versions. The first is well suited to dense Unicode +ranges and is limited to 256. The second is more general, but lookups will be slower. + +### Alphabet, direct version + +``` +uint32_t version = 0 +uint32_t min_codepoint +uint32_t max_codepoint (exclusive) +uint8_t[] data +``` + +The size of the data array is max_codepoint - min_codepoint. 0 represents an unmapped +character. Note that, in the current implementation, automatic hyphenation is disabled +for any word containing an unmapped character. + +In general, pad bytes follow this table, aligning the next table to a 4-byte boundary. + +### Alphabet, general version + +``` +uint32_t version = 1 +uint32_t n_entries +uint32_t[n_entries] data +``` + +Each element in the data table is `(codepoint << 11) | value`. Note that this is +restricted to 11 bits (2048 possible values). The largest known current value is 483 +(for Sanskrit). + +The entries are sorted by codepoint, to facilitate binary search. Another reasonable +implementation for consumers of the data would be to build a hash table at load time. + +## Trie + +``` +uint32_t version = 0 +uint32_t char_mask +uint32_t link_shift +uint32_t link_mask +uint32_t pattern_shift +uint32_t n_entries +uint32_t[n_entries] data +``` + +Each element in the data table is `(pattern << pattern_shift) | (link << link_shift) | char`. + +All known pattern tables fit in 32 bits total. If this is exceeded, there is a fairly +straightforward tweak, where each node occupies a slot by itself (as opposed to sharing +it with edge slots), which would require very minimal changes to the implementation (TODO +present in more detail). + +## Pattern + +``` +uint32_t version = 0 +uint32_t n_entries +uint32_t pattern_offset (in bytes) +uint32_t pattern_size (in bytes) +uint32_t[n_entries] data +uint8_t[] pattern_buf +``` + +Each element in data table is `(len << 26) | (shift << 20) | offset`, where an offset of 0 +points to the first byte of pattern_buf. + +Generally pattern_offset is `16 + 4 * n_entries`. + +For example, 'a4m5ato' would be represented as `[4, 5, 0, 0, 0]`, then len = 2, shift = 3, and +offset points to [4, 5] in the pattern buffer. + +Future extension: additional data representing nonstandard hyphenation. See +[Automatic non-standard hyphenation in OpenOffice.org](https://www.tug.org/TUGboat/tb27-1/tb86nemeth.pdf) +for more information about that issue. diff --git a/engine/src/flutter/include/minikin/Hyphenator.h b/engine/src/flutter/include/minikin/Hyphenator.h index 581c657fbe..9605205a29 100644 --- a/engine/src/flutter/include/minikin/Hyphenator.h +++ b/engine/src/flutter/include/minikin/Hyphenator.h @@ -26,11 +26,8 @@ namespace android { -class Trie { -public: - std::vector result; - std::unordered_map succ; -}; +// hyb file header; implementation details are in the .cpp file +struct Header; class Hyphenator { public: @@ -44,19 +41,43 @@ public: // Example: word is "hyphen", result is [0 0 1 0 0 0], corresponding to "hy-phen". void hyphenate(std::vector* result, const uint16_t* word, size_t len); -private: - void addPattern(const uint16_t* pattern, size_t size); + // pattern data is in binary format, as described in doc/hyb_file_format.md. Note: + // the caller is responsible for ensuring that the lifetime of the pattern data is + // at least as long as the Hyphenator object. - void hyphenateSoft(std::vector* result, const uint16_t* word, size_t len); + // Note: nullptr is valid input, in which case the hyphenator only processes soft hyphens + static Hyphenator* loadBinary(const uint8_t* patternData); + +private: + // apply soft hyphens only, ignoring patterns + void hyphenateSoft(uint8_t* result, const uint16_t* word, size_t len); + + // try looking up word in alphabet table, return false if any code units fail to map + // Note that this methor writes len+2 entries into alpha_codes (including start and stop) + bool alphabetLookup(uint16_t* alpha_codes, const uint16_t* word, size_t len); + + // calculate hyphenation from patterns, assuming alphabet lookup has already been done + void hyphenateFromCodes(uint8_t* result, const uint16_t* codes, size_t len); // TODO: these should become parameters, as they might vary by locale, screen size, and // possibly explicit user control. static const int MIN_PREFIX = 2; static const int MIN_SUFFIX = 3; - Trie root; + // See also LONGEST_HYPHENATED_WORD in LineBreaker.cpp. Here the constant is used so + // that temporary buffers can be stack-allocated without waste, which is a slightly + // different use case. It measures UTF-16 code units. + static const size_t MAX_HYPHENATED_SIZE = 64; + + const uint8_t* patternData; + + // accessors for binary data + const Header* getHeader() const { + return reinterpret_cast(patternData); + } + }; } // namespace android -#endif // MINIKIN_HYPHENATOR_H \ No newline at end of file +#endif // MINIKIN_HYPHENATOR_H diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 765a3ddfd7..58baedc2f0 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -63,3 +63,17 @@ LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) include $(BUILD_STATIC_LIBRARY) + +include $(CLEAR_VARS) + +# Reduced library (currently just hyphenation) for host + +LOCAL_MODULE := libminikin_host +LOCAL_MODULE_TAGS := optional +LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include +LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_SHARED_LIBRARIES := liblog libicuuc-host + +LOCAL_SRC_FILES := Hyphenator.cpp + +include $(BUILD_HOST_STATIC_LIBRARY) diff --git a/engine/src/flutter/libs/minikin/Hyphenator.cpp b/engine/src/flutter/libs/minikin/Hyphenator.cpp index 3eb151b9e0..c5eb60b8e5 100644 --- a/engine/src/flutter/libs/minikin/Hyphenator.cpp +++ b/engine/src/flutter/libs/minikin/Hyphenator.cpp @@ -34,130 +34,202 @@ namespace android { static const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; -void Hyphenator::addPattern(const uint16_t* pattern, size_t size) { - vector word; - vector result; +// The following are structs that correspond to tables inside the hyb file format - // start by parsing the Liang-format pattern into a word and a result vector, the - // vector right-aligned but without leading zeros. Examples: - // a1bc2d -> abcd [1, 0, 2, 0] - // abc1 -> abc [1] - // 1a2b3c4d5 -> abcd [1, 2, 3, 4, 5] - bool lastWasLetter = false; - bool haveSeenNumber = false; - for (size_t i = 0; i < size; i++) { - uint16_t c = pattern[i]; - if (isdigit(c)) { - result.push_back(c - '0'); - lastWasLetter = false; - haveSeenNumber = true; - } else { - word.push_back(c); - if (lastWasLetter && haveSeenNumber) { - result.push_back(0); - } - lastWasLetter = true; - } - } - if (lastWasLetter) { - result.push_back(0); - } - Trie* t = &root; - for (size_t i = 0; i < word.size(); i++) { - t = &t->succ[word[i]]; - } - t->result = result; -} +struct AlphabetTable0 { + uint32_t version; + uint32_t min_codepoint; + uint32_t max_codepoint; + uint8_t data[1]; // actually flexible array, size is known at runtime +}; -// If any soft hyphen is present in the word, use soft hyphens to decide hyphenation, -// as recommended in UAX #14 (Use of Soft Hyphen) -void Hyphenator::hyphenateSoft(vector* result, const uint16_t* word, size_t len) { - (*result)[0] = 0; - for (size_t i = 1; i < len; i++) { - (*result)[i] = word[i - 1] == CHAR_SOFT_HYPHEN; +struct AlphabetTable1 { + uint32_t version; + uint32_t n_entries; + uint32_t data[1]; // actually flexible array, size is known at runtime + + static uint32_t codepoint(uint32_t entry) { return entry >> 11; } + static uint32_t value(uint32_t entry) { return entry & 0x7ff; } +}; + +struct Trie { + uint32_t version; + uint32_t char_mask; + uint32_t link_shift; + uint32_t link_mask; + uint32_t pattern_shift; + uint32_t n_entries; + uint32_t data[1]; // actually flexible array, size is known at runtime +}; + +struct Pattern { + uint32_t version; + uint32_t n_entries; + uint32_t pattern_offset; + uint32_t pattern_size; + uint32_t data[1]; // actually flexible array, size is known at runtime + + // accessors + static uint32_t len(uint32_t entry) { return entry >> 26; } + static uint32_t shift(uint32_t entry) { return (entry >> 20) & 0x3f; } + const uint8_t* buf(uint32_t entry) const { + return reinterpret_cast(this) + pattern_offset + (entry & 0xfffff); } +}; + +struct Header { + uint32_t magic; + uint32_t version; + uint32_t alphabet_offset; + uint32_t trie_offset; + uint32_t pattern_offset; + uint32_t file_size; + + // accessors + const uint8_t* bytes() const { return reinterpret_cast(this); } + uint32_t alphabetVersion() const { + return *reinterpret_cast(bytes() + alphabet_offset); + } + const AlphabetTable0* alphabetTable0() const { + return reinterpret_cast(bytes() + alphabet_offset); + } + const AlphabetTable1* alphabetTable1() const { + return reinterpret_cast(bytes() + alphabet_offset); + } + const Trie* trieTable() const { + return reinterpret_cast(bytes() + trie_offset); + } + const Pattern* patternTable() const { + return reinterpret_cast(bytes() + pattern_offset); + } +}; + +Hyphenator* Hyphenator::loadBinary(const uint8_t* patternData) { + Hyphenator* result = new Hyphenator; + result->patternData = patternData; + return result; } void Hyphenator::hyphenate(vector* result, const uint16_t* word, size_t len) { result->clear(); result->resize(len); - if (len < MIN_PREFIX + MIN_SUFFIX) return; - size_t maxOffset = len - MIN_SUFFIX + 1; - for (size_t i = 0; i < len + 1; i++) { - const Trie* node = &root; - for (size_t j = i; j < len + 2; j++) { - uint16_t c; - if (j == 0 || j == len + 1) { - c = '.'; // word boundary character in pattern data files - } else { - c = word[j - 1]; - if (c == CHAR_SOFT_HYPHEN) { - hyphenateSoft(result, word, len); - return; - } - // TODO: This uses ICU's simple character to character lowercasing, which ignores - // the locale, and ignores cases when lowercasing a character results in more than - // one character. It should be fixed to consider the locale (in order for it to work - // correctly for Turkish and Azerbaijani), as well as support one-to-many, and - // many-to-many case conversions (including non-BMP cases). - if (c < 0x00C0) { // U+00C0 is the lowest uppercase non-ASCII character - // Convert uppercase ASCII to lowercase ASCII, but keep other characters as-is - if (0x0041 <= c && c <= 0x005A) { - c += 0x0020; - } - } else { - c = u_tolower(c); - } + const size_t paddedLen = len + 2; // start and stop code each count for 1 + if (patternData != nullptr && + (int)len >= MIN_PREFIX + MIN_SUFFIX && paddedLen <= MAX_HYPHENATED_SIZE) { + uint16_t alpha_codes[MAX_HYPHENATED_SIZE]; + if (alphabetLookup(alpha_codes, word, len)) { + hyphenateFromCodes(result->data(), alpha_codes, paddedLen); + return; + } + // TODO: try NFC normalization + // TODO: handle non-BMP Unicode (requires remapping of offsets) + } + hyphenateSoft(result->data(), word, len); +} + +// If any soft hyphen is present in the word, use soft hyphens to decide hyphenation, +// as recommended in UAX #14 (Use of Soft Hyphen) +void Hyphenator::hyphenateSoft(uint8_t* result, const uint16_t* word, size_t len) { + result[0] = 0; + for (size_t i = 1; i < len; i++) { + result[i] = word[i - 1] == CHAR_SOFT_HYPHEN; + } +} + +bool Hyphenator::alphabetLookup(uint16_t* alpha_codes, const uint16_t* word, size_t len) { + const Header* header = getHeader(); + // TODO: check header magic + uint32_t alphabetVersion = header->alphabetVersion(); + if (alphabetVersion == 0) { + const AlphabetTable0* alphabet = header->alphabetTable0(); + uint32_t min_codepoint = alphabet->min_codepoint; + uint32_t max_codepoint = alphabet->max_codepoint; + alpha_codes[0] = 0; // word start + for (size_t i = 0; i < len; i++) { + uint16_t c = word[i]; + if (c < min_codepoint || c >= max_codepoint) { + return false; } - auto search = node->succ.find(c); - if (search != node->succ.end()) { - node = &search->second; + uint8_t code = alphabet->data[c - min_codepoint]; + if (code == 0) { + return false; + } + alpha_codes[i + 1] = code; + } + alpha_codes[len + 1] = 0; // word termination + return true; + } else if (alphabetVersion == 1) { + const AlphabetTable1* alphabet = header->alphabetTable1(); + size_t n_entries = alphabet->n_entries; + const uint32_t* begin = alphabet->data; + const uint32_t* end = begin + n_entries; + alpha_codes[0] = 0; + for (size_t i = 0; i < len; i++) { + uint16_t c = word[i]; + auto p = std::lower_bound(begin, end, c << 11); + if (p == end) { + return false; + } + uint32_t entry = *p; + if (AlphabetTable1::codepoint(entry) != c) { + return false; + } + alpha_codes[i + 1] = AlphabetTable1::value(entry); + } + alpha_codes[len + 1] = 0; + return true; + } + return false; +} + +/** + * Internal implementation, after conversion to codes. All case folding and normalization + * has been done by now, and all characters have been found in the alphabet. + * Note: len here is the padded length including 0 codes at start and end. + **/ +void Hyphenator::hyphenateFromCodes(uint8_t* result, const uint16_t* codes, size_t len) { + const Header* header = getHeader(); + const Trie* trie = header->trieTable(); + const Pattern* pattern = header->patternTable(); + uint32_t char_mask = trie->char_mask; + uint32_t link_shift = trie->link_shift; + uint32_t link_mask = trie->link_mask; + uint32_t pattern_shift = trie->pattern_shift; + size_t maxOffset = len - MIN_SUFFIX - 1; + for (size_t i = 0; i < len - 1; i++) { + uint32_t node = 0; // index into Trie table + for (size_t j = i; j < len; j++) { + uint16_t c = codes[j]; + uint32_t entry = trie->data[node + c]; + if ((entry & char_mask) == c) { + node = (entry & link_mask) >> link_shift; } else { break; } - if (!node->result.empty()) { - int resultLen = node->result.size(); - int offset = j + 1 - resultLen; + uint32_t pat_ix = trie->data[node] >> pattern_shift; + // pat_ix contains a 3-tuple of length, shift (number of trailing zeros), and an offset + // into the buf pool. This is the pattern for the substring (i..j) we just matched, + // which we combine (via point-wise max) into the result vector. + if (pat_ix != 0) { + uint32_t pat_entry = pattern->data[pat_ix]; + int pat_len = Pattern::len(pat_entry); + int pat_shift = Pattern::shift(pat_entry); + const uint8_t* pat_buf = pattern->buf(pat_entry); + int offset = j + 1 - (pat_len + pat_shift); + // offset is the index within result that lines up with the start of pat_buf int start = std::max(MIN_PREFIX - offset, 0); - int end = std::min(resultLen, (int)maxOffset - offset); - // TODO performance: this inner loop can profitably be optimized + int end = std::min(pat_len, (int)maxOffset - offset); for (int k = start; k < end; k++) { - (*result)[offset + k] = std::max((*result)[offset + k], node->result[k]); + result[offset + k] = std::max(result[offset + k], pat_buf[k]); } -#if 0 - // debug printing of matched patterns - std::string dbg; - for (size_t k = i; k <= j + 1; k++) { - int off = k - j - 2 + resultLen; - if (off >= 0 && node->result[off] != 0) { - dbg.push_back((char)('0' + node->result[off])); - } - if (k < j + 1) { - uint16_t c = (k == 0 || k == len + 1) ? '.' : word[k - 1]; - dbg.push_back((char)c); - } - } - ALOGD("%d:%d %s", i, j, dbg.c_str()); -#endif } } } // Since the above calculation does not modify values outside // [MIN_PREFIX, len - MIN_SUFFIX], they are left as 0. for (size_t i = MIN_PREFIX; i < maxOffset; i++) { - (*result)[i] &= 1; + result[i] &= 1; } } -Hyphenator* Hyphenator::load(const uint16_t *patternData, size_t size) { - Hyphenator* result = new Hyphenator; - for (size_t i = 0; i < size; i++) { - size_t end = i; - while (patternData[end] != '\n') end++; - result->addPattern(patternData + i, end - i); - i = end; - } - return result; -} - } // namespace android diff --git a/engine/src/flutter/tools/mk_hyb_file.py b/engine/src/flutter/tools/mk_hyb_file.py new file mode 100755 index 0000000000..c078454e6b --- /dev/null +++ b/engine/src/flutter/tools/mk_hyb_file.py @@ -0,0 +1,567 @@ +#!/usr/bin/env python + +# 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. + +""" +Convert hyphen files in standard TeX format (a trio of pat, chr, and hyp) +into binary format. See doc/hyb_file_format.md for more information. + +Usage: mk_hyb_file.py [-v] hyph-foo.pat.txt hyph-foo.hyb + +Optional -v parameter turns on verbose debugging. + +""" + +from __future__ import print_function + +import io +import sys +import struct +import math +import getopt + + +VERBOSE = False + + +if sys.version_info[0] >= 3: + def unichr(x): + return chr(x) + + +# number of bits required to represent numbers up to n inclusive +def num_bits(n): + return 1 + int(math.log(n, 2)) if n > 0 else 0 + + +class Node: + + def __init__(self): + self.succ = {} + self.res = None + self.fsm_pat = None + self.fail = None + + +# List of free slots, implemented as doubly linked list +class Freelist: + + def __init__(self): + self.first = None + self.last = None + self.pred = [] + self.succ = [] + + def grow(self): + this = len(self.pred) + self.pred.append(self.last) + self.succ.append(None) + if self.last is None: + self.first = this + else: + self.succ[self.last] = this + self.last = this + + def next(self, cursor): + if cursor == 0: + cursor = self.first + if cursor is None: + self.grow() + result = self.last + else: + result = cursor + return result, self.succ[result] + + def is_free(self, ix): + while ix >= len(self.pred): + self.grow() + return self.pred[ix] != -1 + + def use(self, ix): + if self.pred[ix] is None: + self.first = self.succ[ix] + else: + self.succ[self.pred[ix]] = self.succ[ix] + if self.succ[ix] is None: + self.last = self.pred[ix] + else: + self.pred[self.succ[ix]] = self.pred[ix] + if self.pred[ix] == -1: + assert self.pred[ix] != -1, 'double free!' + self.pred[ix] = -1 + + +def combine(a, b): + if a is None: return b + if b is None: return a + if len(b) < len(a): a, b = b, a + res = b[:len(b) - len(a)] + for i in range(len(a)): + res.append(max(a[i], b[i + len(b) - len(a)])) + return res + + +def trim(pattern): + for ix in range(len(pattern)): + if pattern[ix] != 0: + return pattern[ix:] + + +def pat_to_binary(pattern): + return b''.join(struct.pack('B', x) for x in pattern) + + +class Hyph: + + def __init__(self): + self.root = Node() + self.root.str = '' + self.node_list = [self.root] + + # Add a pattern (word fragment with numeric codes, such as ".ad4der") + def add_pat(self, pat): + lastWasLetter = False + haveSeenNumber = False + result = [] + word = '' + for c in pat: + if c.isdigit(): + result.append(int(c)) + lastWasLetter = False + haveSeenNumber = True + else: + word += c + if lastWasLetter and haveSeenNumber: + result.append(0) + lastWasLetter = True + if lastWasLetter: + result.append(0) + + self.add_word_res(word, result) + + # Add an exception (word with hyphens, such as "ta-ble") + def add_exception(self, hyph_word): + res = [] + word = ['.'] + need_10 = False + for c in hyph_word: + if c == '-': + res.append(11) + need_10 = False + else: + if need_10: + res.append(10) + word.append(c) + need_10 = True + word.append('.') + res.append(0) + res.append(0) + if VERBOSE: + print(word, res) + self.add_word_res(''.join(word), res) + + def add_word_res(self, word, result): + if VERBOSE: + print(word, result) + + t = self.root + s = '' + for c in word: + s += c + if c not in t.succ: + new_node = Node() + new_node.str = s + self.node_list.append(new_node) + t.succ[c] = new_node + t = t.succ[c] + t.res = result + + def pack(self, node_list, ch_map, use_node=False): + size = 0 + self.node_map = {} + nodes = Freelist() + edges = Freelist() + edge_start = 1 if use_node else 0 + for node in node_list: + succ = sorted([ch_map[c] + edge_start for c in node.succ.keys()]) + if len(succ): + cursor = 0 + while True: + edge_ix, cursor = edges.next(cursor) + ix = edge_ix - succ[0] + if (ix >= 0 and nodes.is_free(ix) and + all(edges.is_free(ix + s) for s in succ) and + ((not use_node) or edges.is_free(ix))): + break + elif use_node: + ix, _ = edges.next(0) + nodes.is_free(ix) # actually don't need nodes at all when use_node, + # but keep it happy + else: + ix, _ = nodes.next(0) + node.ix = ix + self.node_map[ix] = node + nodes.use(ix) + size = max(size, ix) + if use_node: + edges.use(ix) + for s in succ: + edges.use(ix + s) + size += max(ch_map.values()) + 1 + return size + + # return list of nodes in bfs order + def bfs(self, ch_map): + result = [self.root] + ix = 0 + while ix < len(result): + node = result[ix] + node.bfs_ix = ix + mapped = {} + for c, next in node.succ.items(): + assert ch_map[c] not in mapped, 'duplicate edge ' + node.str + ' ' + hex(ord(c)) + mapped[ch_map[c]] = next + for i in sorted(mapped.keys()): + result.append(mapped[i]) + ix += 1 + self.bfs_order = result + return result + + # suffix compression - convert the trie into an acyclic digraph, merging nodes when + # the subtries are identical + def dedup(self): + uniques = [] + dupmap = {} + dedup_ix = [0] * len(self.bfs_order) + for ix in reversed(range(len(self.bfs_order))): + # construct string representation of node + node = self.bfs_order[ix] + if node.res is None: + s = '' + else: + s = ''.join(str(c) for c in node.res) + for c in sorted(node.succ.keys()): + succ = node.succ[c] + s += ' ' + c + str(dedup_ix[succ.bfs_ix]) + if s in dupmap: + dedup_ix[ix] = dupmap[s] + else: + uniques.append(node) + dedup_ix[ix] = ix + dupmap[s] = dedup_ix[ix] + uniques.reverse() + print(len(uniques), 'unique nodes,', len(self.bfs_order), 'total') + return dedup_ix, uniques + + +# load the ".pat" file, which contains patterns such as a1b2c3 +def load(fn): + hyph = Hyph() + with io.open(fn, encoding='UTF-8') as f: + for l in f: + pat = l.strip() + hyph.add_pat(pat) + return hyph + + +# load the ".chr" file, which contains the alphabet and case pairs, eg "aA", "bB" etc. +def load_chr(fn): + ch_map = {'.': 0} + with io.open(fn, encoding='UTF-8') as f: + for i, l in enumerate(f): + l = l.strip() + if len(l) > 2: + # lowercase maps to multi-character uppercase sequence, ignore uppercase for now + l = l[:1] + else: + assert len(l) == 2, 'expected 2 chars in chr' + for c in l: + ch_map[c] = i + 1 + return ch_map + + +# load exceptions with explicit hyphens +def load_hyp(hyph, fn): + with io.open(fn, encoding='UTF-8') as f: + for l in f: + hyph.add_exception(l.strip()) + + +def generate_header(alphabet, trie, pattern): + alphabet_off = 6 * 4 + trie_off = alphabet_off + len(alphabet) + pattern_off = trie_off + len(trie) + file_size = pattern_off + len(pattern) + data = [0x62ad7968, 0, alphabet_off, trie_off, pattern_off, file_size] + return struct.pack('<6I', *data) + + +def generate_alphabet(ch_map): + ch_map = ch_map.copy() + del ch_map['.'] + min_ch = ord(min(ch_map)) + max_ch = ord(max(ch_map)) + if max_ch - min_ch < 1024 and max(ch_map.values()) < 256: + # generate format 0 + data = [0] * (max_ch - min_ch + 1) + for c, val in ch_map.items(): + data[ord(c) - min_ch] = val + result = [struct.pack('<3I', 0, min_ch, max_ch + 1)] + for b in data: + result.append(struct.pack('> 26 + pat_shift = (entry >> 20) & 0x1f + offset = pattern_offset + (entry & 0xfffff) + return pattern_data[offset: offset + pat_len] + b'\0' * pat_shift + + +def traverse_trie(ix, s, trie_data, ch_map, pattern_data, patterns, exceptions): + (char_mask, link_shift, link_mask, pattern_shift) = struct.unpack('<4I', trie_data[4:20]) + node_entry = struct.unpack('> pattern_shift + if pattern: + result = [] + is_exception = False + pat = get_pattern(pattern_data, pattern) + for i in range(len(s) + 1): + pat_off = i - 1 + len(pat) - len(s) + if pat_off < 0: + code = 0 + else: + code = struct.unpack('B', pat[pat_off : pat_off + 1])[0] + if 1 <= code <= 9: + result.append('%d' % code) + elif code == 10: + is_exception = True + elif code == 11: + result.append('-') + is_exception = True + else: + assert code == 0, 'unexpected code' + if i < len(s): + result.append(s[i]) + pat_str = ''.join(result) + #print(`pat_str`, `pat`) + if is_exception: + assert pat_str[0] == '.', "expected leading '.'" + assert pat_str[-1] == '.', "expected trailing '.'" + exceptions.append(pat_str[1:-1]) # strip leading and trailing '.' + else: + patterns.append(pat_str) + for ch in ch_map: + edge_entry = struct.unpack('> link_shift + if link != 0 and ch == (edge_entry & char_mask): + sch = s + ch_map[ch] + traverse_trie(link, sch, trie_data, ch_map, pattern_data, patterns, exceptions) + + +# Verify the generated binary file by reconstructing the textual representations +# from the binary hyb file, then checking that they're identical (mod the order of +# lines within the file, which is irrelevant). This function makes assumptions that +# are stronger than absolutely necessary (in particular, that the patterns are in +# lowercase as defined by python islower). +def verify_hyb_file(hyb_fn, pat_fn, chr_fn, hyp_fn): + with open(hyb_fn, 'rb') as f: + hyb_data = f.read() + header = hyb_data[0: 6 * 4] + (magic, version, alphabet_off, trie_off, pattern_off, file_size) = struct.unpack('<6I', header) + alphabet_data = hyb_data[alphabet_off:trie_off] + trie_data = hyb_data[trie_off:pattern_off] + pattern_data = hyb_data[pattern_off:file_size] + + # reconstruct alphabet table + alphabet_version = struct.unpack('> 11)] = entry & 0x7ff + + ch_map, reconstructed_chr = map_to_chr(alphabet_map) + + # EXCEPTION for Armenian (hy), we don't really deal with the uppercase form of U+0587 + if u'\u0587' in reconstructed_chr: + reconstructed_chr.remove(u'\u0587') + reconstructed_chr.append(u'\u0587\u0535\u0552') + + assert verify_file_sorted(reconstructed_chr, chr_fn), 'alphabet table not verified' + + # reconstruct trie + patterns = [] + exceptions = [] + traverse_trie(0, '', trie_data, ch_map, pattern_data, patterns, exceptions) + assert verify_file_sorted(patterns, pat_fn), 'pattern table not verified' + assert verify_file_sorted(exceptions, hyp_fn), 'exception table not verified' + + +def main(): + global VERBOSE + try: + opts, args = getopt.getopt(sys.argv[1:], 'v') + except getopt.GetoptError as err: + print(str(err)) + sys.exit(1) + for o, _ in opts: + if o == '-v': + VERBOSE = True + pat_fn, out_fn = args + hyph = load(pat_fn) + if pat_fn.endswith('.pat.txt'): + chr_fn = pat_fn[:-8] + '.chr.txt' + ch_map = load_chr(chr_fn) + hyp_fn = pat_fn[:-8] + '.hyp.txt' + load_hyp(hyph, hyp_fn) + generate_hyb_file(hyph, ch_map, out_fn) + verify_hyb_file(out_fn, pat_fn, chr_fn, hyp_fn) + +if __name__ == '__main__': + main() From 179d763488f9e4ddcc94e3e844bfb0d796974f97 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 30 Sep 2015 23:26:54 -0700 Subject: [PATCH 107/364] Explicitly set utf-8 encoding for hyb file verification Not all platforms default to UTF-8 encoding, so we set it explicitly. This patch should fix build breakages resulting from failed verification of binary hyb files for hyphenation patterns. Change-Id: I65ac4536d3436586c2633e2b57554fc6ff16d3a8 --- engine/src/flutter/tools/mk_hyb_file.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/tools/mk_hyb_file.py b/engine/src/flutter/tools/mk_hyb_file.py index c078454e6b..978c082b27 100755 --- a/engine/src/flutter/tools/mk_hyb_file.py +++ b/engine/src/flutter/tools/mk_hyb_file.py @@ -416,7 +416,7 @@ def generate_hyb_file(hyph, ch_map, hyb_fn): # Verify that the file contains the same lines as the lines argument, in arbitrary order def verify_file_sorted(lines, fn): - file_lines = [l.strip() for l in io.open(fn)] + file_lines = [l.strip() for l in io.open(fn, encoding='UTF-8')] line_set = set(lines) file_set = set(file_lines) if line_set == file_set: From ad9cb5909a84f8b8c298d8e0d78e7394fe4803d6 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 24 Sep 2015 18:41:41 +0900 Subject: [PATCH 108/364] Introduce FontFamily::hasVariationSelector This CL introduces new method hasVariationSelector into FontFamily but it is not used in production code. So no behavior changes are expected. This CL contains the following changes: - Introduce hasVariationSelector which returns true if the corresponding font has a glyph for a code point and variation selector pair. - Introduce purgeHbFontCache since hb_face_t won't be released by keeping hb_font_t. - Introduce unit tests with self-built font. Change-Id: I659a6d03d9ec446b409e1fba2758452abb9f44fa --- .../flutter/include/minikin/FontCollection.h | 4 + .../src/flutter/include/minikin/FontFamily.h | 17 ++- .../flutter/libs/minikin/FontCollection.cpp | 7 + .../src/flutter/libs/minikin/FontFamily.cpp | 25 ++++ engine/src/flutter/libs/minikin/Layout.cpp | 2 + engine/src/flutter/tests/Android.mk | 1 + engine/src/flutter/tests/FontFamilyTest.cpp | 122 ++++++++++++++++++ engine/src/flutter/tests/how_to_run.txt | 1 + 8 files changed, 177 insertions(+), 2 deletions(-) create mode 100644 engine/src/flutter/tests/FontFamilyTest.cpp diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index ffdb4d1819..c4daf98fa6 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -47,6 +47,10 @@ public: FakedFont baseFontFaked(FontStyle style); uint32_t getId() const; + + // Calls each managed font family's FontFamily::purgeHbFontCache method. + // Caller should acquire a lock before calling the method. + void purgeFontFamilyHbFontCache() const; private: static const int kLogCharsPerPage = 8; static const int kPageMask = (1 << kLogCharsPerPage) - 1; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index d21a20af71..b1994042e3 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -19,6 +19,7 @@ #include #include +#include #include @@ -123,9 +124,9 @@ struct FakedFont { class FontFamily : public MinikinRefCounted { public: - FontFamily() { } + FontFamily() : mHbFont(nullptr) { } - FontFamily(FontLanguage lang, int variant) : mLang(lang), mVariant(variant) { + FontFamily(FontLanguage lang, int variant) : mLang(lang), mVariant(variant), mHbFont(nullptr) { } ~FontFamily(); @@ -147,6 +148,16 @@ public: // Get Unicode coverage. Lifetime of returned bitset is same as receiver. May return nullptr on // error. const SparseBitSet* getCoverage(); + + // Returns true if the font has a glyph for the code point and variation selector pair. + // Caller should acquire a lock before calling the method. + bool hasVariationSelector(uint32_t codepoint, uint32_t variationSelector); + + // Purges cached mHbFont. + // hb_font_t keeps a reference to hb_face_t which is managed by HbFaceCache. Thus, + // it is good to purge hb_font_t once it is no longer necessary. + // Caller should acquire a lock before calling the method. + void purgeHbFontCache(); private: void addFontLocked(MinikinFont* typeface, FontStyle style); @@ -163,6 +174,8 @@ private: SparseBitSet mCoverage; bool mCoverageValid; + + hb_font_t* mHbFont; }; } // namespace android diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index b4bfe313ba..36d47ded9d 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -233,4 +233,11 @@ uint32_t FontCollection::getId() const { return mId; } +void FontCollection::purgeFontFamilyHbFontCache() const { + assertMinikinLocked(); + for (size_t i = 0; i < mFamilies.size(); ++i) { + mFamilies[i]->purgeHbFontCache(); + } +} + } // namespace android diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index c70cf88023..a6632e0339 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -20,6 +20,10 @@ #include #include +#include +#include + +#include "HbFaceCache.h" #include "MinikinInternal.h" #include #include @@ -229,4 +233,25 @@ const SparseBitSet* FontFamily::getCoverage() { return &mCoverage; } +bool FontFamily::hasVariationSelector(uint32_t codepoint, uint32_t variationSelector) { + assertMinikinLocked(); + if (!mHbFont) { + const FontStyle defaultStyle; + MinikinFont* minikinFont = getClosestMatch(defaultStyle).font; + hb_face_t* face = getHbFaceLocked(minikinFont); + mHbFont = hb_font_create(face); + hb_ot_font_set_funcs(mHbFont); + } + uint32_t unusedGlyph; + return hb_font_get_glyph(mHbFont, codepoint, variationSelector, &unusedGlyph); +} + +void FontFamily::purgeHbFontCache() { + assertMinikinLocked(); + if (mHbFont) { + hb_font_destroy(mHbFont); + mHbFont = nullptr; + } +} + } // namespace android diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 63841515bf..6d62d5d7d8 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -131,6 +131,7 @@ public: layout->setFontCollection(collection); layout->mAdvances.resize(mCount, 0); ctx->clearHbFonts(); + collection->purgeFontFamilyHbFontCache(); layout->doLayoutRun(mChars, mStart, mCount, mNchars, mIsRtl, ctx); } @@ -595,6 +596,7 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu start); } ctx.clearHbFonts(); + mCollection->purgeFontFamilyHbFontCache(); } void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index b4d5e91bc3..b69b8f243f 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -40,6 +40,7 @@ LOCAL_STATIC_LIBRARIES += \ LOCAL_SRC_FILES += \ FontCollectionItemizeTest.cpp \ + FontFamilyTest.cpp \ FontTestUtils.cpp \ MinikinFontForTest.cpp \ GraphemeBreakTests.cpp \ diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp new file mode 100644 index 0000000000..a6813f013b --- /dev/null +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -0,0 +1,122 @@ +/* + * 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. + */ + +#include + +#include +#include "MinikinFontForTest.h" +#include "MinikinInternal.h" + +namespace android { + +// The test font has following glyphs. +// U+82A6 +// U+82A6 U+FE00 (VS1) +// U+82A6 U+E0100 (VS17) +// U+82A6 U+E0101 (VS18) +// U+82A6 U+E0102 (VS19) +// U+845B +// U+845B U+FE00 (VS2) +// U+845B U+E0101 (VS18) +// U+845B U+E0102 (VS19) +// U+845B U+E0103 (VS20) +// U+537F +// U+717D U+FE02 (VS3) +// U+717D U+E0102 (VS19) +// U+717D U+E0103 (VS20) +const char kVsTestFont[] = "/data/minikin/test/data/VarioationSelectorTest-Regular.ttf"; + +class FontFamilyTest : public testing::Test { +public: + virtual void SetUp() override { + if (access(kVsTestFont, R_OK) != 0) { + FAIL() << "Unable to read " << kVsTestFont << ". " + << "Please prepare the test data directory. " + << "For more details, please see how_to_run.txt."; + } + } +}; + +// Asserts that the font family has glyphs for and only for specified codepoint +// and variationSelector pairs. +void expectVSGlyphs(FontFamily* family, uint32_t codepoint, const std::set& vs) { + for (uint32_t i = 0xFE00; i <= 0xE01EF; ++i) { + // Move to variation selectors supplements after variation selectors. + if (i == 0xFF00) { + i = 0xE0100; + } + if (vs.find(i) == vs.end()) { + EXPECT_FALSE(family->hasVariationSelector(codepoint, i)) + << "Glyph for U+" << std::hex << codepoint << " U+" << i; + } else { + EXPECT_TRUE(family->hasVariationSelector(codepoint, i)) + << "Glyph for U+" << std::hex << codepoint << " U+" << i; + } + + } +} + +TEST_F(FontFamilyTest, hasVariationSelectorTest) { + MinikinFontForTest minikinFont(kVsTestFont); + FontFamily family; + family.addFont(&minikinFont); + + AutoMutex _l(gMinikinLock); + + const uint32_t kVS1 = 0xFE00; + const uint32_t kVS2 = 0xFE01; + const uint32_t kVS3 = 0xFE02; + const uint32_t kVS17 = 0xE0100; + const uint32_t kVS18 = 0xE0101; + const uint32_t kVS19 = 0xE0102; + const uint32_t kVS20 = 0xE0103; + + const uint32_t kSupportedChar1 = 0x82A6; + EXPECT_TRUE(family.getCoverage()->get(kSupportedChar1)); + expectVSGlyphs(&family, kSupportedChar1, std::set({kVS1, kVS17, kVS18, kVS19})); + + const uint32_t kSupportedChar2 = 0x845B; + EXPECT_TRUE(family.getCoverage()->get(kSupportedChar2)); + expectVSGlyphs(&family, kSupportedChar2, std::set({kVS2, kVS18, kVS19, kVS20})); + + const uint32_t kNoVsSupportedChar = 0x537F; + EXPECT_TRUE(family.getCoverage()->get(kNoVsSupportedChar)); + expectVSGlyphs(&family, kNoVsSupportedChar, std::set()); + + const uint32_t kVsOnlySupportedChar = 0x717D; + EXPECT_FALSE(family.getCoverage()->get(kVsOnlySupportedChar)); + expectVSGlyphs(&family, kVsOnlySupportedChar, std::set({kVS3, kVS19, kVS20})); + + const uint32_t kNotSupportedChar = 0x845C; + EXPECT_FALSE(family.getCoverage()->get(kNotSupportedChar)); + expectVSGlyphs(&family, kNotSupportedChar, std::set()); +} + +TEST_F(FontFamilyTest, hasVariationSelectorWorksAfterpurgeHbFontCache) { + MinikinFontForTest minikinFont(kVsTestFont); + FontFamily family; + family.addFont(&minikinFont); + + const uint32_t kVS1 = 0xFE00; + const uint32_t kSupportedChar1 = 0x82A6; + + AutoMutex _l(gMinikinLock); + EXPECT_TRUE(family.hasVariationSelector(kSupportedChar1, kVS1)); + + family.purgeHbFontCache(); + EXPECT_TRUE(family.hasVariationSelector(kSupportedChar1, kVS1)); +} +} // namespace android diff --git a/engine/src/flutter/tests/how_to_run.txt b/engine/src/flutter/tests/how_to_run.txt index a6b7952855..09c3b0614e 100644 --- a/engine/src/flutter/tests/how_to_run.txt +++ b/engine/src/flutter/tests/how_to_run.txt @@ -1,4 +1,5 @@ mmm -j8 frameworks/minikin/tests && adb push $OUT/data/nativetest/minikin_tests/minikin_tests \ /data/nativetest/minikin_tests/minikin_tests && +adb push -p frameworks/minikin/tests/data /data/minikin/test/data && adb shell /data/nativetest/minikin_tests/minikin_tests From 9036c194b04f921f35a7b7c064f88bba565c63b3 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 27 Aug 2015 13:50:00 -0700 Subject: [PATCH 109/364] Binary format for hyphenation patterns In the current state, hyphenation in all languages than Sanskrit seems to work (case-folding edge cases). Thus, we just disable Sanskrit. Packed tries are implemented, but not the finite state machine (space/speed tradeoff). This commit contains a throw-away test app, which runs on the host. I think I want to replace it with unit tests, but I'm including it in the CL because it's useful during development. Bug: 21562869 Bug: 21826930 Bug: 23317038 Bug: 23317904 Bug: 24570591 Change-Id: I7479a565a4a062fa319651c2c14c0fa18c5ceaea (cherry picked from commit 96df754284ff81f0a25e7edd486bf7bd85a59fdf) --- engine/src/flutter/app/Android.mk | 36 ++ engine/src/flutter/app/HyphTool.cpp | 62 ++ engine/src/flutter/doc/hyb_file_format.md | 135 +++++ .../src/flutter/include/minikin/Hyphenator.h | 41 +- engine/src/flutter/libs/minikin/Android.mk | 25 + .../src/flutter/libs/minikin/Hyphenator.cpp | 276 +++++---- engine/src/flutter/tools/mk_hyb_file.py | 567 ++++++++++++++++++ 7 files changed, 1030 insertions(+), 112 deletions(-) create mode 100644 engine/src/flutter/app/Android.mk create mode 100644 engine/src/flutter/app/HyphTool.cpp create mode 100644 engine/src/flutter/doc/hyb_file_format.md create mode 100755 engine/src/flutter/tools/mk_hyb_file.py diff --git a/engine/src/flutter/app/Android.mk b/engine/src/flutter/app/Android.mk new file mode 100644 index 0000000000..2038683027 --- /dev/null +++ b/engine/src/flutter/app/Android.mk @@ -0,0 +1,36 @@ +# 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. + +# see how_to_run.txt for instructions on running these tests + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_MODULE := hyphtool +LOCAL_MODULE_TAGS := optional + +LOCAL_STATIC_LIBRARIES := libminikin_host + +# Shared libraries which are dependencies of minikin; these are not automatically +# pulled in by the build system (and thus sadly must be repeated). + +LOCAL_SHARED_LIBRARIES := \ + liblog \ + libicuuc-host + +LOCAL_SRC_FILES += \ + HyphTool.cpp + +include $(BUILD_HOST_EXECUTABLE) diff --git a/engine/src/flutter/app/HyphTool.cpp b/engine/src/flutter/app/HyphTool.cpp new file mode 100644 index 0000000000..730abadcba --- /dev/null +++ b/engine/src/flutter/app/HyphTool.cpp @@ -0,0 +1,62 @@ +#include +#include +#include + +#include "utils/Log.h" + +#include +#include + +using android::Hyphenator; + +Hyphenator* loadHybFile(const char* fn) { + struct stat statbuf; + int status = stat(fn, &statbuf); + if (status < 0) { + fprintf(stderr, "error opening %s\n", fn); + return nullptr; + } + size_t size = statbuf.st_size; + FILE* f = fopen(fn, "rb"); + if (f == NULL) { + fprintf(stderr, "error opening %s\n", fn); + return nullptr; + } + uint8_t* buf = new uint8_t[size]; + size_t read_size = fread(buf, 1, size, f); + if (read_size < size) { + fprintf(stderr, "error reading %s\n", fn); + delete[] buf; + return nullptr; + } + return Hyphenator::loadBinary(buf); +} + +int main(int argc, char** argv) { + Hyphenator* hyph = loadHybFile("/tmp/en.hyb"); // should also be configurable + std::vector result; + std::vector word; + if (argc < 2) { + fprintf(stderr, "usage: hyphtool word\n"); + return 1; + } + char* asciiword = argv[1]; + size_t len = strlen(asciiword); + for (size_t i = 0; i < len; i++) { + uint32_t c = asciiword[i]; + if (c == '-') { + c = 0x00AD; + } + // ASCII (or possibly ISO Latin 1), but kinda painful to do utf conversion :( + word.push_back(c); + } + hyph->hyphenate(&result, word.data(), word.size()); + for (size_t i = 0; i < len; i++) { + if (result[i] != 0) { + printf("-"); + } + printf("%c", word[i]); + } + printf("\n"); + return 0; +} diff --git a/engine/src/flutter/doc/hyb_file_format.md b/engine/src/flutter/doc/hyb_file_format.md new file mode 100644 index 0000000000..3065a6f5cc --- /dev/null +++ b/engine/src/flutter/doc/hyb_file_format.md @@ -0,0 +1,135 @@ +# Hyb (hyphenation pattern binary) file format + +The hyb file format is how hyphenation patterns are stored in the system image. + +Goals include: + +* Concise (system image space is at a premium) +* Usable when mmap'ed, so it doesn't take significant physical RAM +* Fast to compute +* Simple + +It is _not_ intended as an interchange format, so there is no attempt to make the format +extensible or facilitate backward and forward compatibility. + +Further, at some point we will probably pack patterns for multiple languages into a single +physical file, to reduce number of open mmap'ed files. This document doesn't cover that. + +## Theoretical basis + +At heart, the file contains packed tries with suffix compression, actually quite similar +to the implementation in TeX. + +The file contains three sections. The first section represents the "alphabet," including +case folding. It is effectively a map from Unicode code point to a small integer. + +The second section contains the trie in packed form. It is an array of 3-tuples, packed +into a 32 bit integer. Each (suffix-compressed) trie node has a unique index within this +array, and the pattern field in the tuple is the pattern for that node. Further, each edge +in the trie has an entry in the array, and the character and link fields in the tuple +represent the label and destination of the edge. The packing strategy is as in +[Word Hy-phen-a-tion by Com-put-er](http://www.tug.org/docs/liang/liang-thesis.pdf) by +Franklin Mark Liang. + +The trie representation is similar but not identical to the "double-array trie". +The fundamental operation of lookup of the edge from `s` to `t` with label `c` is +to compare `c == character[s + c]`, and if so, `t = link[s + c]`. + +The third section contains the pattern strings. This section is in two parts: first, +an array with a 3-tuple for each pattern (length, number of trailing 0's, and offset +into the string pool); and second, the string pool. Each pattern is encoded as a byte +(packing 2 per byte would be possible but the space savings would not be signficant). + +As much as possible of the file is represented as 32 bit integers, as that is especially +efficent to access. All are little-endian (this could be revised if the code ever needs +to be ported to big-endian systems). + +## Header + +``` +uint32_t magic == 0x62ad7968 +uint32_t version = 0 +uint32_t alphabet_offset (in bytes) +uint32_t trie_offset (in bytes) +uint32_t pattern_offset (in bytes) +uint32_t file_size (in bytes) +``` + +Offsets are from the front of the file, and in bytes. + +## Alphabet + +The alphabet table comes in two versions. The first is well suited to dense Unicode +ranges and is limited to 256. The second is more general, but lookups will be slower. + +### Alphabet, direct version + +``` +uint32_t version = 0 +uint32_t min_codepoint +uint32_t max_codepoint (exclusive) +uint8_t[] data +``` + +The size of the data array is max_codepoint - min_codepoint. 0 represents an unmapped +character. Note that, in the current implementation, automatic hyphenation is disabled +for any word containing an unmapped character. + +In general, pad bytes follow this table, aligning the next table to a 4-byte boundary. + +### Alphabet, general version + +``` +uint32_t version = 1 +uint32_t n_entries +uint32_t[n_entries] data +``` + +Each element in the data table is `(codepoint << 11) | value`. Note that this is +restricted to 11 bits (2048 possible values). The largest known current value is 483 +(for Sanskrit). + +The entries are sorted by codepoint, to facilitate binary search. Another reasonable +implementation for consumers of the data would be to build a hash table at load time. + +## Trie + +``` +uint32_t version = 0 +uint32_t char_mask +uint32_t link_shift +uint32_t link_mask +uint32_t pattern_shift +uint32_t n_entries +uint32_t[n_entries] data +``` + +Each element in the data table is `(pattern << pattern_shift) | (link << link_shift) | char`. + +All known pattern tables fit in 32 bits total. If this is exceeded, there is a fairly +straightforward tweak, where each node occupies a slot by itself (as opposed to sharing +it with edge slots), which would require very minimal changes to the implementation (TODO +present in more detail). + +## Pattern + +``` +uint32_t version = 0 +uint32_t n_entries +uint32_t pattern_offset (in bytes) +uint32_t pattern_size (in bytes) +uint32_t[n_entries] data +uint8_t[] pattern_buf +``` + +Each element in data table is `(len << 26) | (shift << 20) | offset`, where an offset of 0 +points to the first byte of pattern_buf. + +Generally pattern_offset is `16 + 4 * n_entries`. + +For example, 'a4m5ato' would be represented as `[4, 5, 0, 0, 0]`, then len = 2, shift = 3, and +offset points to [4, 5] in the pattern buffer. + +Future extension: additional data representing nonstandard hyphenation. See +[Automatic non-standard hyphenation in OpenOffice.org](https://www.tug.org/TUGboat/tb27-1/tb86nemeth.pdf) +for more information about that issue. diff --git a/engine/src/flutter/include/minikin/Hyphenator.h b/engine/src/flutter/include/minikin/Hyphenator.h index 581c657fbe..9605205a29 100644 --- a/engine/src/flutter/include/minikin/Hyphenator.h +++ b/engine/src/flutter/include/minikin/Hyphenator.h @@ -26,11 +26,8 @@ namespace android { -class Trie { -public: - std::vector result; - std::unordered_map succ; -}; +// hyb file header; implementation details are in the .cpp file +struct Header; class Hyphenator { public: @@ -44,19 +41,43 @@ public: // Example: word is "hyphen", result is [0 0 1 0 0 0], corresponding to "hy-phen". void hyphenate(std::vector* result, const uint16_t* word, size_t len); -private: - void addPattern(const uint16_t* pattern, size_t size); + // pattern data is in binary format, as described in doc/hyb_file_format.md. Note: + // the caller is responsible for ensuring that the lifetime of the pattern data is + // at least as long as the Hyphenator object. - void hyphenateSoft(std::vector* result, const uint16_t* word, size_t len); + // Note: nullptr is valid input, in which case the hyphenator only processes soft hyphens + static Hyphenator* loadBinary(const uint8_t* patternData); + +private: + // apply soft hyphens only, ignoring patterns + void hyphenateSoft(uint8_t* result, const uint16_t* word, size_t len); + + // try looking up word in alphabet table, return false if any code units fail to map + // Note that this methor writes len+2 entries into alpha_codes (including start and stop) + bool alphabetLookup(uint16_t* alpha_codes, const uint16_t* word, size_t len); + + // calculate hyphenation from patterns, assuming alphabet lookup has already been done + void hyphenateFromCodes(uint8_t* result, const uint16_t* codes, size_t len); // TODO: these should become parameters, as they might vary by locale, screen size, and // possibly explicit user control. static const int MIN_PREFIX = 2; static const int MIN_SUFFIX = 3; - Trie root; + // See also LONGEST_HYPHENATED_WORD in LineBreaker.cpp. Here the constant is used so + // that temporary buffers can be stack-allocated without waste, which is a slightly + // different use case. It measures UTF-16 code units. + static const size_t MAX_HYPHENATED_SIZE = 64; + + const uint8_t* patternData; + + // accessors for binary data + const Header* getHeader() const { + return reinterpret_cast(patternData); + } + }; } // namespace android -#endif // MINIKIN_HYPHENATOR_H \ No newline at end of file +#endif // MINIKIN_HYPHENATOR_H diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 873f279f0c..7558f83aa5 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -48,3 +48,28 @@ LOCAL_SHARED_LIBRARIES := \ libutils include $(BUILD_SHARED_LIBRARY) + +include $(CLEAR_VARS) + +LOCAL_MODULE := libminikin +LOCAL_MODULE_TAGS := optional +LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include +LOCAL_SRC_FILES := $(minikin_src_files) +LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) + +include $(BUILD_STATIC_LIBRARY) + +include $(CLEAR_VARS) + +# Reduced library (currently just hyphenation) for host + +LOCAL_MODULE := libminikin_host +LOCAL_MODULE_TAGS := optional +LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include +LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_SHARED_LIBRARIES := liblog libicuuc-host + +LOCAL_SRC_FILES := Hyphenator.cpp + +include $(BUILD_HOST_STATIC_LIBRARY) diff --git a/engine/src/flutter/libs/minikin/Hyphenator.cpp b/engine/src/flutter/libs/minikin/Hyphenator.cpp index 3eb151b9e0..c5eb60b8e5 100644 --- a/engine/src/flutter/libs/minikin/Hyphenator.cpp +++ b/engine/src/flutter/libs/minikin/Hyphenator.cpp @@ -34,130 +34,202 @@ namespace android { static const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; -void Hyphenator::addPattern(const uint16_t* pattern, size_t size) { - vector word; - vector result; +// The following are structs that correspond to tables inside the hyb file format - // start by parsing the Liang-format pattern into a word and a result vector, the - // vector right-aligned but without leading zeros. Examples: - // a1bc2d -> abcd [1, 0, 2, 0] - // abc1 -> abc [1] - // 1a2b3c4d5 -> abcd [1, 2, 3, 4, 5] - bool lastWasLetter = false; - bool haveSeenNumber = false; - for (size_t i = 0; i < size; i++) { - uint16_t c = pattern[i]; - if (isdigit(c)) { - result.push_back(c - '0'); - lastWasLetter = false; - haveSeenNumber = true; - } else { - word.push_back(c); - if (lastWasLetter && haveSeenNumber) { - result.push_back(0); - } - lastWasLetter = true; - } - } - if (lastWasLetter) { - result.push_back(0); - } - Trie* t = &root; - for (size_t i = 0; i < word.size(); i++) { - t = &t->succ[word[i]]; - } - t->result = result; -} +struct AlphabetTable0 { + uint32_t version; + uint32_t min_codepoint; + uint32_t max_codepoint; + uint8_t data[1]; // actually flexible array, size is known at runtime +}; -// If any soft hyphen is present in the word, use soft hyphens to decide hyphenation, -// as recommended in UAX #14 (Use of Soft Hyphen) -void Hyphenator::hyphenateSoft(vector* result, const uint16_t* word, size_t len) { - (*result)[0] = 0; - for (size_t i = 1; i < len; i++) { - (*result)[i] = word[i - 1] == CHAR_SOFT_HYPHEN; +struct AlphabetTable1 { + uint32_t version; + uint32_t n_entries; + uint32_t data[1]; // actually flexible array, size is known at runtime + + static uint32_t codepoint(uint32_t entry) { return entry >> 11; } + static uint32_t value(uint32_t entry) { return entry & 0x7ff; } +}; + +struct Trie { + uint32_t version; + uint32_t char_mask; + uint32_t link_shift; + uint32_t link_mask; + uint32_t pattern_shift; + uint32_t n_entries; + uint32_t data[1]; // actually flexible array, size is known at runtime +}; + +struct Pattern { + uint32_t version; + uint32_t n_entries; + uint32_t pattern_offset; + uint32_t pattern_size; + uint32_t data[1]; // actually flexible array, size is known at runtime + + // accessors + static uint32_t len(uint32_t entry) { return entry >> 26; } + static uint32_t shift(uint32_t entry) { return (entry >> 20) & 0x3f; } + const uint8_t* buf(uint32_t entry) const { + return reinterpret_cast(this) + pattern_offset + (entry & 0xfffff); } +}; + +struct Header { + uint32_t magic; + uint32_t version; + uint32_t alphabet_offset; + uint32_t trie_offset; + uint32_t pattern_offset; + uint32_t file_size; + + // accessors + const uint8_t* bytes() const { return reinterpret_cast(this); } + uint32_t alphabetVersion() const { + return *reinterpret_cast(bytes() + alphabet_offset); + } + const AlphabetTable0* alphabetTable0() const { + return reinterpret_cast(bytes() + alphabet_offset); + } + const AlphabetTable1* alphabetTable1() const { + return reinterpret_cast(bytes() + alphabet_offset); + } + const Trie* trieTable() const { + return reinterpret_cast(bytes() + trie_offset); + } + const Pattern* patternTable() const { + return reinterpret_cast(bytes() + pattern_offset); + } +}; + +Hyphenator* Hyphenator::loadBinary(const uint8_t* patternData) { + Hyphenator* result = new Hyphenator; + result->patternData = patternData; + return result; } void Hyphenator::hyphenate(vector* result, const uint16_t* word, size_t len) { result->clear(); result->resize(len); - if (len < MIN_PREFIX + MIN_SUFFIX) return; - size_t maxOffset = len - MIN_SUFFIX + 1; - for (size_t i = 0; i < len + 1; i++) { - const Trie* node = &root; - for (size_t j = i; j < len + 2; j++) { - uint16_t c; - if (j == 0 || j == len + 1) { - c = '.'; // word boundary character in pattern data files - } else { - c = word[j - 1]; - if (c == CHAR_SOFT_HYPHEN) { - hyphenateSoft(result, word, len); - return; - } - // TODO: This uses ICU's simple character to character lowercasing, which ignores - // the locale, and ignores cases when lowercasing a character results in more than - // one character. It should be fixed to consider the locale (in order for it to work - // correctly for Turkish and Azerbaijani), as well as support one-to-many, and - // many-to-many case conversions (including non-BMP cases). - if (c < 0x00C0) { // U+00C0 is the lowest uppercase non-ASCII character - // Convert uppercase ASCII to lowercase ASCII, but keep other characters as-is - if (0x0041 <= c && c <= 0x005A) { - c += 0x0020; - } - } else { - c = u_tolower(c); - } + const size_t paddedLen = len + 2; // start and stop code each count for 1 + if (patternData != nullptr && + (int)len >= MIN_PREFIX + MIN_SUFFIX && paddedLen <= MAX_HYPHENATED_SIZE) { + uint16_t alpha_codes[MAX_HYPHENATED_SIZE]; + if (alphabetLookup(alpha_codes, word, len)) { + hyphenateFromCodes(result->data(), alpha_codes, paddedLen); + return; + } + // TODO: try NFC normalization + // TODO: handle non-BMP Unicode (requires remapping of offsets) + } + hyphenateSoft(result->data(), word, len); +} + +// If any soft hyphen is present in the word, use soft hyphens to decide hyphenation, +// as recommended in UAX #14 (Use of Soft Hyphen) +void Hyphenator::hyphenateSoft(uint8_t* result, const uint16_t* word, size_t len) { + result[0] = 0; + for (size_t i = 1; i < len; i++) { + result[i] = word[i - 1] == CHAR_SOFT_HYPHEN; + } +} + +bool Hyphenator::alphabetLookup(uint16_t* alpha_codes, const uint16_t* word, size_t len) { + const Header* header = getHeader(); + // TODO: check header magic + uint32_t alphabetVersion = header->alphabetVersion(); + if (alphabetVersion == 0) { + const AlphabetTable0* alphabet = header->alphabetTable0(); + uint32_t min_codepoint = alphabet->min_codepoint; + uint32_t max_codepoint = alphabet->max_codepoint; + alpha_codes[0] = 0; // word start + for (size_t i = 0; i < len; i++) { + uint16_t c = word[i]; + if (c < min_codepoint || c >= max_codepoint) { + return false; } - auto search = node->succ.find(c); - if (search != node->succ.end()) { - node = &search->second; + uint8_t code = alphabet->data[c - min_codepoint]; + if (code == 0) { + return false; + } + alpha_codes[i + 1] = code; + } + alpha_codes[len + 1] = 0; // word termination + return true; + } else if (alphabetVersion == 1) { + const AlphabetTable1* alphabet = header->alphabetTable1(); + size_t n_entries = alphabet->n_entries; + const uint32_t* begin = alphabet->data; + const uint32_t* end = begin + n_entries; + alpha_codes[0] = 0; + for (size_t i = 0; i < len; i++) { + uint16_t c = word[i]; + auto p = std::lower_bound(begin, end, c << 11); + if (p == end) { + return false; + } + uint32_t entry = *p; + if (AlphabetTable1::codepoint(entry) != c) { + return false; + } + alpha_codes[i + 1] = AlphabetTable1::value(entry); + } + alpha_codes[len + 1] = 0; + return true; + } + return false; +} + +/** + * Internal implementation, after conversion to codes. All case folding and normalization + * has been done by now, and all characters have been found in the alphabet. + * Note: len here is the padded length including 0 codes at start and end. + **/ +void Hyphenator::hyphenateFromCodes(uint8_t* result, const uint16_t* codes, size_t len) { + const Header* header = getHeader(); + const Trie* trie = header->trieTable(); + const Pattern* pattern = header->patternTable(); + uint32_t char_mask = trie->char_mask; + uint32_t link_shift = trie->link_shift; + uint32_t link_mask = trie->link_mask; + uint32_t pattern_shift = trie->pattern_shift; + size_t maxOffset = len - MIN_SUFFIX - 1; + for (size_t i = 0; i < len - 1; i++) { + uint32_t node = 0; // index into Trie table + for (size_t j = i; j < len; j++) { + uint16_t c = codes[j]; + uint32_t entry = trie->data[node + c]; + if ((entry & char_mask) == c) { + node = (entry & link_mask) >> link_shift; } else { break; } - if (!node->result.empty()) { - int resultLen = node->result.size(); - int offset = j + 1 - resultLen; + uint32_t pat_ix = trie->data[node] >> pattern_shift; + // pat_ix contains a 3-tuple of length, shift (number of trailing zeros), and an offset + // into the buf pool. This is the pattern for the substring (i..j) we just matched, + // which we combine (via point-wise max) into the result vector. + if (pat_ix != 0) { + uint32_t pat_entry = pattern->data[pat_ix]; + int pat_len = Pattern::len(pat_entry); + int pat_shift = Pattern::shift(pat_entry); + const uint8_t* pat_buf = pattern->buf(pat_entry); + int offset = j + 1 - (pat_len + pat_shift); + // offset is the index within result that lines up with the start of pat_buf int start = std::max(MIN_PREFIX - offset, 0); - int end = std::min(resultLen, (int)maxOffset - offset); - // TODO performance: this inner loop can profitably be optimized + int end = std::min(pat_len, (int)maxOffset - offset); for (int k = start; k < end; k++) { - (*result)[offset + k] = std::max((*result)[offset + k], node->result[k]); + result[offset + k] = std::max(result[offset + k], pat_buf[k]); } -#if 0 - // debug printing of matched patterns - std::string dbg; - for (size_t k = i; k <= j + 1; k++) { - int off = k - j - 2 + resultLen; - if (off >= 0 && node->result[off] != 0) { - dbg.push_back((char)('0' + node->result[off])); - } - if (k < j + 1) { - uint16_t c = (k == 0 || k == len + 1) ? '.' : word[k - 1]; - dbg.push_back((char)c); - } - } - ALOGD("%d:%d %s", i, j, dbg.c_str()); -#endif } } } // Since the above calculation does not modify values outside // [MIN_PREFIX, len - MIN_SUFFIX], they are left as 0. for (size_t i = MIN_PREFIX; i < maxOffset; i++) { - (*result)[i] &= 1; + result[i] &= 1; } } -Hyphenator* Hyphenator::load(const uint16_t *patternData, size_t size) { - Hyphenator* result = new Hyphenator; - for (size_t i = 0; i < size; i++) { - size_t end = i; - while (patternData[end] != '\n') end++; - result->addPattern(patternData + i, end - i); - i = end; - } - return result; -} - } // namespace android diff --git a/engine/src/flutter/tools/mk_hyb_file.py b/engine/src/flutter/tools/mk_hyb_file.py new file mode 100755 index 0000000000..c078454e6b --- /dev/null +++ b/engine/src/flutter/tools/mk_hyb_file.py @@ -0,0 +1,567 @@ +#!/usr/bin/env python + +# 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. + +""" +Convert hyphen files in standard TeX format (a trio of pat, chr, and hyp) +into binary format. See doc/hyb_file_format.md for more information. + +Usage: mk_hyb_file.py [-v] hyph-foo.pat.txt hyph-foo.hyb + +Optional -v parameter turns on verbose debugging. + +""" + +from __future__ import print_function + +import io +import sys +import struct +import math +import getopt + + +VERBOSE = False + + +if sys.version_info[0] >= 3: + def unichr(x): + return chr(x) + + +# number of bits required to represent numbers up to n inclusive +def num_bits(n): + return 1 + int(math.log(n, 2)) if n > 0 else 0 + + +class Node: + + def __init__(self): + self.succ = {} + self.res = None + self.fsm_pat = None + self.fail = None + + +# List of free slots, implemented as doubly linked list +class Freelist: + + def __init__(self): + self.first = None + self.last = None + self.pred = [] + self.succ = [] + + def grow(self): + this = len(self.pred) + self.pred.append(self.last) + self.succ.append(None) + if self.last is None: + self.first = this + else: + self.succ[self.last] = this + self.last = this + + def next(self, cursor): + if cursor == 0: + cursor = self.first + if cursor is None: + self.grow() + result = self.last + else: + result = cursor + return result, self.succ[result] + + def is_free(self, ix): + while ix >= len(self.pred): + self.grow() + return self.pred[ix] != -1 + + def use(self, ix): + if self.pred[ix] is None: + self.first = self.succ[ix] + else: + self.succ[self.pred[ix]] = self.succ[ix] + if self.succ[ix] is None: + self.last = self.pred[ix] + else: + self.pred[self.succ[ix]] = self.pred[ix] + if self.pred[ix] == -1: + assert self.pred[ix] != -1, 'double free!' + self.pred[ix] = -1 + + +def combine(a, b): + if a is None: return b + if b is None: return a + if len(b) < len(a): a, b = b, a + res = b[:len(b) - len(a)] + for i in range(len(a)): + res.append(max(a[i], b[i + len(b) - len(a)])) + return res + + +def trim(pattern): + for ix in range(len(pattern)): + if pattern[ix] != 0: + return pattern[ix:] + + +def pat_to_binary(pattern): + return b''.join(struct.pack('B', x) for x in pattern) + + +class Hyph: + + def __init__(self): + self.root = Node() + self.root.str = '' + self.node_list = [self.root] + + # Add a pattern (word fragment with numeric codes, such as ".ad4der") + def add_pat(self, pat): + lastWasLetter = False + haveSeenNumber = False + result = [] + word = '' + for c in pat: + if c.isdigit(): + result.append(int(c)) + lastWasLetter = False + haveSeenNumber = True + else: + word += c + if lastWasLetter and haveSeenNumber: + result.append(0) + lastWasLetter = True + if lastWasLetter: + result.append(0) + + self.add_word_res(word, result) + + # Add an exception (word with hyphens, such as "ta-ble") + def add_exception(self, hyph_word): + res = [] + word = ['.'] + need_10 = False + for c in hyph_word: + if c == '-': + res.append(11) + need_10 = False + else: + if need_10: + res.append(10) + word.append(c) + need_10 = True + word.append('.') + res.append(0) + res.append(0) + if VERBOSE: + print(word, res) + self.add_word_res(''.join(word), res) + + def add_word_res(self, word, result): + if VERBOSE: + print(word, result) + + t = self.root + s = '' + for c in word: + s += c + if c not in t.succ: + new_node = Node() + new_node.str = s + self.node_list.append(new_node) + t.succ[c] = new_node + t = t.succ[c] + t.res = result + + def pack(self, node_list, ch_map, use_node=False): + size = 0 + self.node_map = {} + nodes = Freelist() + edges = Freelist() + edge_start = 1 if use_node else 0 + for node in node_list: + succ = sorted([ch_map[c] + edge_start for c in node.succ.keys()]) + if len(succ): + cursor = 0 + while True: + edge_ix, cursor = edges.next(cursor) + ix = edge_ix - succ[0] + if (ix >= 0 and nodes.is_free(ix) and + all(edges.is_free(ix + s) for s in succ) and + ((not use_node) or edges.is_free(ix))): + break + elif use_node: + ix, _ = edges.next(0) + nodes.is_free(ix) # actually don't need nodes at all when use_node, + # but keep it happy + else: + ix, _ = nodes.next(0) + node.ix = ix + self.node_map[ix] = node + nodes.use(ix) + size = max(size, ix) + if use_node: + edges.use(ix) + for s in succ: + edges.use(ix + s) + size += max(ch_map.values()) + 1 + return size + + # return list of nodes in bfs order + def bfs(self, ch_map): + result = [self.root] + ix = 0 + while ix < len(result): + node = result[ix] + node.bfs_ix = ix + mapped = {} + for c, next in node.succ.items(): + assert ch_map[c] not in mapped, 'duplicate edge ' + node.str + ' ' + hex(ord(c)) + mapped[ch_map[c]] = next + for i in sorted(mapped.keys()): + result.append(mapped[i]) + ix += 1 + self.bfs_order = result + return result + + # suffix compression - convert the trie into an acyclic digraph, merging nodes when + # the subtries are identical + def dedup(self): + uniques = [] + dupmap = {} + dedup_ix = [0] * len(self.bfs_order) + for ix in reversed(range(len(self.bfs_order))): + # construct string representation of node + node = self.bfs_order[ix] + if node.res is None: + s = '' + else: + s = ''.join(str(c) for c in node.res) + for c in sorted(node.succ.keys()): + succ = node.succ[c] + s += ' ' + c + str(dedup_ix[succ.bfs_ix]) + if s in dupmap: + dedup_ix[ix] = dupmap[s] + else: + uniques.append(node) + dedup_ix[ix] = ix + dupmap[s] = dedup_ix[ix] + uniques.reverse() + print(len(uniques), 'unique nodes,', len(self.bfs_order), 'total') + return dedup_ix, uniques + + +# load the ".pat" file, which contains patterns such as a1b2c3 +def load(fn): + hyph = Hyph() + with io.open(fn, encoding='UTF-8') as f: + for l in f: + pat = l.strip() + hyph.add_pat(pat) + return hyph + + +# load the ".chr" file, which contains the alphabet and case pairs, eg "aA", "bB" etc. +def load_chr(fn): + ch_map = {'.': 0} + with io.open(fn, encoding='UTF-8') as f: + for i, l in enumerate(f): + l = l.strip() + if len(l) > 2: + # lowercase maps to multi-character uppercase sequence, ignore uppercase for now + l = l[:1] + else: + assert len(l) == 2, 'expected 2 chars in chr' + for c in l: + ch_map[c] = i + 1 + return ch_map + + +# load exceptions with explicit hyphens +def load_hyp(hyph, fn): + with io.open(fn, encoding='UTF-8') as f: + for l in f: + hyph.add_exception(l.strip()) + + +def generate_header(alphabet, trie, pattern): + alphabet_off = 6 * 4 + trie_off = alphabet_off + len(alphabet) + pattern_off = trie_off + len(trie) + file_size = pattern_off + len(pattern) + data = [0x62ad7968, 0, alphabet_off, trie_off, pattern_off, file_size] + return struct.pack('<6I', *data) + + +def generate_alphabet(ch_map): + ch_map = ch_map.copy() + del ch_map['.'] + min_ch = ord(min(ch_map)) + max_ch = ord(max(ch_map)) + if max_ch - min_ch < 1024 and max(ch_map.values()) < 256: + # generate format 0 + data = [0] * (max_ch - min_ch + 1) + for c, val in ch_map.items(): + data[ord(c) - min_ch] = val + result = [struct.pack('<3I', 0, min_ch, max_ch + 1)] + for b in data: + result.append(struct.pack('> 26 + pat_shift = (entry >> 20) & 0x1f + offset = pattern_offset + (entry & 0xfffff) + return pattern_data[offset: offset + pat_len] + b'\0' * pat_shift + + +def traverse_trie(ix, s, trie_data, ch_map, pattern_data, patterns, exceptions): + (char_mask, link_shift, link_mask, pattern_shift) = struct.unpack('<4I', trie_data[4:20]) + node_entry = struct.unpack('> pattern_shift + if pattern: + result = [] + is_exception = False + pat = get_pattern(pattern_data, pattern) + for i in range(len(s) + 1): + pat_off = i - 1 + len(pat) - len(s) + if pat_off < 0: + code = 0 + else: + code = struct.unpack('B', pat[pat_off : pat_off + 1])[0] + if 1 <= code <= 9: + result.append('%d' % code) + elif code == 10: + is_exception = True + elif code == 11: + result.append('-') + is_exception = True + else: + assert code == 0, 'unexpected code' + if i < len(s): + result.append(s[i]) + pat_str = ''.join(result) + #print(`pat_str`, `pat`) + if is_exception: + assert pat_str[0] == '.', "expected leading '.'" + assert pat_str[-1] == '.', "expected trailing '.'" + exceptions.append(pat_str[1:-1]) # strip leading and trailing '.' + else: + patterns.append(pat_str) + for ch in ch_map: + edge_entry = struct.unpack('> link_shift + if link != 0 and ch == (edge_entry & char_mask): + sch = s + ch_map[ch] + traverse_trie(link, sch, trie_data, ch_map, pattern_data, patterns, exceptions) + + +# Verify the generated binary file by reconstructing the textual representations +# from the binary hyb file, then checking that they're identical (mod the order of +# lines within the file, which is irrelevant). This function makes assumptions that +# are stronger than absolutely necessary (in particular, that the patterns are in +# lowercase as defined by python islower). +def verify_hyb_file(hyb_fn, pat_fn, chr_fn, hyp_fn): + with open(hyb_fn, 'rb') as f: + hyb_data = f.read() + header = hyb_data[0: 6 * 4] + (magic, version, alphabet_off, trie_off, pattern_off, file_size) = struct.unpack('<6I', header) + alphabet_data = hyb_data[alphabet_off:trie_off] + trie_data = hyb_data[trie_off:pattern_off] + pattern_data = hyb_data[pattern_off:file_size] + + # reconstruct alphabet table + alphabet_version = struct.unpack('> 11)] = entry & 0x7ff + + ch_map, reconstructed_chr = map_to_chr(alphabet_map) + + # EXCEPTION for Armenian (hy), we don't really deal with the uppercase form of U+0587 + if u'\u0587' in reconstructed_chr: + reconstructed_chr.remove(u'\u0587') + reconstructed_chr.append(u'\u0587\u0535\u0552') + + assert verify_file_sorted(reconstructed_chr, chr_fn), 'alphabet table not verified' + + # reconstruct trie + patterns = [] + exceptions = [] + traverse_trie(0, '', trie_data, ch_map, pattern_data, patterns, exceptions) + assert verify_file_sorted(patterns, pat_fn), 'pattern table not verified' + assert verify_file_sorted(exceptions, hyp_fn), 'exception table not verified' + + +def main(): + global VERBOSE + try: + opts, args = getopt.getopt(sys.argv[1:], 'v') + except getopt.GetoptError as err: + print(str(err)) + sys.exit(1) + for o, _ in opts: + if o == '-v': + VERBOSE = True + pat_fn, out_fn = args + hyph = load(pat_fn) + if pat_fn.endswith('.pat.txt'): + chr_fn = pat_fn[:-8] + '.chr.txt' + ch_map = load_chr(chr_fn) + hyp_fn = pat_fn[:-8] + '.hyp.txt' + load_hyp(hyph, hyp_fn) + generate_hyb_file(hyph, ch_map, out_fn) + verify_hyb_file(out_fn, pat_fn, chr_fn, hyp_fn) + +if __name__ == '__main__': + main() From 7635ac1324ebe58f21adc904185f446cec11a97d Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 30 Sep 2015 23:26:54 -0700 Subject: [PATCH 110/364] Explicitly set utf-8 encoding for hyb file verification Not all platforms default to UTF-8 encoding, so we set it explicitly. This patch should fix build breakages resulting from failed verification of binary hyb files for hyphenation patterns. Bug: 24570591 Change-Id: I65ac4536d3436586c2633e2b57554fc6ff16d3a8 (cherry picked from commit 179d763488f9e4ddcc94e3e844bfb0d796974f97) --- engine/src/flutter/tools/mk_hyb_file.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/tools/mk_hyb_file.py b/engine/src/flutter/tools/mk_hyb_file.py index c078454e6b..978c082b27 100755 --- a/engine/src/flutter/tools/mk_hyb_file.py +++ b/engine/src/flutter/tools/mk_hyb_file.py @@ -416,7 +416,7 @@ def generate_hyb_file(hyph, ch_map, hyb_fn): # Verify that the file contains the same lines as the lines argument, in arbitrary order def verify_file_sorted(lines, fn): - file_lines = [l.strip() for l in io.open(fn)] + file_lines = [l.strip() for l in io.open(fn, encoding='UTF-8')] line_set = set(lines) file_set = set(file_lines) if line_set == file_set: From 4f26d114368939d06989de1e54c65227fdbfa843 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Wed, 14 Oct 2015 19:34:29 -0700 Subject: [PATCH 111/364] Complete half-done cherry-picking of Android.mk. DO NOT MERGE The previous commit, 9036c194b04f921f35a7b7c064f88bba565c63b3, was incompletely cherry-picked. This adds the missing parts. Bug: 24570591 Change-Id: I1097c60587fb8a88cfe6b8ffed5b1689d9bdd429 --- engine/src/flutter/libs/minikin/Android.mk | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 7558f83aa5..c3e70db267 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -16,7 +16,7 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) -LOCAL_SRC_FILES := \ +minikin_src_files := \ AnalyzeStyle.cpp \ CmapCoverage.cpp \ FontCollection.cpp \ @@ -31,14 +31,12 @@ LOCAL_SRC_FILES := \ MinikinFontFreeType.cpp \ SparseBitSet.cpp -LOCAL_MODULE := libminikin - -LOCAL_C_INCLUDES += \ +minikin_c_includes += \ external/harfbuzz_ng/src \ external/freetype/include \ frameworks/minikin/include -LOCAL_SHARED_LIBRARIES := \ +minikin_shared_libraries := \ libharfbuzz_ng \ libft2 \ liblog \ @@ -47,6 +45,12 @@ LOCAL_SHARED_LIBRARIES := \ libicuuc \ libutils +LOCAL_MODULE := libminikin +LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include +LOCAL_SRC_FILES := $(minikin_src_files) +LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) + include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) From aaec3837bf0355869f1da14e1aacf2b29100a309 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 13 Oct 2015 19:35:05 +0900 Subject: [PATCH 112/364] Remove MinikinFont::GetGlyph interface. MinikinFont:GetGlyph is no longer used. No behavior chnages are expected with this CL. Change-Id: I13398503841ac06f930b04815017d4b33338efa1 --- engine/src/flutter/include/minikin/MinikinFont.h | 2 -- .../src/flutter/include/minikin/MinikinFontFreeType.h | 2 -- .../src/flutter/libs/minikin/MinikinFontFreeType.cpp | 6 ------ engine/src/flutter/sample/MinikinSkia.cpp | 11 ----------- engine/src/flutter/sample/MinikinSkia.h | 4 +--- engine/src/flutter/tests/HbFaceCacheTest.cpp | 5 ----- engine/src/flutter/tests/MinikinFontForTest.cpp | 5 ----- engine/src/flutter/tests/MinikinFontForTest.h | 1 - 8 files changed, 1 insertion(+), 35 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 7f65cd7b0a..2ad2151a31 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -96,8 +96,6 @@ class MinikinFontFreeType; class MinikinFont : public MinikinRefCounted { public: - virtual bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const = 0; - virtual float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const = 0; diff --git a/engine/src/flutter/include/minikin/MinikinFontFreeType.h b/engine/src/flutter/include/minikin/MinikinFontFreeType.h index 13a513982b..a957d124c7 100644 --- a/engine/src/flutter/include/minikin/MinikinFontFreeType.h +++ b/engine/src/flutter/include/minikin/MinikinFontFreeType.h @@ -42,8 +42,6 @@ public: ~MinikinFontFreeType(); - bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const; - float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const; diff --git a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp index 972f3f1d14..cbeed61593 100644 --- a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp @@ -38,12 +38,6 @@ MinikinFontFreeType::~MinikinFontFreeType() { FT_Done_Face(mTypeface); } -bool MinikinFontFreeType::GetGlyph(uint32_t codepoint, uint32_t *glyph) const { - FT_UInt glyph_index = FT_Get_Char_Index(mTypeface, codepoint); - *glyph = glyph_index; - return !!glyph_index; -} - float MinikinFontFreeType::GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const { FT_Set_Pixel_Sizes(mTypeface, 0, paint.size); diff --git a/engine/src/flutter/sample/MinikinSkia.cpp b/engine/src/flutter/sample/MinikinSkia.cpp index 8b499d8131..feda8adff1 100644 --- a/engine/src/flutter/sample/MinikinSkia.cpp +++ b/engine/src/flutter/sample/MinikinSkia.cpp @@ -14,17 +14,6 @@ MinikinFontSkia::~MinikinFontSkia() { SkSafeUnref(mTypeface); } -bool MinikinFontSkia::GetGlyph(uint32_t codepoint, uint32_t *glyph) const { - SkPaint paint; - paint.setTypeface(mTypeface); - paint.setTextEncoding(SkPaint::kUTF32_TextEncoding); - uint16_t glyph16; - paint.textToGlyphs(&codepoint, sizeof(codepoint), &glyph16); - *glyph = glyph16; - //printf("glyph for U+%04x = %d\n", codepoint, glyph16); - return !!glyph; -} - static void MinikinFontSkia_SetSkiaPaint(SkTypeface* typeface, SkPaint* skPaint, const MinikinPaint& paint) { skPaint->setTypeface(typeface); skPaint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); diff --git a/engine/src/flutter/sample/MinikinSkia.h b/engine/src/flutter/sample/MinikinSkia.h index fca6ca2322..25ac1b0c08 100644 --- a/engine/src/flutter/sample/MinikinSkia.h +++ b/engine/src/flutter/sample/MinikinSkia.h @@ -6,8 +6,6 @@ public: ~MinikinFontSkia(); - bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const; - float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const; @@ -26,4 +24,4 @@ private: }; -} // namespace android \ No newline at end of file +} // namespace android diff --git a/engine/src/flutter/tests/HbFaceCacheTest.cpp b/engine/src/flutter/tests/HbFaceCacheTest.cpp index 1b63073851..fbaf0eab15 100644 --- a/engine/src/flutter/tests/HbFaceCacheTest.cpp +++ b/engine/src/flutter/tests/HbFaceCacheTest.cpp @@ -35,11 +35,6 @@ public: MockMinikinFont(int32_t id) : mId(id) { } - virtual bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const { - LOG_ALWAYS_FATAL("MockMinikinFont::GetGlyph is not implemented."); - return false; - } - virtual float GetHorizontalAdvance( uint32_t glyph_id, const MinikinPaint &paint) const { LOG_ALWAYS_FATAL("MockMinikinFont::GetHorizontalAdvance is not implemented."); diff --git a/engine/src/flutter/tests/MinikinFontForTest.cpp b/engine/src/flutter/tests/MinikinFontForTest.cpp index 2d29e805aa..033241e26d 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/MinikinFontForTest.cpp @@ -29,11 +29,6 @@ MinikinFontForTest::MinikinFontForTest(const std::string& font_path) : mFontPath MinikinFontForTest::~MinikinFontForTest() { } -bool MinikinFontForTest::GetGlyph(uint32_t codepoint, uint32_t *glyph) const { - LOG_ALWAYS_FATAL("MinikinFontForTest::GetGlyph is not yet implemented"); - return false; -} - float MinikinFontForTest::GetHorizontalAdvance( uint32_t glyph_id, const android::MinikinPaint &paint) const { LOG_ALWAYS_FATAL("MinikinFontForTest::GetHorizontalAdvance is not yet implemented"); diff --git a/engine/src/flutter/tests/MinikinFontForTest.h b/engine/src/flutter/tests/MinikinFontForTest.h index ecebb7e2b8..5738666f77 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.h +++ b/engine/src/flutter/tests/MinikinFontForTest.h @@ -24,7 +24,6 @@ public: ~MinikinFontForTest(); // MinikinFont overrides. - bool GetGlyph(uint32_t codepoint, uint32_t *glyph) const; float GetHorizontalAdvance(uint32_t glyph_id, const android::MinikinPaint &paint) const; void GetBounds(android::MinikinRect* bounds, uint32_t glyph_id, const android::MinikinPaint& paint) const; From 2a099196e614d9b8be29b7eed60d7bf0ea54f750 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 1 Oct 2015 15:59:38 +0900 Subject: [PATCH 113/364] Support Variation Selector in font selection. This CL contains the following changes: - Add a variation selector argument into getFamilyForChar to be able to select fonts which support variation selector. - In case no fonts support the codepoint and variation selector pair, add a fallback rule which selects font family with ignoring variation selector. - Change FontCollection::itemize to not change the font family immediately preceding a variation selector. - Introduce unit tests for variation selectors. With this CL, TextView can render the variation selectors correctly. Bug: 11256006 Change-Id: I22ce0e9eadc941f84e3a9b23462f194e51dd7180 --- .../flutter/include/minikin/FontCollection.h | 2 +- .../flutter/libs/minikin/FontCollection.cpp | 79 ++++-- .../tests/FontCollectionItemizeTest.cpp | 250 +++++++++++++++++- 3 files changed, 306 insertions(+), 25 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index c4daf98fa6..ca24e386a0 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -60,7 +60,7 @@ private: size_t end; }; - FontFamily* getFamilyForChar(uint32_t ch, FontLanguage lang, int variant) const; + FontFamily* getFamilyForChar(uint32_t ch, uint32_t vs, FontLanguage lang, int variant) const; // static for allocating unique id's static uint32_t sNextId; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 36d47ded9d..4c0070c2b1 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -103,7 +103,7 @@ FontCollection::~FontCollection() { // 3. If a font matches just language, it gets a score of 2. // 4. Matching the "compact" or "elegant" variant adds one to the score. // 5. Highest score wins, with ties resolved to the first font. -FontFamily* FontCollection::getFamilyForChar(uint32_t ch, +FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, FontLanguage lang, int variant) const { if (ch >= mMaxChar) { return NULL; @@ -112,11 +112,11 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, #ifdef VERBOSE_DEBUG ALOGD("querying range %d:%d\n", range.start, range.end); #endif - FontFamily* bestFamily = NULL; + FontFamily* bestFamily = nullptr; int bestScore = -1; for (size_t i = range.start; i < range.end; i++) { FontFamily* family = mFamilyVec[i]; - if (family->getCoverage()->get(ch)) { + if (vs == 0 ? family->getCoverage()->get(ch) : family->hasVariationSelector(ch, vs)) { // First font family in collection always matches if (mFamilies[0] == family) { return family; @@ -131,7 +131,13 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, } } } - if (bestFamily == NULL && !mFamilyVec.empty()) { + if (bestFamily == nullptr && vs != 0) { + // If no fonts support the codepoint and variation selector pair, + // fallback to select a font family that supports just the base + // character, ignoring the variation selector. + return getFamilyForChar(ch, 0, lang, variant); + } + if (bestFamily == nullptr && !mFamilyVec.empty()) { UErrorCode errorCode = U_ZERO_ERROR; const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode); if (U_SUCCESS(errorCode)) { @@ -140,7 +146,7 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, if (U_SUCCESS(errorCode) && len > 0) { int off = 0; U16_NEXT_UNSAFE(decomposed, off, ch); - return getFamilyForChar(ch, lang, variant); + return getFamilyForChar(ch, vs, lang, variant); } } bestFamily = mFamilies[0]; @@ -167,35 +173,61 @@ static bool isStickyWhitelisted(uint32_t c) { return false; } +static bool isVariationSelector(uint32_t c) { + return (0xFE00 <= c && c <= 0xFE0F) || (0xE0100 <= c && c <= 0xE01EF); +} + void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style, vector* result) const { FontLanguage lang = style.getLanguage(); int variant = style.getVariant(); FontFamily* lastFamily = NULL; Run* run = NULL; - int nShorts; - for (size_t i = 0; i < string_size; i += nShorts) { - nShorts = 1; - uint32_t ch = string[i]; - // sigh, decode UTF-16 by hand here - if ((ch & 0xfc00) == 0xd800) { - if ((i + 1) < string_size) { - ch = 0x10000 + ((ch & 0x3ff) << 10) + (string[i + 1] & 0x3ff); - nShorts = 2; + + if (string_size == 0) { + return; + } + + const uint32_t kEndOfString = 0xFFFFFFFF; + + uint32_t nextCh = 0; + uint32_t prevCh = 0; + size_t nextUtf16Pos = 0; + size_t readLength = 0; + U16_NEXT(string, readLength, string_size, nextCh); + + do { + const uint32_t ch = nextCh; + const size_t utf16Pos = nextUtf16Pos; + nextUtf16Pos = readLength; + if (readLength < string_size) { + U16_NEXT(string, readLength, string_size, nextCh); + } else { + nextCh = kEndOfString; + } + + bool shouldContinueRun = false; + if (lastFamily != nullptr) { + if (isStickyWhitelisted(ch)) { + // Continue using existing font as long as it has coverage and is whitelisted + shouldContinueRun = lastFamily->getCoverage()->get(ch); + } else if (isVariationSelector(ch)) { + // Always continue if the character is a variation selector. + shouldContinueRun = true; } } - // Continue using existing font as long as it has coverage and is whitelisted - if (lastFamily == NULL - || !(isStickyWhitelisted(ch) && lastFamily->getCoverage()->get(ch))) { - FontFamily* family = getFamilyForChar(ch, lang, variant); - if (i == 0 || family != lastFamily) { - size_t start = i; + + if (!shouldContinueRun) { + FontFamily* family = + getFamilyForChar(ch, isVariationSelector(nextCh) ? nextCh : 0, lang, variant); + if (utf16Pos == 0 || family != lastFamily) { + size_t start = utf16Pos; // Workaround for Emoji keycap until we implement per-cluster font // selection: if keycap is found in a different font that also // supports previous char, attach previous char to the new run. // Only handles non-surrogate characters. // Bug 7557244. - if (ch == KEYCAP && i && family && family->getCoverage()->get(string[i - 1])) { + if (ch == KEYCAP && utf16Pos != 0 && family && family->getCoverage()->get(prevCh)) { run->end--; if (run->start == run->end) { result->pop_back(); @@ -214,8 +246,9 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty run->start = start; } } - run->end = i + nShorts; - } + prevCh = ch; + run->end = nextUtf16Pos; // exclusive + } while (nextCh != kEndOfString); } MinikinFont* FontCollection::baseFont(FontStyle style) { diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index cabc967984..3c453f3062 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -277,6 +277,255 @@ TEST(FontCollectionItemizeTest, itemize_mixed) { EXPECT_FALSE(runs[4].fakedFont.fakery.isFakeItalic()); } +TEST(FontCollectionItemizeTest, itemize_variationSelector) { + std::unique_ptr collection = getFontCollection(); + std::vector runs; + + // A glyph for U+4FAE is provided by both Japanese font and Simplified + // Chinese font. Also a glyph for U+242EE is provided by both Japanese and + // Traditional Chinese font. To avoid effects of device default locale, + // explicitly specify the locale. + FontStyle kZH_HansStyle = FontStyle(FontLanguage("zh_Hans", 7)); + FontStyle kZH_HantStyle = FontStyle(FontLanguage("zh_Hant", 7)); + + // U+4FAE is available in both zh_Hans and ja font, but U+4FAE,U+FE00 is + // only available in ja font. + itemize(collection.get(), "U+4FAE", kZH_HansStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+4FAE U+FE00", kZH_HansStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+4FAE U+4FAE U+FE00", kZH_HansStyle, &runs); + ASSERT_EQ(2U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); + EXPECT_EQ(1, runs[1].start); + EXPECT_EQ(3, runs[1].end); + EXPECT_EQ(kJAFont, getFontPath(runs[1])); + + itemize(collection.get(), "U+4FAE U+4FAE U+FE00 U+4FAE", kZH_HansStyle, &runs); + ASSERT_EQ(3U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); + EXPECT_EQ(1, runs[1].start); + EXPECT_EQ(3, runs[1].end); + EXPECT_EQ(kJAFont, getFontPath(runs[1])); + EXPECT_EQ(3, runs[2].start); + EXPECT_EQ(4, runs[2].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[2])); + + // Validation selector after validation selector. + itemize(collection.get(), "U+4FAE U+FE00 U+FE00", kZH_HansStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(3, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[1])); + + // No font supports U+242EE U+FE0E. + itemize(collection.get(), "U+4FAE U+FE0E", kZH_HansStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); + + // Surrogate pairs handling. + // U+242EE is available in ja font and zh_Hant font. + // U+242EE U+FE00 is available only in ja font. + itemize(collection.get(), "U+242EE", kZH_HantStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+242EE U+FE00", kZH_HantStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(3, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+242EE U+242EE U+FE00", kZH_HantStyle, &runs); + ASSERT_EQ(2U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); + EXPECT_EQ(2, runs[1].start); + EXPECT_EQ(5, runs[1].end); + EXPECT_EQ(kJAFont, getFontPath(runs[1])); + + itemize(collection.get(), "U+242EE U+242EE U+FE00 U+242EE", kZH_HantStyle, &runs); + ASSERT_EQ(3U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); + EXPECT_EQ(2, runs[1].start); + EXPECT_EQ(5, runs[1].end); + EXPECT_EQ(kJAFont, getFontPath(runs[1])); + EXPECT_EQ(5, runs[2].start); + EXPECT_EQ(7, runs[2].end); + EXPECT_EQ(kZH_HantFont, getFontPath(runs[2])); + + // Validation selector after validation selector. + itemize(collection.get(), "U+242EE U+FE00 U+FE00", kZH_HansStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(4, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + + // No font supports U+242EE U+FE0E + itemize(collection.get(), "U+242EE U+FE0E", kZH_HantStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(3, runs[0].end); + EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); + + // Isolated variation selector supplement. + itemize(collection.get(), "U+FE00", FontStyle(), &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+FE00", kZH_HantStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[0])); +} + +TEST(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { + std::unique_ptr collection = getFontCollection(); + std::vector runs; + + // A glyph for U+845B is provided by both Japanese font and Simplified + // Chinese font. Also a glyph for U+242EE is provided by both Japanese and + // Traditional Chinese font. To avoid effects of device default locale, + // explicitly specify the locale. + FontStyle kZH_HansStyle = FontStyle(FontLanguage("zh_Hans", 7)); + FontStyle kZH_HantStyle = FontStyle(FontLanguage("zh_Hant", 7)); + + // U+845B is available in both zh_Hans and ja font, but U+845B,U+E0100 is + // only available in ja font. + itemize(collection.get(), "U+845B", kZH_HansStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+845B U+E0100", kZH_HansStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(3, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+845B U+845B U+E0100", kZH_HansStyle, &runs); + ASSERT_EQ(2U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); + EXPECT_EQ(1, runs[1].start); + EXPECT_EQ(4, runs[1].end); + EXPECT_EQ(kJAFont, getFontPath(runs[1])); + + itemize(collection.get(), "U+845B U+845B U+E0100 U+845B", kZH_HansStyle, &runs); + ASSERT_EQ(3U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); + EXPECT_EQ(1, runs[1].start); + EXPECT_EQ(4, runs[1].end); + EXPECT_EQ(kJAFont, getFontPath(runs[1])); + EXPECT_EQ(4, runs[2].start); + EXPECT_EQ(5, runs[2].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[2])); + + // Validation selector after validation selector. + itemize(collection.get(), "U+845B U+E0100 U+E0100", kZH_HansStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + + // No font supports U+845B U+E01E0. + itemize(collection.get(), "U+845B U+E01E0", kZH_HansStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(3, runs[0].end); + EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); + + // Isolated variation selector supplement + // Surrogate pairs handling. + // U+242EE is available in ja font and zh_Hant font. + // U+242EE U+E0100 is available only in ja font. + itemize(collection.get(), "U+242EE", kZH_HantStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+242EE U+E0101", kZH_HantStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(4, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+242EE U+242EE U+E0101", kZH_HantStyle, &runs); + ASSERT_EQ(2U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); + EXPECT_EQ(2, runs[1].start); + EXPECT_EQ(6, runs[1].end); + EXPECT_EQ(kJAFont, getFontPath(runs[1])); + + itemize(collection.get(), "U+242EE U+242EE U+E0101 U+242EE", kZH_HantStyle, &runs); + ASSERT_EQ(3U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); + EXPECT_EQ(2, runs[1].start); + EXPECT_EQ(6, runs[1].end); + EXPECT_EQ(kJAFont, getFontPath(runs[1])); + EXPECT_EQ(6, runs[2].start); + EXPECT_EQ(8, runs[2].end); + EXPECT_EQ(kZH_HantFont, getFontPath(runs[2])); + + // Validation selector after validation selector. + itemize(collection.get(), "U+242EE U+E0100 U+E0100", kZH_HantStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(6, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + + // No font supports U+242EE U+E01E0. + itemize(collection.get(), "U+242EE U+E01E0", kZH_HantStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(4, runs[0].end); + EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); + + // Isolated variation selector supplement. + itemize(collection.get(), "U+E0100", FontStyle(), &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+E0100", kZH_HantStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[0])); +} + TEST(FontCollectionItemizeTest, itemize_no_crash) { std::unique_ptr collection = getFontCollection(); std::vector runs; @@ -340,4 +589,3 @@ TEST(FontCollectionItemizeTest, itemize_fakery) { EXPECT_TRUE(runs[0].fakedFont.fakery.isFakeItalic()); } -// TODO(11256006): Add Variation Selector test cases once it is supported. From 9a4c3535bef65b72cf8b4b7da3b19d5995e2c137 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Mon, 19 Oct 2015 22:16:08 -0700 Subject: [PATCH 114/364] Basic scaffolding for handling a language list. The behavior hasn't changed much yet: all languages are ignored for rendering text, except the very first supported language. Change-Id: I1695fb985927ae5e28e4f59c1b531e4993af8688 --- .../src/flutter/include/minikin/FontFamily.h | 23 +++++++++ .../src/flutter/libs/minikin/FontFamily.cpp | 33 +++++++++++++ engine/src/flutter/tests/FontFamilyTest.cpp | 48 +++++++++++++++++++ 3 files changed, 104 insertions(+) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index b1994042e3..fc05e3b219 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -35,6 +35,7 @@ class MinikinFont; // font rendering. class FontLanguage { friend class FontStyle; + friend class FontLanguages; public: FontLanguage() : mBits(0) { } @@ -46,6 +47,8 @@ public: } operator bool() const { return mBits != 0; } + bool isUnsupported() const { return mBits == kUnsupportedLanguage; } + std::string getString() const; // 0 = no match, 1 = language matches, 2 = language and script match @@ -64,6 +67,23 @@ private: uint32_t mBits; }; +// A list of zero or more instances of FontLanguage, in the order of +// preference. Used for further resolution of rendering results. +class FontLanguages { +public: + FontLanguages() { mLangs.clear(); } + + // Parse from string, which is a comma-separated list of languages + FontLanguages(const char* buf, size_t size); + + const FontLanguage& operator[](size_t index) const { return mLangs.at(index); } + + size_t size() const { return mLangs.size(); } + +private: + std::vector mLangs; +}; + // FontStyle represents all style information needed to select an actual font // from a collection. The implementation is packed into a single 32-bit word // so it can be efficiently copied, embedded in other objects, etc. @@ -76,6 +96,9 @@ public: bits = (weight & kWeightMask) | (italic ? kItalicMask : 0) | (variant << kVariantShift) | (lang.bits() << kLangShift); } + FontStyle(FontLanguages langs, int variant = 0, int weight = 4, bool italic = false) : + // TODO: Use all the languages in langs + FontStyle(langs[0], variant, weight, italic) { } int getWeight() const { return bits & kWeightMask; } bool getItalic() const { return (bits & kItalicMask) != 0; } int getVariant() const { return (bits >> kVariantShift) & kVariantMask; } diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index a6632e0339..dfd37fe593 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -16,9 +16,12 @@ #define LOG_TAG "Minikin" +#include + #include #include #include +#include #include #include @@ -115,6 +118,36 @@ int FontLanguage::match(const FontLanguage other) const { return result; } +FontLanguages::FontLanguages(const char* buf, size_t size) { + std::unordered_set seen; + mLangs.clear(); + const char* bufEnd = buf + size; + const char* lastStart = buf; + bool isLastLang = false; + while (true) { + const char* commaLoc = static_cast( + memchr(lastStart, ',', bufEnd - lastStart)); + if (commaLoc == NULL) { + commaLoc = bufEnd; + isLastLang = true; + } + FontLanguage lang(lastStart, commaLoc - lastStart); + if (isLastLang && mLangs.size() == 0) { + // Make sure the list has at least one member + mLangs.push_back(lang); + return; + } + uint32_t bits = lang.bits(); + if (bits != FontLanguage::kUnsupportedLanguage && seen.count(bits) == 0) { + mLangs.push_back(lang); + if (isLastLang) return; + seen.insert(bits); + } + if (isLastLang) return; + lastStart = commaLoc + 1; + } +} + FontFamily::~FontFamily() { for (size_t i = 0; i < mFonts.size(); i++) { mFonts[i].typeface->UnrefLocked(); diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index a6813f013b..78f286c0ca 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -22,6 +22,54 @@ namespace android { +TEST(FontLanguagesTest, basicTests) { + FontLanguages emptyLangs; + EXPECT_EQ(0u, emptyLangs.size()); + + FontLanguage english("en", 2); + FontLanguages singletonLangs("en", 2); + EXPECT_EQ(1u, singletonLangs.size()); + EXPECT_EQ(english, singletonLangs[0]); + + FontLanguage french("fr", 2); + FontLanguages twoLangs("en,fr", 5); + EXPECT_EQ(2u, twoLangs.size()); + EXPECT_EQ(english, twoLangs[0]); + EXPECT_EQ(french, twoLangs[1]); +} + +TEST(FontLanguagesTest, unsupportedLanguageTests) { + FontLanguage unsupportedLang("x-example", 9); + ASSERT_TRUE(unsupportedLang.isUnsupported()); + + FontLanguages oneUnsupported("x-example", 9); + EXPECT_EQ(1u, oneUnsupported.size()); + EXPECT_TRUE(oneUnsupported[0].isUnsupported()); + + FontLanguages twoUnsupporteds("x-example,x-example", 19); + EXPECT_EQ(1u, twoUnsupporteds.size()); + EXPECT_TRUE(twoUnsupporteds[0].isUnsupported()); + + FontLanguage english("en", 2); + FontLanguages firstUnsupported("x-example,en", 12); + EXPECT_EQ(1u, firstUnsupported.size()); + EXPECT_EQ(english, firstUnsupported[0]); + + FontLanguages lastUnsupported("en,x-example", 12); + EXPECT_EQ(1u, lastUnsupported.size()); + EXPECT_EQ(english, lastUnsupported[0]); +} + +TEST(FontLanguagesTest, repeatedLanguageTests) { + FontLanguage english("en", 2); + FontLanguage englishInLatn("en-Latn", 2); + ASSERT_TRUE(english == englishInLatn); + + FontLanguages langs("en,en-Latn", 10); + EXPECT_EQ(1u, langs.size()); + EXPECT_EQ(english, langs[0]); +} + // The test font has following glyphs. // U+82A6 // U+82A6 U+FE00 (VS1) From a816dfb3fad6087a82e5d5843b5da0504ece34b9 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 27 Oct 2015 14:56:12 +0900 Subject: [PATCH 115/364] Add -Werror -Wall -Wextra to compiler option. - To suppress noisy unused parameter warnings, comment out unused arguments. - Add -Werror for suppressing further warning. - Add -Wall -Wextra for safety. Change-Id: I30a0914a4633bd93eb60957cdf378770f04d8428 --- engine/src/flutter/include/minikin/Layout.h | 2 +- engine/src/flutter/libs/minikin/Android.mk | 3 +++ engine/src/flutter/libs/minikin/HbFaceCache.cpp | 9 ++------- engine/src/flutter/libs/minikin/Layout.cpp | 9 +++++---- .../src/flutter/libs/minikin/MinikinFontFreeType.cpp | 8 ++++---- engine/src/flutter/tests/Android.mk | 2 ++ engine/src/flutter/tests/HbFaceCacheTest.cpp | 10 +++++----- engine/src/flutter/tests/MinikinFontForTest.cpp | 8 ++++---- 8 files changed, 26 insertions(+), 25 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 83eb963b71..cb68db9c3d 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -59,7 +59,7 @@ struct LayoutGlyph { }; // Internal state used during layout operation -class LayoutContext; +struct LayoutContext; enum { kBidi_LTR = 0, diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 4d34c11470..c728b09b84 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -50,6 +50,7 @@ LOCAL_MODULE := libminikin LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_CPPFLAGS += -Werror -Wall -Wextra LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) include $(BUILD_SHARED_LIBRARY) @@ -61,6 +62,7 @@ LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_CPPFLAGS += -Werror -Wall -Wextra LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) include $(BUILD_STATIC_LIBRARY) @@ -73,6 +75,7 @@ LOCAL_MODULE := libminikin_host LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_CPPFLAGS += -Werror -Wall -Wextra LOCAL_SHARED_LIBRARIES := liblog libicuuc-host LOCAL_SRC_FILES := Hyphenator.cpp diff --git a/engine/src/flutter/libs/minikin/HbFaceCache.cpp b/engine/src/flutter/libs/minikin/HbFaceCache.cpp index fde2fa869f..a12cd95a95 100644 --- a/engine/src/flutter/libs/minikin/HbFaceCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFaceCache.cpp @@ -26,7 +26,7 @@ namespace android { -static hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { +static hb_blob_t* referenceTable(hb_face_t* /* face */, hb_tag_t tag, void* userData) { MinikinFont* font = reinterpret_cast(userData); size_t length = 0; bool ok = font->GetTable(tag, NULL, &length); @@ -50,11 +50,6 @@ static hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) HB_MEMORY_MODE_WRITABLE, buffer, free); } -static unsigned int disabledDecomposeCompatibility( - hb_unicode_funcs_t*, hb_codepoint_t, hb_codepoint_t*, void*) { - return 0; -} - class HbFaceCache : private OnEntryRemoved { public: HbFaceCache() : mCache(kMaxEntries) { @@ -62,7 +57,7 @@ public: } // callback for OnEntryRemoved - void operator()(int32_t& key, hb_face_t*& value) { + void operator()(int32_t& /* key */, hb_face_t*& value) { hb_face_destroy(value); } diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 6d62d5d7d8..9084ebafad 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -276,16 +276,17 @@ void Layout::setFontCollection(const FontCollection* collection) { mCollection = collection; } -static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, void* userData) -{ +static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* /* hbFont */, void* fontData, + hb_codepoint_t glyph, void* /* userData */) { MinikinPaint* paint = reinterpret_cast(fontData); MinikinFont* font = paint->font; float advance = font->GetHorizontalAdvance(glyph, *paint); return 256 * advance + 0.5; } -static hb_bool_t harfbuzzGetGlyphHorizontalOrigin(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, hb_position_t* x, hb_position_t* y, void* userData) -{ +static hb_bool_t harfbuzzGetGlyphHorizontalOrigin(hb_font_t* /* hbFont */, void* /* fontData */, + hb_codepoint_t /* glyph */, hb_position_t* /* x */, hb_position_t* /* y */, + void* /* userData */) { // Just return true, following the way that Harfbuzz-FreeType // implementation does. return true; diff --git a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp index cbeed61593..c9eb456be5 100644 --- a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp @@ -47,8 +47,8 @@ float MinikinFontFreeType::GetHorizontalAdvance(uint32_t glyph_id, return advance * (1.0 / 65536); } -void MinikinFontFreeType::GetBounds(MinikinRect* bounds, uint32_t glyph_id, - const MinikinPaint& paint) const { +void MinikinFontFreeType::GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph_id*/, + const MinikinPaint& /* paint */) const { // TODO: NYI } @@ -66,8 +66,8 @@ int32_t MinikinFontFreeType::GetUniqueId() const { return mUniqueId; } -bool MinikinFontFreeType::Render(uint32_t glyph_id, - const MinikinPaint &paint, GlyphBitmap *result) { +bool MinikinFontFreeType::Render(uint32_t glyph_id, const MinikinPaint& /* paint */, + GlyphBitmap *result) { FT_Error error; FT_Int32 load_flags = FT_LOAD_DEFAULT; // TODO: respect hinting settings error = FT_Load_Glyph(mTypeface, glyph_id, load_flags); diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index b69b8f243f..b6bc15c0dc 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -54,4 +54,6 @@ LOCAL_C_INCLUDES := \ external/libxml2/include \ external/skia/src/core +LOCAL_CPPFLAGS += -Werror -Wall -Wextra + include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/HbFaceCacheTest.cpp b/engine/src/flutter/tests/HbFaceCacheTest.cpp index fbaf0eab15..76eec5b5a8 100644 --- a/engine/src/flutter/tests/HbFaceCacheTest.cpp +++ b/engine/src/flutter/tests/HbFaceCacheTest.cpp @@ -35,18 +35,18 @@ public: MockMinikinFont(int32_t id) : mId(id) { } - virtual float GetHorizontalAdvance( - uint32_t glyph_id, const MinikinPaint &paint) const { + virtual float GetHorizontalAdvance(uint32_t /* glyph_id */, + const MinikinPaint& /* paint */) const { LOG_ALWAYS_FATAL("MockMinikinFont::GetHorizontalAdvance is not implemented."); return 0.0f; } - virtual void GetBounds(MinikinRect* bounds, uint32_t glyph_id, - const MinikinPaint &paint) const { + virtual void GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph_id */, + const MinikinPaint& /* paint */) const { LOG_ALWAYS_FATAL("MockMinikinFont::GetBounds is not implemented."); } - virtual bool GetTable(uint32_t tag, uint8_t *buf, size_t *size) { + virtual bool GetTable(uint32_t /* tag */, uint8_t* /* buf */, size_t* /* size */) { LOG_ALWAYS_FATAL("MockMinikinFont::GetTable is not implemented."); return false; } diff --git a/engine/src/flutter/tests/MinikinFontForTest.cpp b/engine/src/flutter/tests/MinikinFontForTest.cpp index 033241e26d..ed7075188b 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/MinikinFontForTest.cpp @@ -29,14 +29,14 @@ MinikinFontForTest::MinikinFontForTest(const std::string& font_path) : mFontPath MinikinFontForTest::~MinikinFontForTest() { } -float MinikinFontForTest::GetHorizontalAdvance( - uint32_t glyph_id, const android::MinikinPaint &paint) const { +float MinikinFontForTest::GetHorizontalAdvance(uint32_t /* glyph_id */, + const android::MinikinPaint& /* paint */) const { LOG_ALWAYS_FATAL("MinikinFontForTest::GetHorizontalAdvance is not yet implemented"); return 0.0f; } -void MinikinFontForTest::GetBounds(android::MinikinRect* bounds, uint32_t glyph_id, - const android::MinikinPaint& paint) const { +void MinikinFontForTest::GetBounds(android::MinikinRect* /* bounds */, uint32_t /* glyph_id */, + const android::MinikinPaint& /* paint */) const { LOG_ALWAYS_FATAL("MinikinFontForTest::GetBounds is not yet implemented"); } From 07c8ad2b85c6e653f5450dba0a7e4689d4ec2cd0 Mon Sep 17 00:00:00 2001 From: Bart Sears Date: Wed, 28 Oct 2015 03:16:55 +0000 Subject: [PATCH 116/364] Revert "Add -Werror -Wall -Wextra to compiler option." This reverts commit a816dfb3fad6087a82e5d5843b5da0504ece34b9. Change-Id: I2b4b10e8afedc85dbe2d07f3e47315652b65cd14 --- engine/src/flutter/include/minikin/Layout.h | 2 +- engine/src/flutter/libs/minikin/Android.mk | 3 --- engine/src/flutter/libs/minikin/HbFaceCache.cpp | 9 +++++++-- engine/src/flutter/libs/minikin/Layout.cpp | 9 ++++----- .../src/flutter/libs/minikin/MinikinFontFreeType.cpp | 8 ++++---- engine/src/flutter/tests/Android.mk | 2 -- engine/src/flutter/tests/HbFaceCacheTest.cpp | 10 +++++----- engine/src/flutter/tests/MinikinFontForTest.cpp | 8 ++++---- 8 files changed, 25 insertions(+), 26 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index cb68db9c3d..83eb963b71 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -59,7 +59,7 @@ struct LayoutGlyph { }; // Internal state used during layout operation -struct LayoutContext; +class LayoutContext; enum { kBidi_LTR = 0, diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index c728b09b84..4d34c11470 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -50,7 +50,6 @@ LOCAL_MODULE := libminikin LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) include $(BUILD_SHARED_LIBRARY) @@ -62,7 +61,6 @@ LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) include $(BUILD_STATIC_LIBRARY) @@ -75,7 +73,6 @@ LOCAL_MODULE := libminikin_host LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra LOCAL_SHARED_LIBRARIES := liblog libicuuc-host LOCAL_SRC_FILES := Hyphenator.cpp diff --git a/engine/src/flutter/libs/minikin/HbFaceCache.cpp b/engine/src/flutter/libs/minikin/HbFaceCache.cpp index a12cd95a95..fde2fa869f 100644 --- a/engine/src/flutter/libs/minikin/HbFaceCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFaceCache.cpp @@ -26,7 +26,7 @@ namespace android { -static hb_blob_t* referenceTable(hb_face_t* /* face */, hb_tag_t tag, void* userData) { +static hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { MinikinFont* font = reinterpret_cast(userData); size_t length = 0; bool ok = font->GetTable(tag, NULL, &length); @@ -50,6 +50,11 @@ static hb_blob_t* referenceTable(hb_face_t* /* face */, hb_tag_t tag, void* user HB_MEMORY_MODE_WRITABLE, buffer, free); } +static unsigned int disabledDecomposeCompatibility( + hb_unicode_funcs_t*, hb_codepoint_t, hb_codepoint_t*, void*) { + return 0; +} + class HbFaceCache : private OnEntryRemoved { public: HbFaceCache() : mCache(kMaxEntries) { @@ -57,7 +62,7 @@ public: } // callback for OnEntryRemoved - void operator()(int32_t& /* key */, hb_face_t*& value) { + void operator()(int32_t& key, hb_face_t*& value) { hb_face_destroy(value); } diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 9084ebafad..6d62d5d7d8 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -276,17 +276,16 @@ void Layout::setFontCollection(const FontCollection* collection) { mCollection = collection; } -static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* /* hbFont */, void* fontData, - hb_codepoint_t glyph, void* /* userData */) { +static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, void* userData) +{ MinikinPaint* paint = reinterpret_cast(fontData); MinikinFont* font = paint->font; float advance = font->GetHorizontalAdvance(glyph, *paint); return 256 * advance + 0.5; } -static hb_bool_t harfbuzzGetGlyphHorizontalOrigin(hb_font_t* /* hbFont */, void* /* fontData */, - hb_codepoint_t /* glyph */, hb_position_t* /* x */, hb_position_t* /* y */, - void* /* userData */) { +static hb_bool_t harfbuzzGetGlyphHorizontalOrigin(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, hb_position_t* x, hb_position_t* y, void* userData) +{ // Just return true, following the way that Harfbuzz-FreeType // implementation does. return true; diff --git a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp index c9eb456be5..cbeed61593 100644 --- a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp @@ -47,8 +47,8 @@ float MinikinFontFreeType::GetHorizontalAdvance(uint32_t glyph_id, return advance * (1.0 / 65536); } -void MinikinFontFreeType::GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph_id*/, - const MinikinPaint& /* paint */) const { +void MinikinFontFreeType::GetBounds(MinikinRect* bounds, uint32_t glyph_id, + const MinikinPaint& paint) const { // TODO: NYI } @@ -66,8 +66,8 @@ int32_t MinikinFontFreeType::GetUniqueId() const { return mUniqueId; } -bool MinikinFontFreeType::Render(uint32_t glyph_id, const MinikinPaint& /* paint */, - GlyphBitmap *result) { +bool MinikinFontFreeType::Render(uint32_t glyph_id, + const MinikinPaint &paint, GlyphBitmap *result) { FT_Error error; FT_Int32 load_flags = FT_LOAD_DEFAULT; // TODO: respect hinting settings error = FT_Load_Glyph(mTypeface, glyph_id, load_flags); diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index b6bc15c0dc..b69b8f243f 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -54,6 +54,4 @@ LOCAL_C_INCLUDES := \ external/libxml2/include \ external/skia/src/core -LOCAL_CPPFLAGS += -Werror -Wall -Wextra - include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/HbFaceCacheTest.cpp b/engine/src/flutter/tests/HbFaceCacheTest.cpp index 76eec5b5a8..fbaf0eab15 100644 --- a/engine/src/flutter/tests/HbFaceCacheTest.cpp +++ b/engine/src/flutter/tests/HbFaceCacheTest.cpp @@ -35,18 +35,18 @@ public: MockMinikinFont(int32_t id) : mId(id) { } - virtual float GetHorizontalAdvance(uint32_t /* glyph_id */, - const MinikinPaint& /* paint */) const { + virtual float GetHorizontalAdvance( + uint32_t glyph_id, const MinikinPaint &paint) const { LOG_ALWAYS_FATAL("MockMinikinFont::GetHorizontalAdvance is not implemented."); return 0.0f; } - virtual void GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph_id */, - const MinikinPaint& /* paint */) const { + virtual void GetBounds(MinikinRect* bounds, uint32_t glyph_id, + const MinikinPaint &paint) const { LOG_ALWAYS_FATAL("MockMinikinFont::GetBounds is not implemented."); } - virtual bool GetTable(uint32_t /* tag */, uint8_t* /* buf */, size_t* /* size */) { + virtual bool GetTable(uint32_t tag, uint8_t *buf, size_t *size) { LOG_ALWAYS_FATAL("MockMinikinFont::GetTable is not implemented."); return false; } diff --git a/engine/src/flutter/tests/MinikinFontForTest.cpp b/engine/src/flutter/tests/MinikinFontForTest.cpp index ed7075188b..033241e26d 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/MinikinFontForTest.cpp @@ -29,14 +29,14 @@ MinikinFontForTest::MinikinFontForTest(const std::string& font_path) : mFontPath MinikinFontForTest::~MinikinFontForTest() { } -float MinikinFontForTest::GetHorizontalAdvance(uint32_t /* glyph_id */, - const android::MinikinPaint& /* paint */) const { +float MinikinFontForTest::GetHorizontalAdvance( + uint32_t glyph_id, const android::MinikinPaint &paint) const { LOG_ALWAYS_FATAL("MinikinFontForTest::GetHorizontalAdvance is not yet implemented"); return 0.0f; } -void MinikinFontForTest::GetBounds(android::MinikinRect* /* bounds */, uint32_t /* glyph_id */, - const android::MinikinPaint& /* paint */) const { +void MinikinFontForTest::GetBounds(android::MinikinRect* bounds, uint32_t glyph_id, + const android::MinikinPaint& paint) const { LOG_ALWAYS_FATAL("MinikinFontForTest::GetBounds is not yet implemented"); } From ac88812115bd4232cb956582ae9fdbaf221d8cb7 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 27 Oct 2015 14:56:12 +0900 Subject: [PATCH 117/364] Add -Werror -Wall -Wextra to compiler option. This is 2nd trial of I30a0914a4633bd93eb60957cdf378770f04d8428 - To suppress noisy unused parameter warnings, comment out unused arguments. - Add -Werror for suppressing further warning. - Add -Wall -Wextra for safety. - Use "z" prefix for format string of size_t. Verified that compile succeeded on all arm,arm64,mips,x86,x86_64. Change-Id: I7ad208464486b8a35da53929cb1cfe541ed0052f --- engine/src/flutter/include/minikin/Layout.h | 2 +- engine/src/flutter/libs/minikin/Android.mk | 3 +++ engine/src/flutter/libs/minikin/FontCollection.cpp | 8 ++++---- engine/src/flutter/libs/minikin/FontFamily.cpp | 4 ++-- engine/src/flutter/libs/minikin/HbFaceCache.cpp | 12 ++++-------- engine/src/flutter/libs/minikin/Layout.cpp | 13 +++++++------ engine/src/flutter/libs/minikin/LineBreaker.cpp | 6 +++--- .../flutter/libs/minikin/MinikinFontFreeType.cpp | 8 ++++---- engine/src/flutter/tests/Android.mk | 2 ++ engine/src/flutter/tests/HbFaceCacheTest.cpp | 10 +++++----- engine/src/flutter/tests/MinikinFontForTest.cpp | 8 ++++---- 11 files changed, 39 insertions(+), 37 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 83eb963b71..cb68db9c3d 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -59,7 +59,7 @@ struct LayoutGlyph { }; // Internal state used during layout operation -class LayoutContext; +struct LayoutContext; enum { kBidi_LTR = 0, diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 4d34c11470..c728b09b84 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -50,6 +50,7 @@ LOCAL_MODULE := libminikin LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_CPPFLAGS += -Werror -Wall -Wextra LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) include $(BUILD_SHARED_LIBRARY) @@ -61,6 +62,7 @@ LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_CPPFLAGS += -Werror -Wall -Wextra LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) include $(BUILD_STATIC_LIBRARY) @@ -73,6 +75,7 @@ LOCAL_MODULE := libminikin_host LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_C_INCLUDES := $(minikin_c_includes) +LOCAL_CPPFLAGS += -Werror -Wall -Wextra LOCAL_SHARED_LIBRARIES := liblog libicuuc-host LOCAL_SRC_FILES := Hyphenator.cpp diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 4c0070c2b1..2c22880259 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -43,7 +43,7 @@ FontCollection::FontCollection(const vector& typefaces) : vector lastChar; size_t nTypefaces = typefaces.size(); #ifdef VERBOSE_DEBUG - ALOGD("nTypefaces = %d\n", nTypefaces); + ALOGD("nTypefaces = %zd\n", nTypefaces); #endif const FontStyle defaultStyle; for (size_t i = 0; i < nTypefaces; i++) { @@ -72,7 +72,7 @@ FontCollection::FontCollection(const vector& typefaces) : mRanges.push_back(dummy); Range* range = &mRanges.back(); #ifdef VERBOSE_DEBUG - ALOGD("i=%d: range start = %d\n", i, offset); + ALOGD("i=%zd: range start = %zd\n", i, offset); #endif range->start = offset; for (size_t j = 0; j < nTypefaces; j++) { @@ -82,7 +82,7 @@ FontCollection::FontCollection(const vector& typefaces) : offset++; uint32_t nextChar = family->getCoverage()->nextSetBit((i + 1) << kLogCharsPerPage); #ifdef VERBOSE_DEBUG - ALOGD("nextChar = %d (j = %d)\n", nextChar, j); + ALOGD("nextChar = %d (j = %zd)\n", nextChar, j); #endif lastChar[j] = nextChar; } @@ -110,7 +110,7 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, } const Range& range = mRanges[ch >> kLogCharsPerPage]; #ifdef VERBOSE_DEBUG - ALOGD("querying range %d:%d\n", range.start, range.end); + ALOGD("querying range %zd:%zd\n", range.start, range.end); #endif FontFamily* bestFamily = nullptr; int bestScore = -1; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index dfd37fe593..1ff5a6bce4 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -258,8 +258,8 @@ const SparseBitSet* FontFamily::getCoverage() { } CmapCoverage::getCoverage(mCoverage, cmapData.get(), cmapSize); // TODO: Error check? #ifdef VERBOSE_DEBUG - ALOGD("font coverage length=%d, first ch=%x\n", mCoverage->length(), - mCoverage->nextSetBit(0)); + ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), + mCoverage.nextSetBit(0)); #endif mCoverageValid = true; } diff --git a/engine/src/flutter/libs/minikin/HbFaceCache.cpp b/engine/src/flutter/libs/minikin/HbFaceCache.cpp index fde2fa869f..235f7f1b0c 100644 --- a/engine/src/flutter/libs/minikin/HbFaceCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFaceCache.cpp @@ -18,6 +18,7 @@ #include "HbFaceCache.h" +#include #include #include @@ -26,7 +27,7 @@ namespace android { -static hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { +static hb_blob_t* referenceTable(hb_face_t* /* face */, hb_tag_t tag, void* userData) { MinikinFont* font = reinterpret_cast(userData); size_t length = 0; bool ok = font->GetTable(tag, NULL, &length); @@ -39,7 +40,7 @@ static hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) } ok = font->GetTable(tag, reinterpret_cast(buffer), &length); #ifdef VERBOSE_DEBUG - ALOGD("referenceTable %c%c%c%c length=%d %d", + ALOGD("referenceTable %c%c%c%c length=%zd %d", (tag >>24)&0xff, (tag>>16)&0xff, (tag>>8)&0xff, tag&0xff, length, ok); #endif if (!ok) { @@ -50,11 +51,6 @@ static hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) HB_MEMORY_MODE_WRITABLE, buffer, free); } -static unsigned int disabledDecomposeCompatibility( - hb_unicode_funcs_t*, hb_codepoint_t, hb_codepoint_t*, void*) { - return 0; -} - class HbFaceCache : private OnEntryRemoved { public: HbFaceCache() : mCache(kMaxEntries) { @@ -62,7 +58,7 @@ public: } // callback for OnEntryRemoved - void operator()(int32_t& key, hb_face_t*& value) { + void operator()(int32_t& /* key */, hb_face_t*& value) { hb_face_destroy(value); } diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 6d62d5d7d8..3b140faa2b 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -276,16 +276,17 @@ void Layout::setFontCollection(const FontCollection* collection) { mCollection = collection; } -static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, void* userData) -{ +static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* /* hbFont */, void* fontData, + hb_codepoint_t glyph, void* /* userData */) { MinikinPaint* paint = reinterpret_cast(fontData); MinikinFont* font = paint->font; float advance = font->GetHorizontalAdvance(glyph, *paint); return 256 * advance + 0.5; } -static hb_bool_t harfbuzzGetGlyphHorizontalOrigin(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, hb_position_t* x, hb_position_t* y, void* userData) -{ +static hb_bool_t harfbuzzGetGlyphHorizontalOrigin(hb_font_t* /* hbFont */, void* /* fontData */, + hb_codepoint_t /* glyph */, hb_position_t* /* x */, hb_position_t* /* y */, + void* /* userData */) { // Just return true, following the way that Harfbuzz-FreeType // implementation does. return true; @@ -709,7 +710,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t ctx->paint.fakery = mFaces[font_ix].fakery; hb_font_t* hbFont = ctx->hbFonts[font_ix]; #ifdef VERBOSE_DEBUG - ALOGD("Run %u, font %d [%d:%d]", run_ix, font_ix, run.start, run.end); + ALOGD("Run %zu, font %d [%d:%d]", run_ix, font_ix, run.start, run.end); #endif hb_font_set_ppem(hbFont, size * scaleX, size); @@ -804,7 +805,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t if (info[i].cluster - start < count) { mAdvances[info[i].cluster - start] += xAdvance; } else { - ALOGE("cluster %d (start %d) out of bounds of count %d", + ALOGE("cluster %zu (start %zu) out of bounds of count %zu", info[i].cluster - start, start, count); } x += xAdvance; diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index a832ca20e2..a2507e0ba8 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -249,7 +249,7 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.penalty = SCORE_DESPERATE; cand.hyphenEdit = 0; #if VERBOSE_DEBUG - ALOGD("desperate cand: %d %g:%g", + ALOGD("desperate cand: %zd %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); #endif addCandidate(cand); @@ -264,7 +264,7 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.penalty = penalty; cand.hyphenEdit = hyph; #if VERBOSE_DEBUG - ALOGD("cand: %d %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); + ALOGD("cand: %zd %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); #endif addCandidate(cand); } @@ -409,7 +409,7 @@ void LineBreaker::computeBreaksOptimal(bool isRectangle) { mCandidates[i].prev = bestPrev; mCandidates[i].lineNumber = mCandidates[bestPrev].lineNumber + 1; #if VERBOSE_DEBUG - ALOGD("break %d: score=%g, prev=%d", i, mCandidates[i].score, mCandidates[i].prev); + ALOGD("break %zd: score=%g, prev=%zd", i, mCandidates[i].score, mCandidates[i].prev); #endif } finishBreaksOptimal(); diff --git a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp index cbeed61593..c9eb456be5 100644 --- a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp @@ -47,8 +47,8 @@ float MinikinFontFreeType::GetHorizontalAdvance(uint32_t glyph_id, return advance * (1.0 / 65536); } -void MinikinFontFreeType::GetBounds(MinikinRect* bounds, uint32_t glyph_id, - const MinikinPaint& paint) const { +void MinikinFontFreeType::GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph_id*/, + const MinikinPaint& /* paint */) const { // TODO: NYI } @@ -66,8 +66,8 @@ int32_t MinikinFontFreeType::GetUniqueId() const { return mUniqueId; } -bool MinikinFontFreeType::Render(uint32_t glyph_id, - const MinikinPaint &paint, GlyphBitmap *result) { +bool MinikinFontFreeType::Render(uint32_t glyph_id, const MinikinPaint& /* paint */, + GlyphBitmap *result) { FT_Error error; FT_Int32 load_flags = FT_LOAD_DEFAULT; // TODO: respect hinting settings error = FT_Load_Glyph(mTypeface, glyph_id, load_flags); diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index b69b8f243f..b6bc15c0dc 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -54,4 +54,6 @@ LOCAL_C_INCLUDES := \ external/libxml2/include \ external/skia/src/core +LOCAL_CPPFLAGS += -Werror -Wall -Wextra + include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/HbFaceCacheTest.cpp b/engine/src/flutter/tests/HbFaceCacheTest.cpp index fbaf0eab15..76eec5b5a8 100644 --- a/engine/src/flutter/tests/HbFaceCacheTest.cpp +++ b/engine/src/flutter/tests/HbFaceCacheTest.cpp @@ -35,18 +35,18 @@ public: MockMinikinFont(int32_t id) : mId(id) { } - virtual float GetHorizontalAdvance( - uint32_t glyph_id, const MinikinPaint &paint) const { + virtual float GetHorizontalAdvance(uint32_t /* glyph_id */, + const MinikinPaint& /* paint */) const { LOG_ALWAYS_FATAL("MockMinikinFont::GetHorizontalAdvance is not implemented."); return 0.0f; } - virtual void GetBounds(MinikinRect* bounds, uint32_t glyph_id, - const MinikinPaint &paint) const { + virtual void GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph_id */, + const MinikinPaint& /* paint */) const { LOG_ALWAYS_FATAL("MockMinikinFont::GetBounds is not implemented."); } - virtual bool GetTable(uint32_t tag, uint8_t *buf, size_t *size) { + virtual bool GetTable(uint32_t /* tag */, uint8_t* /* buf */, size_t* /* size */) { LOG_ALWAYS_FATAL("MockMinikinFont::GetTable is not implemented."); return false; } diff --git a/engine/src/flutter/tests/MinikinFontForTest.cpp b/engine/src/flutter/tests/MinikinFontForTest.cpp index 033241e26d..ed7075188b 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/MinikinFontForTest.cpp @@ -29,14 +29,14 @@ MinikinFontForTest::MinikinFontForTest(const std::string& font_path) : mFontPath MinikinFontForTest::~MinikinFontForTest() { } -float MinikinFontForTest::GetHorizontalAdvance( - uint32_t glyph_id, const android::MinikinPaint &paint) const { +float MinikinFontForTest::GetHorizontalAdvance(uint32_t /* glyph_id */, + const android::MinikinPaint& /* paint */) const { LOG_ALWAYS_FATAL("MinikinFontForTest::GetHorizontalAdvance is not yet implemented"); return 0.0f; } -void MinikinFontForTest::GetBounds(android::MinikinRect* bounds, uint32_t glyph_id, - const android::MinikinPaint& paint) const { +void MinikinFontForTest::GetBounds(android::MinikinRect* /* bounds */, uint32_t /* glyph_id */, + const android::MinikinPaint& /* paint */) const { LOG_ALWAYS_FATAL("MinikinFontForTest::GetBounds is not yet implemented"); } From 34c39bcde69c8505fd72c460ee601dff1ad4c8c9 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 29 Oct 2015 11:39:58 -0700 Subject: [PATCH 118/364] Accept variation selector in emoji sequences - DO NOT MERGE This patch basically ignores variation selectors for the purpose of itemization into font runs. This allows GSUB to be applied when input sequences contain variation selectors. Bug: 25368653 Change-Id: I9c1d325ae0cd322c21b7e850d0ec4d73551b2372 --- engine/src/flutter/libs/minikin/FontCollection.cpp | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index b4bfe313ba..2bcbc03779 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -167,6 +167,10 @@ static bool isStickyWhitelisted(uint32_t c) { return false; } +static bool isVariationSelector(uint32_t c) { + return (0xFE00 <= c && c <= 0xFE0F) || (0xE0100 <= c && c <= 0xE01EF); +} + void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style, vector* result) const { FontLanguage lang = style.getLanguage(); @@ -184,9 +188,11 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty nShorts = 2; } } - // Continue using existing font as long as it has coverage and is whitelisted + // Continue using existing font as long as it has coverage and is whitelisted; + // also variation sequences continue existing run. if (lastFamily == NULL - || !(isStickyWhitelisted(ch) && lastFamily->getCoverage()->get(ch))) { + || !((isStickyWhitelisted(ch) && lastFamily->getCoverage()->get(ch)) + || isVariationSelector(ch))) { FontFamily* family = getFamilyForChar(ch, lang, variant); if (i == 0 || family != lastFamily) { size_t start = i; From 5001f2ae481c3b77ffcb2b64803cc9e96e5cfeb9 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 2 Nov 2015 17:17:24 -0800 Subject: [PATCH 119/364] Suppress linebreaks in emoji ZWJ sequences - DO NOT MERGE Due to the way emoji ZWJ sequences are defined, the ICU line breaking algorithm determines that there are valid line breaks inside the sequence. This patch suppresses these line breaks. Bug: 25433289 Change-Id: I225ebebc0f4186e4b8f48fee399c4a62b3f0218a --- .../src/flutter/libs/minikin/LineBreaker.cpp | 33 +++++++++++++++++-- 1 file changed, 31 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index a832ca20e2..77374feaa0 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -17,6 +17,7 @@ #define VERBOSE_DEBUG 0 #include +#include #define LOG_TAG "Minikin" #include @@ -30,6 +31,7 @@ namespace android { const int CHAR_TAB = 0x0009; const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; +const uint16_t CHAR_ZWJ = 0x200D; // Large scores in a hierarchy; we prefer desperate breaks to an overfull line. All these // constants are larger than any reasonable actual width score. @@ -123,6 +125,32 @@ static bool isLineBreakingHyphen(uint16_t c) { c == 0x2E40); // DOUBLE HYPHEN } +/** + * Determine whether a line break at position i within the buffer buf is valid. This + * represents customization beyond the ICU behavior, because plain ICU provides some + * line break opportunities that we don't want. + **/ +static bool isBreakValid(uint16_t codeUnit, const uint16_t* buf, size_t bufEnd, size_t i) { + if (codeUnit == CHAR_SOFT_HYPHEN) { + return false; + } + if (codeUnit == CHAR_ZWJ) { + // Possible emoji ZWJ sequence + uint32_t next_codepoint; + U16_NEXT(buf, i, bufEnd, next_codepoint); + if (next_codepoint == 0x2764 || // HEAVY BLACK HEART + next_codepoint == 0x1F466 || // BOY + next_codepoint == 0x1F467 || // GIRL + next_codepoint == 0x1F468 || // MAN + next_codepoint == 0x1F469 || // WOMAN + next_codepoint == 0x1F48B || // KISS MARK + next_codepoint == 0x1F5E8) { // LEFT SPEECH BUBBLE + return false; + } + } + return true; +} + // Ordinarily, this method measures the text in the range given. However, when paint // is nullptr, it assumes the widths have already been calculated and stored in the // width buffer. @@ -175,8 +203,9 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa } if (i + 1 == current) { // Override ICU's treatment of soft hyphen as a break opportunity, because we want it - // to be a hyphen break, with penalty and drawing behavior. - if (c != CHAR_SOFT_HYPHEN) { + // to be a hyphen break, with penalty and drawing behavior. Also, suppress line + // breaks within emoji ZWJ sequences. + if (isBreakValid(c, mTextBuf.data(), end, i + 1)) { // TODO: Add a new type of HyphenEdit for breaks whose hyphen already exists, so // we can pass the whole word down to Hyphenator like the soft hyphen case. bool wordEndsInHyphen = isLineBreakingHyphen(c); From 40ffbdf94c93487dcf86bf6e073a8272eb10ce09 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Fri, 30 Oct 2015 17:09:01 +0900 Subject: [PATCH 120/364] Fix invalid decrement range of KEYCAP handling in itemize. This issue was introduced by I22ce0e9eadc941f84e3a9b23462f194e51dd7180. Need to decrement the two utf16 chars in KEYCAP handling. To add unit tests, this CL also addresses the Bug: 24184208 by introducing self built fonts since there is no good example in system installed fonts. Bug: 24184208 Change-Id: I23fa008adbaced78a3cb96442a6bc8892ab84ce8 --- .../flutter/libs/minikin/FontCollection.cpp | 6 +- .../tests/FontCollectionItemizeTest.cpp | 67 +++++++++++++------ engine/src/flutter/tests/FontTestUtils.cpp | 17 ++--- engine/src/flutter/tests/FontTestUtils.h | 3 +- 4 files changed, 58 insertions(+), 35 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 2c22880259..9fe0686e29 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -225,14 +225,14 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty // Workaround for Emoji keycap until we implement per-cluster font // selection: if keycap is found in a different font that also // supports previous char, attach previous char to the new run. - // Only handles non-surrogate characters. // Bug 7557244. if (ch == KEYCAP && utf16Pos != 0 && family && family->getCoverage()->get(prevCh)) { - run->end--; + const size_t prevChLength = U16_LENGTH(prevCh); + run->end -= prevChLength; if (run->start == run->end) { result->pop_back(); } - start--; + start -= prevChLength; } Run dummy; result->push_back(dummy); diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 3c453f3062..ae1cbf47db 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -24,15 +24,18 @@ using android::FontCollection; using android::FontLanguage; using android::FontStyle; -const char kEmojiFont[] = "/system/fonts/NotoColorEmoji.ttf"; -const char kJAFont[] = "/system/fonts/NotoSansJP-Regular.otf"; -const char kKOFont[] = "/system/fonts/NotoSansKR-Regular.otf"; -const char kLatinBoldFont[] = "/system/fonts/Roboto-Bold.ttf"; -const char kLatinBoldItalicFont[] = "/system/fonts/Roboto-BoldItalic.ttf"; -const char kLatinFont[] = "/system/fonts/Roboto-Regular.ttf"; -const char kLatinItalicFont[] = "/system/fonts/Roboto-Italic.ttf"; -const char kZH_HansFont[] = "/system/fonts/NotoSansSC-Regular.otf"; -const char kZH_HantFont[] = "/system/fonts/NotoSansTC-Regular.otf"; +const char kItemizeFontXml[] = "/data/minikin/test/data/itemize.xml"; +#define kTestFontDir "/data/minikin/test/data/" + +const char kEmojiFont[] = kTestFontDir "Emoji.ttf"; +const char kJAFont[] = kTestFontDir "Ja.ttf"; +const char kKOFont[] = kTestFontDir "Ko.ttf"; +const char kLatinBoldFont[] = kTestFontDir "Bold.ttf"; +const char kLatinBoldItalicFont[] = kTestFontDir "BoldItalic.ttf"; +const char kLatinFont[] = kTestFontDir "Regular.ttf"; +const char kLatinItalicFont[] = kTestFontDir "Italic.ttf"; +const char kZH_HansFont[] = kTestFontDir "ZhHans.ttf"; +const char kZH_HantFont[] = kTestFontDir "ZhHant.ttf"; // Utility function for calling itemize function. void itemize(FontCollection* collection, const char* str, FontStyle style, @@ -52,7 +55,7 @@ const std::string& getFontPath(const FontCollection::Run& run) { } TEST(FontCollectionItemizeTest, itemize_latin) { - std::unique_ptr collection = getFontCollection(); + std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; const FontStyle kRegularStyle = FontStyle(); @@ -122,7 +125,7 @@ TEST(FontCollectionItemizeTest, itemize_latin) { } TEST(FontCollectionItemizeTest, itemize_emoji) { - std::unique_ptr collection = getFontCollection(); + std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; itemize(collection.get(), "U+1F469 U+1F467", FontStyle(), &runs); @@ -143,6 +146,28 @@ TEST(FontCollectionItemizeTest, itemize_emoji) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + itemize(collection.get(), "U+1F470 U+20E3", FontStyle(), &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(3, runs[0].end); + EXPECT_EQ(kEmojiFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + itemize(collection.get(), "U+242EE U+1F470 U+20E3", FontStyle(), &runs); + ASSERT_EQ(2U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + EXPECT_EQ(2, runs[1].start); + EXPECT_EQ(5, runs[1].end); + EXPECT_EQ(kEmojiFont, getFontPath(runs[1])); + EXPECT_FALSE(runs[1].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[1].fakedFont.fakery.isFakeItalic()); + // Currently there is no fonts which has a glyph for 'a' + U+20E3, so they // are splitted into two. itemize(collection.get(), "'a' U+20E3", FontStyle(), &runs); @@ -161,7 +186,7 @@ TEST(FontCollectionItemizeTest, itemize_emoji) { } TEST(FontCollectionItemizeTest, itemize_non_latin) { - std::unique_ptr collection = getFontCollection(); + std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; FontStyle kJAStyle = FontStyle(FontLanguage("ja_JP", 5)); @@ -239,7 +264,7 @@ TEST(FontCollectionItemizeTest, itemize_non_latin) { } TEST(FontCollectionItemizeTest, itemize_mixed) { - std::unique_ptr collection = getFontCollection(); + std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; FontStyle kUSStyle = FontStyle(FontLanguage("en_US", 5)); @@ -278,7 +303,7 @@ TEST(FontCollectionItemizeTest, itemize_mixed) { } TEST(FontCollectionItemizeTest, itemize_variationSelector) { - std::unique_ptr collection = getFontCollection(); + std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; // A glyph for U+4FAE is provided by both Japanese font and Simplified @@ -392,17 +417,17 @@ TEST(FontCollectionItemizeTest, itemize_variationSelector) { ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); - EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontPath(runs[0])); itemize(collection.get(), "U+FE00", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); - EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontPath(runs[0])); } TEST(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { - std::unique_ptr collection = getFontCollection(); + std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; // A glyph for U+845B is provided by both Japanese font and Simplified @@ -517,17 +542,17 @@ TEST(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); - EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontPath(runs[0])); itemize(collection.get(), "U+E0100", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); - EXPECT_EQ(kLatinFont, getFontPath(runs[0])); + EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontPath(runs[0])); } TEST(FontCollectionItemizeTest, itemize_no_crash) { - std::unique_ptr collection = getFontCollection(); + std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; // Broken Surrogate pairs. Check only not crashing. @@ -551,7 +576,7 @@ TEST(FontCollectionItemizeTest, itemize_no_crash) { } TEST(FontCollectionItemizeTest, itemize_fakery) { - std::unique_ptr collection = getFontCollection(); + std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; FontStyle kJABoldStyle = FontStyle(FontLanguage("ja_JP", 5), 0, 7, false); diff --git a/engine/src/flutter/tests/FontTestUtils.cpp b/engine/src/flutter/tests/FontTestUtils.cpp index e5d6c2a448..8e1d184adc 100644 --- a/engine/src/flutter/tests/FontTestUtils.cpp +++ b/engine/src/flutter/tests/FontTestUtils.cpp @@ -19,13 +19,12 @@ #include #include +#include #include "MinikinFontForTest.h" -const char kFontDir[] = "/system/fonts/"; -const char kFontXml[] = "/system/etc/fonts.xml"; - -std::unique_ptr getFontCollection() { - xmlDoc* doc = xmlReadFile(kFontXml, NULL, 0); +std::unique_ptr getFontCollection( + const char* fontDir, const char* fontXml) { + xmlDoc* doc = xmlReadFile(fontXml, NULL, 0); xmlNode* familySet = xmlDocGetRootElement(doc); std::vector families; @@ -59,13 +58,11 @@ std::unique_ptr getFontCollection() { xmlGetProp(fontNode, (const xmlChar*)"style"), (const xmlChar*)"italic") == 0; xmlChar* fontFileName = xmlNodeListGetString(doc, fontNode->xmlChildrenNode, 1); - std::string fontPath = kFontDir + std::string((const char*)fontFileName); + std::string fontPath = fontDir + std::string((const char*)fontFileName); xmlFree(fontFileName); - if (access(fontPath.c_str(), R_OK) != 0) { - // Skip not accessible fonts. - continue; - } + LOG_ALWAYS_FATAL_IF(access(fontPath.c_str(), R_OK) != 0, + "%s is not found", fontPath.c_str()); family->addFont(new MinikinFontForTest(fontPath), android::FontStyle(weight, italic)); } diff --git a/engine/src/flutter/tests/FontTestUtils.h b/engine/src/flutter/tests/FontTestUtils.h index d53956f2d5..7c62c46407 100644 --- a/engine/src/flutter/tests/FontTestUtils.h +++ b/engine/src/flutter/tests/FontTestUtils.h @@ -25,6 +25,7 @@ * This function reads /system/etc/fonts.xml and make font families and * collections of them. MinikinFontForTest is used for FontFamily creation. */ -std::unique_ptr getFontCollection(); +std::unique_ptr getFontCollection( + const char* fontDir, const char* fontXml); #endif // MINIKIN_FONT_TEST_UTILS_H From 6e98debfaf50ad0d301fef2d2b656ba175b2e02c Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 29 Oct 2015 11:39:58 -0700 Subject: [PATCH 121/364] Accept variation selector in emoji sequences - DO NOT MERGE This patch basically ignores variation selectors for the purpose of itemization into font runs. This allows GSUB to be applied when input sequences contain variation selectors. Bug: 25368653 Change-Id: I9c1d325ae0cd322c21b7e850d0ec4d73551b2372 --- engine/src/flutter/libs/minikin/FontCollection.cpp | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index b4bfe313ba..2bcbc03779 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -167,6 +167,10 @@ static bool isStickyWhitelisted(uint32_t c) { return false; } +static bool isVariationSelector(uint32_t c) { + return (0xFE00 <= c && c <= 0xFE0F) || (0xE0100 <= c && c <= 0xE01EF); +} + void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style, vector* result) const { FontLanguage lang = style.getLanguage(); @@ -184,9 +188,11 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty nShorts = 2; } } - // Continue using existing font as long as it has coverage and is whitelisted + // Continue using existing font as long as it has coverage and is whitelisted; + // also variation sequences continue existing run. if (lastFamily == NULL - || !(isStickyWhitelisted(ch) && lastFamily->getCoverage()->get(ch))) { + || !((isStickyWhitelisted(ch) && lastFamily->getCoverage()->get(ch)) + || isVariationSelector(ch))) { FontFamily* family = getFamilyForChar(ch, lang, variant); if (i == 0 || family != lastFamily) { size_t start = i; From d40c0c59e446196c0beff54968913205f7f6fe28 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 2 Nov 2015 17:17:24 -0800 Subject: [PATCH 122/364] Suppress linebreaks in emoji ZWJ sequences - DO NOT MERGE Due to the way emoji ZWJ sequences are defined, the ICU line breaking algorithm determines that there are valid line breaks inside the sequence. This patch suppresses these line breaks. Bug: 25433289 Change-Id: I225ebebc0f4186e4b8f48fee399c4a62b3f0218a --- .../src/flutter/libs/minikin/LineBreaker.cpp | 33 +++++++++++++++++-- 1 file changed, 31 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index a832ca20e2..77374feaa0 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -17,6 +17,7 @@ #define VERBOSE_DEBUG 0 #include +#include #define LOG_TAG "Minikin" #include @@ -30,6 +31,7 @@ namespace android { const int CHAR_TAB = 0x0009; const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; +const uint16_t CHAR_ZWJ = 0x200D; // Large scores in a hierarchy; we prefer desperate breaks to an overfull line. All these // constants are larger than any reasonable actual width score. @@ -123,6 +125,32 @@ static bool isLineBreakingHyphen(uint16_t c) { c == 0x2E40); // DOUBLE HYPHEN } +/** + * Determine whether a line break at position i within the buffer buf is valid. This + * represents customization beyond the ICU behavior, because plain ICU provides some + * line break opportunities that we don't want. + **/ +static bool isBreakValid(uint16_t codeUnit, const uint16_t* buf, size_t bufEnd, size_t i) { + if (codeUnit == CHAR_SOFT_HYPHEN) { + return false; + } + if (codeUnit == CHAR_ZWJ) { + // Possible emoji ZWJ sequence + uint32_t next_codepoint; + U16_NEXT(buf, i, bufEnd, next_codepoint); + if (next_codepoint == 0x2764 || // HEAVY BLACK HEART + next_codepoint == 0x1F466 || // BOY + next_codepoint == 0x1F467 || // GIRL + next_codepoint == 0x1F468 || // MAN + next_codepoint == 0x1F469 || // WOMAN + next_codepoint == 0x1F48B || // KISS MARK + next_codepoint == 0x1F5E8) { // LEFT SPEECH BUBBLE + return false; + } + } + return true; +} + // Ordinarily, this method measures the text in the range given. However, when paint // is nullptr, it assumes the widths have already been calculated and stored in the // width buffer. @@ -175,8 +203,9 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa } if (i + 1 == current) { // Override ICU's treatment of soft hyphen as a break opportunity, because we want it - // to be a hyphen break, with penalty and drawing behavior. - if (c != CHAR_SOFT_HYPHEN) { + // to be a hyphen break, with penalty and drawing behavior. Also, suppress line + // breaks within emoji ZWJ sequences. + if (isBreakValid(c, mTextBuf.data(), end, i + 1)) { // TODO: Add a new type of HyphenEdit for breaks whose hyphen already exists, so // we can pass the whole word down to Hyphenator like the soft hyphen case. bool wordEndsInHyphen = isLineBreakingHyphen(c); From 77476fc5b9de291cacdeaccdf0f54300795a755a Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Wed, 21 Oct 2015 23:48:50 +0900 Subject: [PATCH 123/364] Introduce FontCollection::hasVariationSelector method. To implement Paint.hasGlyph(), we need a new method to ask the FontCollection if it has a glyph for the code point and variation selector pair. Bug: 11256006 Change-Id: Ie4185c91bcaa4d01aee6beb97784b1f9d2a88f12 --- .../flutter/include/minikin/FontCollection.h | 5 ++ .../flutter/libs/minikin/FontCollection.cpp | 22 ++++++ engine/src/flutter/tests/Android.mk | 1 + .../src/flutter/tests/FontCollectionTest.cpp | 78 +++++++++++++++++++ 4 files changed, 106 insertions(+) create mode 100644 engine/src/flutter/tests/FontCollectionTest.cpp diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index ca24e386a0..09c9356e09 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -40,6 +40,11 @@ public: void itemize(const uint16_t *string, size_t string_length, FontStyle style, std::vector* result) const; + // Returns true if there is a glyph for the code point and variation selector pair. + // Returns false if no fonts have a glyph for the code point and variation + // selector pair, or invalid variation selector is passed. + bool hasVariationSelector(uint32_t baseCodepoint, uint32_t variationSelector) const; + // Get the base font for the given style, useful for font-wide metrics. MinikinFont* baseFont(FontStyle style); diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 9fe0686e29..74974137ec 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -67,6 +67,10 @@ FontCollection::FontCollection(const vector& typefaces) : "Font collection must have at least one valid typeface"); size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage; size_t offset = 0; + // TODO: Use variation selector map for mRanges construction. + // 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. for (size_t i = 0; i < nPages; i++) { Range dummy; mRanges.push_back(dummy); @@ -177,6 +181,24 @@ static bool isVariationSelector(uint32_t c) { return (0xFE00 <= c && c <= 0xFE0F) || (0xE0100 <= c && c <= 0xE01EF); } +bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, + uint32_t variationSelector) const { + if (!isVariationSelector(variationSelector)) { + return false; + } + if (baseCodepoint >= mMaxChar) { + return false; + } + // Currently mRanges can not be used here since it isn't aware of the variation sequence. + // TODO: Use mRanges for narrowing down the search range. + for (size_t i = 0; i < mFamilies.size(); i++) { + if (mFamilies[i]->hasVariationSelector(baseCodepoint, variationSelector)) { + return true; + } + } + return false; +} + void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style, vector* result) const { FontLanguage lang = style.getLanguage(); diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index b6bc15c0dc..d12dca72e3 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -39,6 +39,7 @@ LOCAL_STATIC_LIBRARIES += \ libxml2 LOCAL_SRC_FILES += \ + FontCollectionTest.cpp \ FontCollectionItemizeTest.cpp \ FontFamilyTest.cpp \ FontTestUtils.cpp \ diff --git a/engine/src/flutter/tests/FontCollectionTest.cpp b/engine/src/flutter/tests/FontCollectionTest.cpp new file mode 100644 index 0000000000..593575617f --- /dev/null +++ b/engine/src/flutter/tests/FontCollectionTest.cpp @@ -0,0 +1,78 @@ +/* + * 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. + */ + +#include + +#include +#include "MinikinFontForTest.h" +#include "MinikinInternal.h" + +namespace android { + +// The test font has following glyphs. +// U+82A6 +// U+82A6 U+FE00 (VS1) +// U+82A6 U+E0100 (VS17) +// U+82A6 U+E0101 (VS18) +// U+82A6 U+E0102 (VS19) +// U+845B +// U+845B U+FE01 (VS2) +// U+845B U+E0101 (VS18) +// U+845B U+E0102 (VS19) +// U+845B U+E0103 (VS20) +// U+537F +// U+717D U+FE02 (VS3) +// U+717D U+E0102 (VS19) +// U+717D U+E0103 (VS20) +const char kVsTestFont[] = "/data/minikin/test/data/VarioationSelectorTest-Regular.ttf"; + +void expectVSGlyphs(const FontCollection& fc, uint32_t codepoint, const std::set& vsSet) { + for (uint32_t vs = 0xFE00; vs <= 0xE01EF; ++vs) { + // Move to variation selectors supplements after variation selectors. + if (vs == 0xFF00) { + vs = 0xE0100; + } + if (vsSet.find(vs) == vsSet.end()) { + EXPECT_FALSE(fc.hasVariationSelector(codepoint, vs)) + << "Glyph for U+" << std::hex << codepoint << " U+" << vs; + } else { + EXPECT_TRUE(fc.hasVariationSelector(codepoint, vs)) + << "Glyph for U+" << std::hex << codepoint << " U+" << vs; + } + } +} + +TEST(FontCollectionTest, hasVariationSelectorTest) { + FontFamily* family = new FontFamily(); + family->addFont(new MinikinFontForTest(kVsTestFont)); + std::vector families({family}); + FontCollection fc(families); + family->Unref(); + + EXPECT_FALSE(fc.hasVariationSelector(0x82A6, 0)); + expectVSGlyphs(fc, 0x82A6, std::set({0xFE00, 0xE0100, 0xE0101, 0xE0102})); + + EXPECT_FALSE(fc.hasVariationSelector(0x845B, 0)); + expectVSGlyphs(fc, 0x845B, std::set({0xFE01, 0xE0101, 0xE0102, 0xE0103})); + + EXPECT_FALSE(fc.hasVariationSelector(0x537F, 0)); + expectVSGlyphs(fc, 0x537F, std::set({})); + + EXPECT_FALSE(fc.hasVariationSelector(0x717D, 0)); + expectVSGlyphs(fc, 0x717D, std::set({0xFE02, 0xE0102, 0xE0103})); +} + +} // namespace android From 3700f235084f994bac5f86ebdd874d3b85a0bdc6 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Wed, 18 Nov 2015 20:25:27 +0900 Subject: [PATCH 124/364] Search all families instead of using mRanges for variation sequence. To optimize the font family search, mRanges is used for narrowing down the search range. However, mRanges is constructed from format 4 or format 12 entries. So, if the font supports a variation sequence but doesn't support the base character of the sequence, the font may not be listed in mRanges. The proper way to fix this issue is using format 14 subtable information for mRanges construction. However, this is not a trivial work since currently we rely on HarfBuzz for variation sequence lookup and it doesn't provide any API for retrieving coverage information. Thus, as the quick fix, iterate all font families in font fallback chain if the variation sequence is specified. Change-Id: I278da84be8fb8f553590e2e42ed450b7e4a34eca --- .../flutter/libs/minikin/FontCollection.cpp | 15 ++++++++-- .../tests/FontCollectionItemizeTest.cpp | 29 +++++++++++++++++++ 2 files changed, 42 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 9fe0686e29..d2c5a3b9a9 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -108,14 +108,25 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, if (ch >= mMaxChar) { return NULL; } - const Range& range = mRanges[ch >> kLogCharsPerPage]; + + // Even if the font supports variation sequence, mRanges isn't aware of the base character of + // the sequence. Search all FontFamilies if variation sequence is specified. + // TODO: Always use mRanges for font search. + const std::vector& familyVec = (vs == 0) ? mFamilyVec : mFamilies; + Range range; + if (vs == 0) { + range = mRanges[ch >> kLogCharsPerPage]; + } else { + range = { 0, mFamilies.size() }; + } + #ifdef VERBOSE_DEBUG ALOGD("querying range %zd:%zd\n", range.start, range.end); #endif FontFamily* bestFamily = nullptr; int bestScore = -1; for (size_t i = range.start; i < range.end; i++) { - FontFamily* family = mFamilyVec[i]; + FontFamily* family = familyVec[i]; if (vs == 0 ? family->getCoverage()->get(ch) : family->hasVariationSelector(ch, vs)) { // First font family in collection always matches if (mFamilies[0] == family) { diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index ae1cbf47db..47f5259c73 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -21,6 +21,7 @@ #include "UnicodeUtils.h" using android::FontCollection; +using android::FontFamily; using android::FontLanguage; using android::FontStyle; @@ -614,3 +615,31 @@ TEST(FontCollectionItemizeTest, itemize_fakery) { EXPECT_TRUE(runs[0].fakedFont.fakery.isFakeItalic()); } +TEST(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { + // kVSTestFont supports U+717D U+FE02 but doesn't support U+717D. + // kVSTestFont should be selected for U+717D U+FE02 even if it does not support the base code + // point. + const std::string kVSTestFont = kTestFontDir "VarioationSelectorTest-Regular.ttf"; + + std::vector families; + FontFamily* family1 = new FontFamily(FontLanguage(), android::VARIANT_DEFAULT); + family1->addFont(new MinikinFontForTest(kLatinFont)); + families.push_back(family1); + + FontFamily* family2 = new FontFamily(FontLanguage(), android::VARIANT_DEFAULT); + family2->addFont(new MinikinFontForTest(kVSTestFont)); + families.push_back(family2); + + FontCollection collection(families); + + std::vector runs; + + itemize(&collection, "U+717D U+FE02", FontStyle(), &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kVSTestFont, getFontPath(runs[0])); + + family1->Unref(); + family2->Unref(); +} From 371e5dbb3f61fbfb653eed4fa2e452f8978419ff Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 30 Nov 2015 15:04:59 -0800 Subject: [PATCH 125/364] Avoid integer overflows in parsing fonts A malformed TTF can cause size calculations to overflow. This patch checks the maximum reasonable value so that the total size fits in 32 bits. It also adds some explicit casting to avoid possible technical undefined behavior when parsing sized unsigned values. Bug: 25645298 Change-Id: Id4716132041a6f4f1fbb73ec4e445391cf7d9616 --- engine/src/flutter/libs/minikin/CmapCoverage.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index 75033729e3..64310006fd 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -29,11 +29,12 @@ namespace android { // These could perhaps be optimized to use __builtin_bswap16 and friends. static uint32_t readU16(const uint8_t* data, size_t offset) { - return data[offset] << 8 | data[offset + 1]; + return ((uint32_t)data[offset]) << 8 | ((uint32_t)data[offset + 1]); } static uint32_t readU32(const uint8_t* data, size_t offset) { - return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]; + return ((uint32_t)data[offset]) << 24 | ((uint32_t)data[offset + 1]) << 16 | + ((uint32_t)data[offset + 2]) << 8 | ((uint32_t)data[offset + 3]); } static void addRange(vector &coverage, uint32_t start, uint32_t end) { @@ -101,11 +102,13 @@ static bool getCoverageFormat12(vector& coverage, const uint8_t* data, const size_t kGroupSize = 12; const size_t kStartCharCodeOffset = 0; const size_t kEndCharCodeOffset = 4; + const size_t kMaxNGroups = 0xfffffff0 / kGroupSize; // protection against overflow + // For all values < kMaxNGroups, kFirstGroupOffset + nGroups * kGroupSize fits in 32 bits. if (kFirstGroupOffset > size) { return false; } uint32_t nGroups = readU32(data, kNGroupsOffset); - if (kFirstGroupOffset + nGroups * kGroupSize > size) { + if (nGroups >= kMaxNGroups || kFirstGroupOffset + nGroups * kGroupSize > size) { return false; } for (uint32_t i = 0; i < nGroups; i++) { From 1fd1c390217da22a54b49e9a91bc79b0323e6a73 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 30 Nov 2015 15:04:59 -0800 Subject: [PATCH 126/364] Avoid integer overflows in parsing fonts A malformed TTF can cause size calculations to overflow. This patch checks the maximum reasonable value so that the total size fits in 32 bits. It also adds some explicit casting to avoid possible technical undefined behavior when parsing sized unsigned values. Bug: 25645298 Change-Id: Id4716132041a6f4f1fbb73ec4e445391cf7d9616 (cherry picked from commit 371e5dbb3f61fbfb653eed4fa2e452f8978419ff) --- engine/src/flutter/libs/minikin/CmapCoverage.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index 4156d69d5a..8be45d173c 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -30,11 +30,12 @@ namespace android { // These could perhaps be optimized to use __builtin_bswap16 and friends. static uint32_t readU16(const uint8_t* data, size_t offset) { - return data[offset] << 8 | data[offset + 1]; + return ((uint32_t)data[offset]) << 8 | ((uint32_t)data[offset + 1]); } static uint32_t readU32(const uint8_t* data, size_t offset) { - return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]; + return ((uint32_t)data[offset]) << 24 | ((uint32_t)data[offset + 1]) << 16 | + ((uint32_t)data[offset + 2]) << 8 | ((uint32_t)data[offset + 3]); } static void addRange(vector &coverage, uint32_t start, uint32_t end) { @@ -101,11 +102,13 @@ static bool getCoverageFormat12(vector& coverage, const uint8_t* data, const size_t kGroupSize = 12; const size_t kStartCharCodeOffset = 0; const size_t kEndCharCodeOffset = 4; + const size_t kMaxNGroups = 0xfffffff0 / kGroupSize; // protection against overflow + // For all values < kMaxNGroups, kFirstGroupOffset + nGroups * kGroupSize fits in 32 bits. if (kFirstGroupOffset > size) { return false; } uint32_t nGroups = readU32(data, kNGroupsOffset); - if (kFirstGroupOffset + nGroups * kGroupSize > size) { + if (nGroups >= kMaxNGroups || kFirstGroupOffset + nGroups * kGroupSize > size) { return false; } for (uint32_t i = 0; i < nGroups; i++) { From c047506ec25e0ed90f77b0fa127ef5644b4e1b0e Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 29 Oct 2015 18:59:30 +0900 Subject: [PATCH 127/364] Select emoji font based on variation selectors. If U+FE0E is appended to the emoji code point, the glyph should have a text presentation. On the other hand, if U+FE0F is appended to the emoji code point, the glyph should have an emoji presentation. Bug: 11256006 Change-Id: I5187d44500b13a138e7ffbcf2c72e2da06374c8c --- .../src/flutter/include/minikin/FontFamily.h | 4 +- .../flutter/libs/minikin/FontCollection.cpp | 30 +- .../src/flutter/libs/minikin/FontFamily.cpp | 29 +- .../tests/FontCollectionItemizeTest.cpp | 261 +++++++++++++++++- engine/src/flutter/tests/FontFamilyTest.cpp | 13 + 5 files changed, 316 insertions(+), 21 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index fc05e3b219..776bcc41be 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -48,6 +48,7 @@ public: operator bool() const { return mBits != 0; } bool isUnsupported() const { return mBits == kUnsupportedLanguage; } + bool hasEmojiFlag() const { return isUnsupported() ? false : (mBits & kEmojiFlag); } std::string getString() const; @@ -61,9 +62,10 @@ private: static const uint32_t kUnsupportedLanguage = 0xFFFFFFFFu; static const uint32_t kBaseLangMask = 0xFFFFFFu; - static const uint32_t kScriptMask = (1u << 26) - (1u << 24); static const uint32_t kHansFlag = 1u << 24; static const uint32_t kHantFlag = 1u << 25; + static const uint32_t kEmojiFlag = 1u << 26; + static const uint32_t kScriptMask = kHansFlag | kHantFlag | kEmojiFlag; uint32_t mBits; }; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index ea702226af..d089e8b0d9 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -106,7 +106,15 @@ FontCollection::~FontCollection() { // 2. If a font matches both language and script, it gets a score of 4. // 3. If a font matches just language, it gets a score of 2. // 4. Matching the "compact" or "elegant" variant adds one to the score. -// 5. Highest score wins, with ties resolved to the first font. +// 5. If there is a variation selector and a font supports the complete variation sequence, we add +// 12 to the score. +// 6. If there is a color variation selector (U+FE0F), we add 6 to the score if the font is an emoji +// font. This additional score of 6 is only given if the base character is supported in the font, +// but not the whole variation sequence. +// 7. If there is a text variation selector (U+FE0E), we add 6 to the score if the font is not an +// emoji font. This additional score of 6 is only given if the base character is supported in the +// font, but not the whole variation sequence. +// 8. Highest score wins, with ties resolved to the first font. FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, FontLanguage lang, int variant) const { if (ch >= mMaxChar) { @@ -131,27 +139,29 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, int bestScore = -1; for (size_t i = range.start; i < range.end; i++) { FontFamily* family = familyVec[i]; - if (vs == 0 ? family->getCoverage()->get(ch) : family->hasVariationSelector(ch, vs)) { - // First font family in collection always matches - if (mFamilies[0] == family) { + const bool hasVSGlyph = (vs != 0) && family->hasVariationSelector(ch, vs); + if (hasVSGlyph || family->getCoverage()->get(ch)) { + if ((vs == 0 || hasVSGlyph) && mFamilies[0] == family) { + // If the first font family in collection supports the given character or sequence, + // always use it. return family; } int score = lang.match(family->lang()) * 2; if (family->variant() == 0 || family->variant() == variant) { score++; } + if (hasVSGlyph) { + score += 12; + } else if (((vs == 0xFE0F) && family->lang().hasEmojiFlag()) || + ((vs == 0xFE0E) && !family->lang().hasEmojiFlag())) { + score += 6; + } if (score > bestScore) { bestScore = score; bestFamily = family; } } } - if (bestFamily == nullptr && vs != 0) { - // If no fonts support the codepoint and variation selector pair, - // fallback to select a font family that supports just the base - // character, ignoring the variation selector. - return getFamilyForChar(ch, 0, lang, variant); - } if (bestFamily == nullptr && !mFamilyVec.empty()) { UErrorCode errorCode = U_ZERO_ERROR; const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode); diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 1ff5a6bce4..5adff57b6e 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -62,11 +62,15 @@ FontLanguage::FontLanguage(const char* buf, size_t size) { uint16_t c = buf[next]; if (c == '-' || c == '_') break; } - if (next - i == 4 && buf[i] == 'H' && buf[i+1] == 'a' && buf[i+2] == 'n') { - if (buf[i+3] == 's') { - bits |= kHansFlag; - } else if (buf[i+3] == 't') { - bits |= kHantFlag; + if (next - i == 4) { + if (buf[i] == 'H' && buf[i+1] == 'a' && buf[i+2] == 'n') { + if (buf[i+3] == 's') { + bits |= kHansFlag; + } else if (buf[i+3] == 't') { + bits |= kHantFlag; + } + } else if (buf[i] == 'Q' && buf[i+1] == 'a' && buf[i+2] == 'a'&& buf[i+3] == 'e') { + bits |= kEmojiFlag; } } // TODO: this might be a good place to infer script from country (zh_TW -> Hant), @@ -96,10 +100,17 @@ std::string FontLanguage::getString() const { buf[i++] = 'd'; } buf[i++] = '-'; - buf[i++] = 'H'; - buf[i++] = 'a'; - buf[i++] = 'n'; - buf[i++] = (mBits & kHansFlag) ? 's' : 't'; + if (mBits & kEmojiFlag) { + buf[i++] = 'Q'; + buf[i++] = 'a'; + buf[i++] = 'a'; + buf[i++] = 'e'; + } else { + buf[i++] = 'H'; + buf[i++] = 'a'; + buf[i++] = 'n'; + buf[i++] = (mBits & kHansFlag) ? 's' : 't'; + } } return std::string(buf, i); } diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 47f5259c73..a7da4269a6 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -25,9 +25,9 @@ using android::FontFamily; using android::FontLanguage; using android::FontStyle; -const char kItemizeFontXml[] = "/data/minikin/test/data/itemize.xml"; #define kTestFontDir "/data/minikin/test/data/" +const char kItemizeFontXml[] = kTestFontDir "itemize.xml"; const char kEmojiFont[] = kTestFontDir "Emoji.ttf"; const char kJAFont[] = kTestFontDir "Ja.ttf"; const char kKOFont[] = kTestFontDir "Ko.ttf"; @@ -38,6 +38,12 @@ const char kLatinItalicFont[] = kTestFontDir "Italic.ttf"; const char kZH_HansFont[] = kTestFontDir "ZhHans.ttf"; const char kZH_HantFont[] = kTestFontDir "ZhHant.ttf"; +const char kEmojiXmlFile[] = kTestFontDir "emoji.xml"; +const char kNoGlyphFont[] = kTestFontDir "NoGlyphFont.ttf"; +const char kColorEmojiFont[] = kTestFontDir "ColorEmojiFont.ttf"; +const char kTextEmojiFont[] = kTestFontDir "TextEmojiFont.ttf"; +const char kMixedEmojiFont[] = kTestFontDir "ColorTextMixedEmojiFont.ttf"; + // Utility function for calling itemize function. void itemize(FontCollection* collection, const char* str, FontStyle style, std::vector* result) { @@ -52,6 +58,7 @@ void itemize(FontCollection* collection, const char* str, FontStyle style, // Utility function to obtain font path associated with run. const std::string& getFontPath(const FontCollection::Run& run) { + EXPECT_NE(nullptr, run.fakedFont.font); return ((MinikinFontForTest*)run.fakedFont.font)->fontPath(); } @@ -425,6 +432,21 @@ TEST(FontCollectionItemizeTest, itemize_variationSelector) { EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontPath(runs[0])); + + // First font family (Regular.ttf) supports U+203C but doesn't support U+203C U+FE0F. + // Emoji.ttf font supports supports U+203C U+FE0F. Emoji.ttf should be selected. + itemize(collection.get(), "U+203C U+FE0F", kZH_HantStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kEmojiFont, getFontPath(runs[0])); + + // First font family (Regular.ttf) supports U+203C U+FE0E. + itemize(collection.get(), "U+203C U+FE0E", kZH_HantStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kLatinFont, getFontPath(runs[0])); } TEST(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { @@ -643,3 +665,240 @@ TEST(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { family1->Unref(); family2->Unref(); } + +TEST(FontCollectionItemizeTest, itemize_emojiSelection) { + std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); + std::vector runs; + + const FontStyle kDefaultFontStyle; + + // U+00A9 is a text default emoji which is only available in TextEmojiFont.ttf. + // TextEmojiFont.ttf should be selected. + itemize(collection.get(), "U+00A9", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); + + // U+00AE is a text default emoji which is only available in ColorEmojiFont.ttf. + // ColorEmojiFont.ttf should be selected. + itemize(collection.get(), "U+00AE", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + // U+203C is a text default emoji which is available in both TextEmojiFont.ttf and + // ColorEmojiFont.ttf. TextEmojiFont.ttf should be selected. + itemize(collection.get(), "U+203C", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + // TODO: use text font for text default emoji. + // EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); + + // U+2049 is a text default emoji which is not available in either TextEmojiFont.ttf or + // ColorEmojiFont.ttf. No font should be selected. + itemize(collection.get(), "U+2049", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); + + // U+231A is a emoji default emoji which is available only in TextEmojiFont.ttf. + // TextEmojiFont.ttf should be selected. + itemize(collection.get(), "U+231A", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); + + // U+231B is a emoji default emoji which is available only in ColorEmojiFont.ttf. + // ColorEmojiFont.ttf should be selected. + itemize(collection.get(), "U+231B", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + // U+23E9 is a emoji default emoji which is available in both TextEmojiFont.ttf and + // ColorEmojiFont.ttf. ColorEmojiFont should be selected. + itemize(collection.get(), "U+23E9", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + // U+23EA is a emoji default emoji which is not avaialble in either TextEmojiFont.ttf and + // ColorEmojiFont.ttf. No font should b e selected. + itemize(collection.get(), "U+23EA", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); +} + +TEST(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { + std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); + std::vector runs; + + const FontStyle kDefaultFontStyle; + + // U+00A9 is a text default emoji which is only available in TextEmojiFont.ttf. + // TextEmojiFont.ttf should be selected. + itemize(collection.get(), "U+00A9 U+FE0E", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); + + // U+00A9 is a text default emoji which is only available in ColorEmojiFont.ttf. + // ColorEmojiFont.ttf should be selected. + itemize(collection.get(), "U+00AE U+FE0E", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + // Text emoji is specified but it is not available. Use color emoji instead. + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + // U+203C is a text default emoji which is available in both TextEmojiFont.ttf and + // ColorEmojiFont.ttf. TextEmojiFont.ttf should be selected. + itemize(collection.get(), "U+203C U+FE0E", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); + + // U+2049 is a text default emoji which is not available either TextEmojiFont.ttf or + // ColorEmojiFont.ttf. No font should be selected. + itemize(collection.get(), "U+2049 U+FE0E", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); + + // U+231A is a emoji default emoji which is available only in TextEmojifFont. + // TextEmojiFont.ttf sohuld be selected. + itemize(collection.get(), "U+231A U+FE0E", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); + + // U+231B is a emoji default emoji which is available only in ColorEmojiFont.ttf. + // ColorEmojiFont.ttf should be selected. + itemize(collection.get(), "U+231B U+FE0E", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + // Text emoji is specified but it is not available. Use color emoji instead. + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + // U+23E9 is a emoji default emoji which is available in both TextEmojiFont.ttf and + // ColorEmojiFont.ttf. TextEmojiFont.ttf should be selected even if U+23E9 is emoji default + // emoji since U+FE0E is appended. + itemize(collection.get(), "U+23E9 U+FE0E", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); + + // U+23EA is a emoji default emoji but which is not available in either TextEmojiFont.ttf or + // ColorEmojiFont.ttf. No font should be selected. + itemize(collection.get(), "U+23EA U+FE0E", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); + + // U+26FA U+FE0E is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F + // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. + itemize(collection.get(), "U+26FA U+FE0E", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kMixedEmojiFont, getFontPath(runs[0])); +} + +TEST(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { + std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); + std::vector runs; + + const FontStyle kDefaultFontStyle; + + // U+00A9 is a text default emoji which is available only in TextEmojiFont.ttf. + // TextEmojiFont.ttf shoudl be selected. + itemize(collection.get(), "U+00A9 U+FE0F", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + // Color emoji is specified but it is not available. Use text representaion instead. + EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); + + // U+00AE is a text default emoji which is available only in ColorEmojiFont.ttf. + // ColorEmojiFont.ttf should be selected. + itemize(collection.get(), "U+00AE U+FE0F", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + // U+203C is a text default emoji which is available in both TextEmojiFont.ttf and + // ColorEmojiFont.ttf. ColorEmojiFont.ttf should be selected even if U+203C is a text default + // emoji since U+FF0F is appended. + itemize(collection.get(), "U+203C U+FE0F", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + // U+2049 is a text default emoji which is not available in either TextEmojiFont.ttf or + // ColorEmojiFont.ttf. No font should be selected. + itemize(collection.get(), "U+2049 U+FE0F", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); + + // U+231A is a emoji default emoji which is available only in TextEmojiFont.ttf. + // TextEmojiFont.ttf should be selected. + itemize(collection.get(), "U+231A U+FE0F", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + // Color emoji is specified but it is not available. Use text representation instead. + EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); + + // U+231B is a emoji default emoji which is available only in ColorEmojiFont.ttf. + // ColorEmojiFont.ttf should be selected. + itemize(collection.get(), "U+231B U+FE0F", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + // U+23E9 is a emoji default emoji which is available in both TextEmojiFont.ttf and + // ColorEmojiFont.ttf. ColorEmojiFont.ttf should be selected. + itemize(collection.get(), "U+23E9 U+FE0F", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + // U+23EA is a emoji default emoji which is not available in either TextEmojiFont.ttf or + // ColorEmojiFont.ttf. No font should be selected. + itemize(collection.get(), "U+23EA U+FE0F", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); + + // U+26F9 U+FE0F is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F + // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. + itemize(collection.get(), "U+26F9 U+FE0F", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kMixedEmojiFont, getFontPath(runs[0])); +} + diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index 78f286c0ca..d46245cd1f 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -70,6 +70,19 @@ TEST(FontLanguagesTest, repeatedLanguageTests) { EXPECT_EQ(english, langs[0]); } +TEST(FontLanguagesTest, undEmojiTests) { + FontLanguage emoji("und-Qaae", 8); + EXPECT_TRUE(emoji.hasEmojiFlag()); + + FontLanguage und("und", 3); + EXPECT_FALSE(und.hasEmojiFlag()); + EXPECT_FALSE(emoji == und); + + FontLanguage undExample("und-example", 10); + EXPECT_FALSE(undExample.hasEmojiFlag()); + EXPECT_FALSE(emoji == undExample); +} + // The test font has following glyphs. // U+82A6 // U+82A6 U+FE00 (VS1) From 091810c32bf9bd14db7749e957eb76d731527057 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Wed, 2 Dec 2015 11:07:29 +0900 Subject: [PATCH 128/364] Introduce FontLanguageListCache. FontLanguageListCache is an intentionally leaky singleton and its internal cache won't be purged. BUG: 25122318 Change-Id: I272097e979fe44b83fd86822235350e12eda8f51 --- .../flutter/include/minikin/FontCollection.h | 2 +- .../src/flutter/include/minikin/FontFamily.h | 37 ++++++----- engine/src/flutter/libs/minikin/Android.mk | 1 + .../flutter/libs/minikin/FontCollection.cpp | 21 ++++-- .../src/flutter/libs/minikin/FontFamily.cpp | 28 ++++++++ .../libs/minikin/FontLanguageListCache.cpp | 66 +++++++++++++++++++ .../libs/minikin/FontLanguageListCache.h | 55 ++++++++++++++++ engine/src/flutter/libs/minikin/Layout.cpp | 9 ++- engine/src/flutter/tests/Android.mk | 1 + .../tests/FontCollectionItemizeTest.cpp | 23 +++---- engine/src/flutter/tests/FontFamilyTest.cpp | 22 +++++++ .../tests/FontLanguageListCacheTest.cpp | 61 +++++++++++++++++ 12 files changed, 291 insertions(+), 35 deletions(-) create mode 100644 engine/src/flutter/libs/minikin/FontLanguageListCache.cpp create mode 100644 engine/src/flutter/libs/minikin/FontLanguageListCache.h create mode 100644 engine/src/flutter/tests/FontLanguageListCacheTest.cpp diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 09c9356e09..cd14261640 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -65,7 +65,7 @@ private: size_t end; }; - FontFamily* getFamilyForChar(uint32_t ch, uint32_t vs, FontLanguage lang, int variant) const; + FontFamily* getFamilyForChar(uint32_t ch, uint32_t vs, uint32_t langListId, int variant) const; // static for allocating unique id's static uint32_t sNextId; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 776bcc41be..539a06cef0 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -87,35 +87,42 @@ private: }; // FontStyle represents all style information needed to select an actual font -// from a collection. The implementation is packed into a single 32-bit word +// from a collection. The implementation is packed into two 32-bit words // so it can be efficiently copied, embedded in other objects, etc. class FontStyle { public: - FontStyle(int weight = 4, bool italic = false) { - bits = (weight & kWeightMask) | (italic ? kItalicMask : 0); - } - FontStyle(FontLanguage lang, int variant = 0, int weight = 4, bool italic = false) { - bits = (weight & kWeightMask) | (italic ? kItalicMask : 0) - | (variant << kVariantShift) | (lang.bits() << kLangShift); - } - FontStyle(FontLanguages langs, int variant = 0, int weight = 4, bool italic = false) : - // TODO: Use all the languages in langs - FontStyle(langs[0], variant, weight, italic) { } + FontStyle() : FontStyle(0 /* variant */, 4 /* weight */, false /* italic */) {} + FontStyle(int weight, bool italic) : FontStyle(0 /* variant */, weight, italic) {} + FontStyle(uint32_t langListId) + : FontStyle(langListId, 0 /* variant */, 4 /* weight */, false /* italic */) {} + + FontStyle(int variant, int weight, bool italic); + FontStyle(uint32_t langListId, int variant, int weight, bool italic); + int getWeight() const { return bits & kWeightMask; } bool getItalic() const { return (bits & kItalicMask) != 0; } int getVariant() const { return (bits >> kVariantShift) & kVariantMask; } - FontLanguage getLanguage() const { return FontLanguage(bits >> kLangShift); } + uint32_t getLanguageListId() const { return mLanguageListId; } - bool operator==(const FontStyle other) const { return bits == other.bits; } + bool operator==(const FontStyle other) const { + return bits == other.bits && mLanguageListId == other.mLanguageListId; + } - hash_t hash() const { return bits; } + hash_t hash() const; + + // Looks up a language list from an internal cache and returns its ID. + // If the passed language list is not in the cache, registers it and returns newly assigned ID. + static uint32_t registerLanguageList(const std::string& languages); private: static const uint32_t kWeightMask = (1 << 4) - 1; static const uint32_t kItalicMask = 1 << 4; static const int kVariantShift = 5; static const uint32_t kVariantMask = (1 << 2) - 1; - static const int kLangShift = 7; + + static uint32_t pack(int variant, int weight, bool italic); + uint32_t bits; + uint32_t mLanguageListId; }; enum FontVariant { diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index c728b09b84..4c945a60c9 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -21,6 +21,7 @@ minikin_src_files := \ CmapCoverage.cpp \ FontCollection.cpp \ FontFamily.cpp \ + FontLanguageListCache.cpp \ GraphemeBreak.cpp \ HbFaceCache.cpp \ Hyphenator.cpp \ diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index d089e8b0d9..6201f7492f 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -22,6 +22,7 @@ #include "unicode/unistr.h" #include "unicode/unorm2.h" +#include "FontLanguageListCache.h" #include "MinikinInternal.h" #include @@ -116,11 +117,15 @@ FontCollection::~FontCollection() { // font, but not the whole variation sequence. // 8. Highest score wins, with ties resolved to the first font. FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, - FontLanguage lang, int variant) const { + uint32_t langListId, int variant) const { if (ch >= mMaxChar) { return NULL; } + const FontLanguages& langList = FontLanguageListCache::getById(langListId); + // TODO: use all languages in langList. + const FontLanguage lang = (langList.size() == 0) ? FontLanguage() : langList[0]; + // Even if the font supports variation sequence, mRanges isn't aware of the base character of // the sequence. Search all FontFamilies if variation sequence is specified. // TODO: Always use mRanges for font search. @@ -162,6 +167,12 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, } } } + if (bestFamily == nullptr && vs != 0) { + // If no fonts support the codepoint and variation selector pair, + // fallback to select a font family that supports just the base + // character, ignoring the variation selector. + return getFamilyForChar(ch, 0, langListId, variant); + } if (bestFamily == nullptr && !mFamilyVec.empty()) { UErrorCode errorCode = U_ZERO_ERROR; const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode); @@ -171,7 +182,7 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, if (U_SUCCESS(errorCode) && len > 0) { int off = 0; U16_NEXT_UNSAFE(decomposed, off, ch); - return getFamilyForChar(ch, vs, lang, variant); + return getFamilyForChar(ch, vs, langListId, variant); } } bestFamily = mFamilies[0]; @@ -222,7 +233,7 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style, vector* result) const { - FontLanguage lang = style.getLanguage(); + const uint32_t langListId = style.getLanguageListId(); int variant = style.getVariant(); FontFamily* lastFamily = NULL; Run* run = NULL; @@ -261,8 +272,8 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } if (!shouldContinueRun) { - FontFamily* family = - getFamilyForChar(ch, isVariationSelector(nextCh) ? nextCh : 0, lang, variant); + FontFamily* family = getFamilyForChar(ch, isVariationSelector(nextCh) ? nextCh : 0, + langListId, variant); if (utf16Pos == 0 || family != lastFamily) { size_t start = utf16Pos; // Workaround for Emoji keycap until we implement per-cluster font diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 5adff57b6e..5a3952437a 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -26,6 +26,9 @@ #include #include +#include + +#include "FontLanguageListCache.h" #include "HbFaceCache.h" #include "MinikinInternal.h" #include @@ -159,6 +162,31 @@ FontLanguages::FontLanguages(const char* buf, size_t size) { } } +FontStyle::FontStyle(int variant, int weight, bool italic) + : FontStyle(FontLanguageListCache::kEmptyListId, variant, weight, italic) { +} + +FontStyle::FontStyle(uint32_t languageListId, int variant, int weight, bool italic) + : bits(pack(variant, weight, italic)), mLanguageListId(languageListId) { +} + +hash_t FontStyle::hash() const { + uint32_t hash = JenkinsHashMix(0, bits); + hash = JenkinsHashMix(hash, mLanguageListId); + return JenkinsHashWhiten(hash); +} + +// static +uint32_t FontStyle::registerLanguageList(const std::string& languages) { + AutoMutex _l(gMinikinLock); + return FontLanguageListCache::getId(languages); +} + +// static +uint32_t FontStyle::pack(int variant, int weight, bool italic) { + return (weight & kWeightMask) | (italic ? kItalicMask : 0) | (variant << kVariantShift); +} + FontFamily::~FontFamily() { for (size_t i = 0; i < mFonts.size(); i++) { mFonts[i].typeface->UnrefLocked(); diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp new file mode 100644 index 0000000000..e1c2343dda --- /dev/null +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp @@ -0,0 +1,66 @@ +/* + * 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. + */ + +#define LOG_TAG "Minikin" + +#include "FontLanguageListCache.h" + +#include + +#include "MinikinInternal.h" + +namespace android { + +const uint32_t FontLanguageListCache::kEmptyListId; + +// static +uint32_t FontLanguageListCache::getId(const std::string& languages) { + FontLanguageListCache* inst = FontLanguageListCache::getInstance(); + std::unordered_map::const_iterator it = + inst->mLanguageListLookupTable.find(languages); + if (it != inst->mLanguageListLookupTable.end()) { + return it->second; + } + + // Given language list is not in cache. Insert it and return newly assigned ID. + const uint32_t nextId = inst->mLanguageLists.size(); + inst->mLanguageLists.push_back(FontLanguages(languages.c_str(), languages.size())); + inst->mLanguageListLookupTable.insert(std::make_pair(languages, nextId)); + return nextId; +} + +// static +const FontLanguages& FontLanguageListCache::getById(uint32_t id) { + FontLanguageListCache* inst = FontLanguageListCache::getInstance(); + LOG_ALWAYS_FATAL_IF(id >= inst->mLanguageLists.size(), "Lookup by unknown language list ID."); + return inst->mLanguageLists[id]; +} + +// static +FontLanguageListCache* FontLanguageListCache::getInstance() { + assertMinikinLocked(); + static FontLanguageListCache* instance = nullptr; + if (instance == nullptr) { + instance = new FontLanguageListCache(); + + // Insert an empty language list for mapping empty language list to kEmptyListId. + instance->mLanguageLists.push_back(FontLanguages()); + instance->mLanguageListLookupTable.insert(std::make_pair("", kEmptyListId)); + } + return instance; +} + +} // namespace android diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.h b/engine/src/flutter/libs/minikin/FontLanguageListCache.h new file mode 100644 index 0000000000..7d627b562e --- /dev/null +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.h @@ -0,0 +1,55 @@ +/* + * 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. + */ + +#ifndef MINIKIN_FONT_LANGUAGE_LIST_CACHE_H +#define MINIKIN_FONT_LANGUAGE_LIST_CACHE_H + +#include + +#include + +namespace android { + +class FontLanguageListCache { +public: + // A special ID for the empty language list. + // This value must be 0 since the empty language list is inserted into mLanguageLists by + // default. + const static uint32_t kEmptyListId = 0; + + // Returns language list ID for the given string representation of FontLanguages. + // Caller should acquire a lock before calling the method. + static uint32_t getId(const std::string& languages); + + // Caller should acquire a lock before calling the method. + static const FontLanguages& getById(uint32_t id); + +private: + FontLanguageListCache() {} // Singleton + ~FontLanguageListCache() {} + + // Caller should acquire a lock before calling the method. + static FontLanguageListCache* getInstance(); + + std::vector mLanguageLists; + + // A map from string representation of the font language list to the ID. + std::unordered_map mLanguageListLookupTable; +}; + +} // namespace android + +#endif // MINIKIN_FONT_LANGUAGE_LIST_CACHE_H diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 3b140faa2b..af5e6fe75a 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -34,6 +34,7 @@ #include #include +#include "FontLanguageListCache.h" #include "LayoutUtils.h" #include "HbFaceCache.h" #include "MinikinInternal.h" @@ -742,9 +743,11 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_buffer_clear_contents(buffer); hb_buffer_set_script(buffer, script); hb_buffer_set_direction(buffer, isRtl? HB_DIRECTION_RTL : HB_DIRECTION_LTR); - FontLanguage language = ctx->style.getLanguage(); - if (language) { - string lang = language.getString(); + const FontLanguages& langList = + FontLanguageListCache::getById(ctx->style.getLanguageListId()); + if (langList.size() != 0) { + // TODO: use all languages in langList. + string lang = langList[0].getString(); hb_buffer_set_language(buffer, hb_language_from_string(lang.c_str(), -1)); } hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index d12dca72e3..2eb2abe2a2 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -42,6 +42,7 @@ LOCAL_SRC_FILES += \ FontCollectionTest.cpp \ FontCollectionItemizeTest.cpp \ FontFamilyTest.cpp \ + FontLanguageListCacheTest.cpp \ FontTestUtils.cpp \ MinikinFontForTest.cpp \ GraphemeBreakTests.cpp \ diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index a7da4269a6..d0dc39c974 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -197,9 +197,9 @@ TEST(FontCollectionItemizeTest, itemize_non_latin) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; - FontStyle kJAStyle = FontStyle(FontLanguage("ja_JP", 5)); - FontStyle kUSStyle = FontStyle(FontLanguage("en_US", 5)); - FontStyle kZH_HansStyle = FontStyle(FontLanguage("zh_Hans", 7)); + FontStyle kJAStyle = FontStyle(FontStyle::registerLanguageList("ja_JP")); + FontStyle kUSStyle = FontStyle(FontStyle::registerLanguageList("en_US")); + FontStyle kZH_HansStyle = FontStyle(FontStyle::registerLanguageList("zh_Hans")); // All Japanese Hiragana characters. itemize(collection.get(), "U+3042 U+3044 U+3046 U+3048 U+304A", kUSStyle, &runs); @@ -275,7 +275,7 @@ TEST(FontCollectionItemizeTest, itemize_mixed) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; - FontStyle kUSStyle = FontStyle(FontLanguage("en_US", 5)); + FontStyle kUSStyle = FontStyle(FontStyle::registerLanguageList("en_US")); itemize(collection.get(), "'a' U+4F60 'b' U+4F60 'c'", kUSStyle, &runs); ASSERT_EQ(5U, runs.size()); @@ -318,8 +318,8 @@ TEST(FontCollectionItemizeTest, itemize_variationSelector) { // Chinese font. Also a glyph for U+242EE is provided by both Japanese and // Traditional Chinese font. To avoid effects of device default locale, // explicitly specify the locale. - FontStyle kZH_HansStyle = FontStyle(FontLanguage("zh_Hans", 7)); - FontStyle kZH_HantStyle = FontStyle(FontLanguage("zh_Hant", 7)); + FontStyle kZH_HansStyle = FontStyle(FontStyle::registerLanguageList("zh_Hans")); + FontStyle kZH_HantStyle = FontStyle(FontStyle::registerLanguageList("zh_Hant")); // U+4FAE is available in both zh_Hans and ja font, but U+4FAE,U+FE00 is // only available in ja font. @@ -457,8 +457,8 @@ TEST(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { // Chinese font. Also a glyph for U+242EE is provided by both Japanese and // Traditional Chinese font. To avoid effects of device default locale, // explicitly specify the locale. - FontStyle kZH_HansStyle = FontStyle(FontLanguage("zh_Hans", 7)); - FontStyle kZH_HantStyle = FontStyle(FontLanguage("zh_Hant", 7)); + FontStyle kZH_HansStyle = FontStyle(FontStyle::registerLanguageList("zh_Hans")); + FontStyle kZH_HantStyle = FontStyle(FontStyle::registerLanguageList("zh_Hant")); // U+845B is available in both zh_Hans and ja font, but U+845B,U+E0100 is // only available in ja font. @@ -602,9 +602,10 @@ TEST(FontCollectionItemizeTest, itemize_fakery) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; - FontStyle kJABoldStyle = FontStyle(FontLanguage("ja_JP", 5), 0, 7, false); - FontStyle kJAItalicStyle = FontStyle(FontLanguage("ja_JP", 5), 0, 5, true); - FontStyle kJABoldItalicStyle = FontStyle(FontLanguage("ja_JP", 5), 0, 7, true); + FontStyle kJABoldStyle = FontStyle(FontStyle::registerLanguageList("ja_JP"), 0, 7, false); + FontStyle kJAItalicStyle = FontStyle(FontStyle::registerLanguageList("ja_JP"), 0, 5, true); + FontStyle kJABoldItalicStyle = + FontStyle(FontStyle::registerLanguageList("ja_JP"), 0, 7, true); // Currently there is no italic or bold font for Japanese. FontFakery has // the differences between desired and actual font style. diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index d46245cd1f..fa8302c60c 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -17,6 +17,7 @@ #include #include +#include "FontLanguageListCache.h" #include "MinikinFontForTest.h" #include "MinikinInternal.h" @@ -83,6 +84,27 @@ TEST(FontLanguagesTest, undEmojiTests) { EXPECT_FALSE(emoji == undExample); } +TEST(FontLanguagesTest, registerLanguageListTest) { + EXPECT_EQ(0UL, FontStyle::registerLanguageList("")); + EXPECT_NE(0UL, FontStyle::registerLanguageList("en")); + EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); + EXPECT_NE(0UL, FontStyle::registerLanguageList("en,zh-Hans")); + + EXPECT_EQ(FontStyle::registerLanguageList("en"), FontStyle::registerLanguageList("en")); + EXPECT_NE(FontStyle::registerLanguageList("en"), FontStyle::registerLanguageList("jp")); + + EXPECT_EQ(FontStyle::registerLanguageList("en,zh-Hans"), + FontStyle::registerLanguageList("en,zh-Hans")); + EXPECT_NE(FontStyle::registerLanguageList("en,zh-Hans"), + FontStyle::registerLanguageList("zh-Hans,en")); + EXPECT_NE(FontStyle::registerLanguageList("en,zh-Hans"), + FontStyle::registerLanguageList("jp")); + EXPECT_NE(FontStyle::registerLanguageList("en,zh-Hans"), + FontStyle::registerLanguageList("en")); + EXPECT_NE(FontStyle::registerLanguageList("en,zh-Hans"), + FontStyle::registerLanguageList("en,zh-Hant")); +} + // The test font has following glyphs. // U+82A6 // U+82A6 U+FE00 (VS1) diff --git a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp new file mode 100644 index 0000000000..29757fedce --- /dev/null +++ b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp @@ -0,0 +1,61 @@ +/* + * 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. + */ + +#include + +#include +#include "FontLanguageListCache.h" + +namespace android { + +TEST(FontLanguageListCacheTest, getId) { + EXPECT_EQ(0UL, FontLanguageListCache::getId("")); + EXPECT_NE(0UL, FontStyle::registerLanguageList("en")); + EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); + EXPECT_NE(0UL, FontStyle::registerLanguageList("en,zh-Hans")); + + EXPECT_EQ(FontLanguageListCache::getId("en"), FontLanguageListCache::getId("en")); + EXPECT_NE(FontLanguageListCache::getId("en"), FontLanguageListCache::getId("jp")); + + EXPECT_EQ(FontLanguageListCache::getId("en,zh-Hans"), + FontLanguageListCache::getId("en,zh-Hans")); + EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), + FontLanguageListCache::getId("zh-Hans,en")); + EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), + FontLanguageListCache::getId("jp")); + EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), + FontLanguageListCache::getId("en")); + EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), + FontLanguageListCache::getId("en,zh-Hant")); +} + +TEST(FontLanguageListCacheTest, getById) { + FontLanguage english("en", 2); + FontLanguage japanese("jp", 2); + + EXPECT_EQ(0UL, FontLanguageListCache::getById(0).size()); + + FontLanguages langs = FontLanguageListCache::getById(FontLanguageListCache::getId("en")); + ASSERT_EQ(1UL, langs.size()); + EXPECT_EQ(english, langs[0]); + + langs = FontLanguageListCache::getById(FontLanguageListCache::getId("en,jp")); + ASSERT_EQ(2UL, langs.size()); + EXPECT_EQ(english, langs[0]); + EXPECT_EQ(japanese, langs[1]); +} + +} // android From 01c7dcc124296b1fbf1abb8af115d92021b0e6cd Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Mon, 7 Dec 2015 10:28:31 -0800 Subject: [PATCH 129/364] Copy test font files into data directory. To work native tests with additional font related files, copy the files into /data/nativetest/minikin_tests/. This copy only happens when the minikin_tests is built. It is not an expected to copy the font files into the product image. Change-Id: I7d83abc077bce4e38fd93c7d607bc7e1f7871e6b --- engine/src/flutter/tests/Android.mk | 40 ++++++++++++++++++- .../tests/FontCollectionItemizeTest.cpp | 2 - .../src/flutter/tests/FontCollectionTest.cpp | 2 +- engine/src/flutter/tests/FontFamilyTest.cpp | 2 +- engine/src/flutter/tests/how_to_run.txt | 2 +- 5 files changed, 42 insertions(+), 6 deletions(-) diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index 2eb2abe2a2..044e65de2e 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -16,12 +16,49 @@ LOCAL_PATH := $(call my-dir) +data_root_for_test_zip := $(TARGET_OUT_DATA)/DATA/ +minikin_tests_subpath_from_data := nativetest/minikin_tests +minikin_tests_root_in_device := /data/$(minikin_tests_subpath_from_data) +minikin_tests_root_for_test_zip := $(data_root_for_test_zip)/$(minikin_tests_subpath_from_data) + +define build-one-test-font-module +$(eval include $(CLEAR_VARS))\ +$(eval LOCAL_MODULE := $(1))\ +$(eval LOCAL_SRC_FILES := $(1))\ +$(eval LOCAL_MODULE_CLASS := ETC)\ +$(eval LOCAL_MODULE_TAGS := tests)\ +$(eval LOCAL_MODULE_PATH := $(minikin_tests_root_for_test_zip))\ +$(eval include $(BUILD_PREBUILT)) +endef + +font_src_files := \ + data/BoldItalic.ttf \ + data/Bold.ttf \ + data/ColorEmojiFont.ttf \ + data/ColorTextMixedEmojiFont.ttf \ + data/Emoji.ttf \ + data/Italic.ttf \ + data/Ja.ttf \ + data/Ko.ttf \ + data/NoGlyphFont.ttf \ + data/Regular.ttf \ + data/TextEmojiFont.ttf \ + data/VarioationSelectorTest-Regular.ttf \ + data/ZhHans.ttf \ + data/ZhHant.ttf \ + data/itemize.xml \ + data/emoji.xml + +$(foreach f, $(font_src_files), $(call build-one-test-font-module, $(f))) + include $(CLEAR_VARS) LOCAL_MODULE := minikin_tests LOCAL_MODULE_TAGS := tests LOCAL_STATIC_LIBRARIES := libminikin +LOCAL_ADDITIONAL_DEPENDENCIES = $(font_src_files) +LOCAL_PICKUP_FILES := $(data_root_for_test_zip) # Shared libraries which are dependencies of minikin; these are not automatically # pulled in by the build system (and thus sadly must be repeated). @@ -56,6 +93,7 @@ LOCAL_C_INCLUDES := \ external/libxml2/include \ external/skia/src/core -LOCAL_CPPFLAGS += -Werror -Wall -Wextra +LOCAL_CPPFLAGS += -Werror -Wall -Wextra \ + -DkTestFontDir="\"$(minikin_tests_root_in_device)/data/\"" include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index d0dc39c974..57ed6ee33d 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -25,8 +25,6 @@ using android::FontFamily; using android::FontLanguage; using android::FontStyle; -#define kTestFontDir "/data/minikin/test/data/" - const char kItemizeFontXml[] = kTestFontDir "itemize.xml"; const char kEmojiFont[] = kTestFontDir "Emoji.ttf"; const char kJAFont[] = kTestFontDir "Ja.ttf"; diff --git a/engine/src/flutter/tests/FontCollectionTest.cpp b/engine/src/flutter/tests/FontCollectionTest.cpp index 593575617f..bbc53e3645 100644 --- a/engine/src/flutter/tests/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/FontCollectionTest.cpp @@ -37,7 +37,7 @@ namespace android { // U+717D U+FE02 (VS3) // U+717D U+E0102 (VS19) // U+717D U+E0103 (VS20) -const char kVsTestFont[] = "/data/minikin/test/data/VarioationSelectorTest-Regular.ttf"; +const char kVsTestFont[] = kTestFontDir "/VarioationSelectorTest-Regular.ttf"; void expectVSGlyphs(const FontCollection& fc, uint32_t codepoint, const std::set& vsSet) { for (uint32_t vs = 0xFE00; vs <= 0xE01EF; ++vs) { diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index fa8302c60c..fc44e6c636 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -120,7 +120,7 @@ TEST(FontLanguagesTest, registerLanguageListTest) { // U+717D U+FE02 (VS3) // U+717D U+E0102 (VS19) // U+717D U+E0103 (VS20) -const char kVsTestFont[] = "/data/minikin/test/data/VarioationSelectorTest-Regular.ttf"; +const char kVsTestFont[] = kTestFontDir "VarioationSelectorTest-Regular.ttf"; class FontFamilyTest : public testing::Test { public: diff --git a/engine/src/flutter/tests/how_to_run.txt b/engine/src/flutter/tests/how_to_run.txt index 09c3b0614e..a135c30e13 100644 --- a/engine/src/flutter/tests/how_to_run.txt +++ b/engine/src/flutter/tests/how_to_run.txt @@ -1,5 +1,5 @@ mmm -j8 frameworks/minikin/tests && adb push $OUT/data/nativetest/minikin_tests/minikin_tests \ /data/nativetest/minikin_tests/minikin_tests && -adb push -p frameworks/minikin/tests/data /data/minikin/test/data && +adb push frameworks/minikin/tests/data /data/nativetest/minikin_tests/data && adb shell /data/nativetest/minikin_tests/minikin_tests From eb3ba19800a187135045757193cd48a6599d5f15 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Wed, 9 Dec 2015 15:55:10 -0800 Subject: [PATCH 130/364] Remove script matching score from the font selection fallback. Removing the extra score of 2 for the script matching from the font fallback score calculation. If the two langauges have different scripts, we should treat them as different languages. Change-Id: Ie0d6f27bd1086248895935a7bd01b5d404044ad0 --- .../src/flutter/include/minikin/FontFamily.h | 2 +- .../flutter/libs/minikin/FontCollection.cpp | 23 +++++++++---------- .../src/flutter/libs/minikin/FontFamily.cpp | 12 +--------- .../tests/FontCollectionItemizeTest.cpp | 13 ++++++++++- 4 files changed, 25 insertions(+), 25 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 539a06cef0..00130e6f5d 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -52,7 +52,7 @@ public: std::string getString() const; - // 0 = no match, 1 = language matches, 2 = language and script match + // 0 = no match, 1 = language matches int match(const FontLanguage other) const; private: diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 6201f7492f..bba2ef9535 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -104,18 +104,17 @@ FontCollection::~FontCollection() { // Implement heuristic for choosing best-match font. Here are the rules: // 1. If first font in the collection has the character, it wins. -// 2. If a font matches both language and script, it gets a score of 4. -// 3. If a font matches just language, it gets a score of 2. -// 4. Matching the "compact" or "elegant" variant adds one to the score. -// 5. If there is a variation selector and a font supports the complete variation sequence, we add -// 12 to the score. -// 6. If there is a color variation selector (U+FE0F), we add 6 to the score if the font is an emoji -// font. This additional score of 6 is only given if the base character is supported in the font, +// 2. If a font matches language, it gets a score of 2. +// 3. Matching the "compact" or "elegant" variant adds one to the score. +// 4. If there is a variation selector and a font supports the complete variation sequence, we add +// 8 to the score. +// 5. If there is a color variation selector (U+FE0F), we add 4 to the score if the font is an emoji +// font. This additional score of 4 is only given if the base character is supported in the font, // but not the whole variation sequence. -// 7. If there is a text variation selector (U+FE0E), we add 6 to the score if the font is not an -// emoji font. This additional score of 6 is only given if the base character is supported in the +// 6. If there is a text variation selector (U+FE0E), we add 4 to the score if the font is not an +// emoji font. This additional score of 4 is only given if the base character is supported in the // font, but not the whole variation sequence. -// 8. Highest score wins, with ties resolved to the first font. +// 7. Highest score wins, with ties resolved to the first font. FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, uint32_t langListId, int variant) const { if (ch >= mMaxChar) { @@ -156,10 +155,10 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, score++; } if (hasVSGlyph) { - score += 12; + score += 8; } else if (((vs == 0xFE0F) && family->lang().hasEmojiFlag()) || ((vs == 0xFE0E) && !family->lang().hasEmojiFlag())) { - score += 6; + score += 4; } if (score > bestScore) { bestScore = score; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 5a3952437a..7639831240 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -119,17 +119,7 @@ std::string FontLanguage::getString() const { } int FontLanguage::match(const FontLanguage other) const { - if (mBits == kUnsupportedLanguage || other.mBits == kUnsupportedLanguage) - return 0; - - int result = 0; - if ((mBits & kBaseLangMask) == (other.mBits & kBaseLangMask)) { - result++; - if ((mBits & kScriptMask) != 0 && (mBits & kScriptMask) == (other.mBits & kScriptMask)) { - result++; - } - } - return result; + return *this == other; } FontLanguages::FontLanguages(const char* buf, size_t size) { diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 57ed6ee33d..85d76afccb 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -164,7 +164,7 @@ TEST(FontCollectionItemizeTest, itemize_emoji) { ASSERT_EQ(2U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); - EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); @@ -267,6 +267,17 @@ TEST(FontCollectionItemizeTest, itemize_non_latin) { EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); + + // Both zh-Hant and ja fonts support U+242EE, but zh-Hans doesn't. + // Here, ja and zh-Hant font should have the same score but ja should be selected since it is + // listed before zh-Hant. + itemize(collection.get(), "U+242EE", kZH_HansStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kJAFont, getFontPath(runs[0])); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); + EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); } TEST(FontCollectionItemizeTest, itemize_mixed) { From 10fbe684fbabfb51112bcd44e7f2a80d5c9807cb Mon Sep 17 00:00:00 2001 From: Dan Austin Date: Fri, 11 Dec 2015 16:33:23 -0800 Subject: [PATCH 131/364] Refactored unsigned long negations Replaced two instances of negating an unsigned long, which was resulting in aborts from unsigned integer sanitization with the equivalent logical not-add 1. Bug: 25884483 Change-Id: Ic7498e0af638dcd438ce69803021d3cdc3acd4f6 --- engine/src/flutter/libs/minikin/SparseBitSet.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp index 7acb7ba345..9d1fd308bc 100644 --- a/engine/src/flutter/libs/minikin/SparseBitSet.cpp +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -90,13 +90,13 @@ void SparseBitSet::initFromRanges(const uint32_t* ranges, size_t nRanges) { size_t nElements = (end - (start & ~kElMask) + kElMask) >> kLogBitsPerEl; if (nElements == 1) { mBitmaps[index] |= (kElAllOnes >> (start & kElMask)) & - (kElAllOnes << ((-end) & kElMask)); + (kElAllOnes << ((~end + 1) & kElMask)); } else { mBitmaps[index] |= kElAllOnes >> (start & kElMask); for (size_t j = 1; j < nElements - 1; j++) { mBitmaps[index + j] = kElAllOnes; } - mBitmaps[index + nElements - 1] |= kElAllOnes << ((-end) & kElMask); + mBitmaps[index + nElements - 1] |= kElAllOnes << ((~end + 1) & kElMask); } for (size_t j = startPage + 1; j < endPage + 1; j++) { mIndices[j] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl); From e745083812e73e180543f11b274d3b44c972350d Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 15 Dec 2015 16:01:51 -0800 Subject: [PATCH 132/364] No op build should not build minikin_tests Previous CL[1] adds module names into LOCAL_ADDITIONAL_DEPENDENCIES, but it was wrong. LOCAL_ADDITIONAL_DEPENDENCIES only accepts file path. However, BUILD_PREBUILT doesn't provide a file path of the installed font. So use custom tool and LOCAL_GENERATED_SOURCES instead. Confirmed no-op build doesn't built minikin_tests and continuous_native_tests.zip contains all necessary files. [1]: I7d83abc077bce4e38fd93c7d607bc7e1f7871e6b BUG: 26197092 Change-Id: I90e80036248ae72e0e0f9c6144a259f5f96ec9ce --- engine/src/flutter/tests/Android.mk | 24 +++++++++--------------- 1 file changed, 9 insertions(+), 15 deletions(-) diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index 044e65de2e..2483b763c4 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -16,21 +16,13 @@ LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + data_root_for_test_zip := $(TARGET_OUT_DATA)/DATA/ minikin_tests_subpath_from_data := nativetest/minikin_tests minikin_tests_root_in_device := /data/$(minikin_tests_subpath_from_data) minikin_tests_root_for_test_zip := $(data_root_for_test_zip)/$(minikin_tests_subpath_from_data) -define build-one-test-font-module -$(eval include $(CLEAR_VARS))\ -$(eval LOCAL_MODULE := $(1))\ -$(eval LOCAL_SRC_FILES := $(1))\ -$(eval LOCAL_MODULE_CLASS := ETC)\ -$(eval LOCAL_MODULE_TAGS := tests)\ -$(eval LOCAL_MODULE_PATH := $(minikin_tests_root_for_test_zip))\ -$(eval include $(BUILD_PREBUILT)) -endef - font_src_files := \ data/BoldItalic.ttf \ data/Bold.ttf \ @@ -49,15 +41,17 @@ font_src_files := \ data/itemize.xml \ data/emoji.xml -$(foreach f, $(font_src_files), $(call build-one-test-font-module, $(f))) - -include $(CLEAR_VARS) - LOCAL_MODULE := minikin_tests LOCAL_MODULE_TAGS := tests +GEN := $(addprefix $(minikin_tests_root_for_test_zip)/, $(font_src_files)) +$(GEN): PRIVATE_PATH := $(LOCAL_PATH) +$(GEN): PRIVATE_CUSTOM_TOOL = cp $< $@ +$(GEN): $(minikin_tests_root_for_test_zip)/data/% : $(LOCAL_PATH)/data/% + $(transform-generated-source) +LOCAL_GENERATED_SOURCES += $(GEN) + LOCAL_STATIC_LIBRARIES := libminikin -LOCAL_ADDITIONAL_DEPENDENCIES = $(font_src_files) LOCAL_PICKUP_FILES := $(data_root_for_test_zip) # Shared libraries which are dependencies of minikin; these are not automatically From bb5c10092c3ec3246a9f4c52cd6b620e86fa5bd8 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Mon, 14 Dec 2015 18:33:23 -0800 Subject: [PATCH 133/364] Save all kind of script tags into FontLanguage. The main purpose of this CL is expanding FontLanguage to be able to save full script tag. Previously, FontLangauge kept only limited script tags. With this CL, FontLanguage keeps all script tags. This CL contains the following changes: - FontLanguage changes: -- Moved to private directory not to be instantiated outside of Minikin. -- Removed bool(), bits(), FontLanguage(uint32_t) methods which are no longer used. -- Change the FontLanguage internal data structure. -- Introduces script match logic. - FontLanguages changes: -- Moved to private directory not to be instantiated outside of Minikin. -- This is now std::vector - FontLanguageListCache changes: -- Now FontLanguageListCache::getId through FontStyle::registerLanguageList is the only way to instantiate the FontLanguage. -- Normalize input to be BCP47 compliant identifier by ICU. Bug: 26168983 Change-Id: I8df992a6851021903478972601a9a5c9424b100c --- .../src/flutter/include/minikin/FontFamily.h | 64 +---- engine/src/flutter/libs/minikin/Android.mk | 1 + .../flutter/libs/minikin/FontCollection.cpp | 10 +- .../src/flutter/libs/minikin/FontFamily.cpp | 120 +-------- .../src/flutter/libs/minikin/FontLanguage.cpp | 135 ++++++++++ .../src/flutter/libs/minikin/FontLanguage.h | 89 +++++++ .../libs/minikin/FontLanguageListCache.cpp | 90 ++++++- .../libs/minikin/FontLanguageListCache.h | 1 + engine/src/flutter/libs/minikin/Layout.cpp | 13 +- .../tests/FontCollectionItemizeTest.cpp | 32 +-- engine/src/flutter/tests/FontFamilyTest.cpp | 232 ++++++++++++++++-- .../tests/FontLanguageListCacheTest.cpp | 18 +- engine/src/flutter/tests/FontTestUtils.cpp | 7 +- engine/src/flutter/tests/ICUTestBase.h | 52 ++++ 14 files changed, 639 insertions(+), 225 deletions(-) create mode 100644 engine/src/flutter/libs/minikin/FontLanguage.cpp create mode 100644 engine/src/flutter/libs/minikin/FontLanguage.h create mode 100644 engine/src/flutter/tests/ICUTestBase.h diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 00130e6f5d..aa2e0ac2e4 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -30,62 +30,6 @@ namespace android { class MinikinFont; -// FontLanguage is a compact representation of a bcp-47 language tag. It -// does not capture all possible information, only what directly affects -// font rendering. -class FontLanguage { - friend class FontStyle; - friend class FontLanguages; -public: - FontLanguage() : mBits(0) { } - - // Parse from string - FontLanguage(const char* buf, size_t size); - - bool operator==(const FontLanguage other) const { - return mBits != kUnsupportedLanguage && mBits == other.mBits; - } - operator bool() const { return mBits != 0; } - - bool isUnsupported() const { return mBits == kUnsupportedLanguage; } - bool hasEmojiFlag() const { return isUnsupported() ? false : (mBits & kEmojiFlag); } - - std::string getString() const; - - // 0 = no match, 1 = language matches - int match(const FontLanguage other) const; - -private: - explicit FontLanguage(uint32_t bits) : mBits(bits) { } - - uint32_t bits() const { return mBits; } - - static const uint32_t kUnsupportedLanguage = 0xFFFFFFFFu; - static const uint32_t kBaseLangMask = 0xFFFFFFu; - static const uint32_t kHansFlag = 1u << 24; - static const uint32_t kHantFlag = 1u << 25; - static const uint32_t kEmojiFlag = 1u << 26; - static const uint32_t kScriptMask = kHansFlag | kHantFlag | kEmojiFlag; - uint32_t mBits; -}; - -// A list of zero or more instances of FontLanguage, in the order of -// preference. Used for further resolution of rendering results. -class FontLanguages { -public: - FontLanguages() { mLangs.clear(); } - - // Parse from string, which is a comma-separated list of languages - FontLanguages(const char* buf, size_t size); - - const FontLanguage& operator[](size_t index) const { return mLangs.at(index); } - - size_t size() const { return mLangs.size(); } - -private: - std::vector mLangs; -}; - // FontStyle represents all style information needed to select an actual font // from a collection. The implementation is packed into two 32-bit words // so it can be efficiently copied, embedded in other objects, etc. @@ -158,7 +102,9 @@ class FontFamily : public MinikinRefCounted { public: FontFamily() : mHbFont(nullptr) { } - FontFamily(FontLanguage lang, int variant) : mLang(lang), mVariant(variant), mHbFont(nullptr) { + FontFamily(int variant); + + FontFamily(uint32_t langId, int variant) : mLangId(langId), mVariant(variant), mHbFont(nullptr) { } ~FontFamily(); @@ -169,7 +115,7 @@ public: void addFont(MinikinFont* typeface, FontStyle style); FakedFont getClosestMatch(FontStyle style) const; - FontLanguage lang() const { return mLang; } + uint32_t langId() const { return mLangId; } int variant() const { return mVariant; } // API's for enumerating the fonts in a family. These don't guarantee any particular order @@ -200,7 +146,7 @@ private: MinikinFont* typeface; FontStyle style; }; - FontLanguage mLang; + uint32_t mLangId; int mVariant; std::vector mFonts; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 4c945a60c9..42fdca3919 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -21,6 +21,7 @@ minikin_src_files := \ CmapCoverage.cpp \ FontCollection.cpp \ FontFamily.cpp \ + FontLanguage.cpp \ FontLanguageListCache.cpp \ GraphemeBreak.cpp \ HbFaceCache.cpp \ diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index bba2ef9535..62c70310c0 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -22,6 +22,7 @@ #include "unicode/unistr.h" #include "unicode/unorm2.h" +#include "FontLanguage.h" #include "FontLanguageListCache.h" #include "MinikinInternal.h" #include @@ -150,14 +151,17 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, // always use it. return family; } - int score = lang.match(family->lang()) * 2; + + // TODO use all language in the list. + FontLanguage fontLang = FontLanguageListCache::getById(family->langId())[0]; + int score = lang.match(fontLang) * 2; if (family->variant() == 0 || family->variant() == variant) { score++; } if (hasVSGlyph) { score += 8; - } else if (((vs == 0xFE0F) && family->lang().hasEmojiFlag()) || - ((vs == 0xFE0E) && !family->lang().hasEmojiFlag())) { + } else if (((vs == 0xFE0F) && fontLang.hasEmojiFlag()) || + ((vs == 0xFE0E) && !fontLang.hasEmojiFlag())) { score += 4; } if (score > bestScore) { diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 7639831240..1405789028 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -16,8 +16,6 @@ #define LOG_TAG "Minikin" -#include - #include #include #include @@ -28,6 +26,7 @@ #include +#include "FontLanguage.h" #include "FontLanguageListCache.h" #include "HbFaceCache.h" #include "MinikinInternal.h" @@ -41,117 +40,6 @@ using std::vector; namespace android { -// Parse bcp-47 language identifier into internal structure -FontLanguage::FontLanguage(const char* buf, size_t size) { - uint32_t bits = 0; - size_t i; - for (i = 0; i < size; i++) { - uint16_t c = buf[i]; - if (c == '-' || c == '_') break; - } - if (i == 2) { - bits = uint8_t(buf[0]) | (uint8_t(buf[1]) << 8); - } else if (i == 3) { - bits = uint8_t(buf[0]) | (uint8_t(buf[1]) << 8) | (uint8_t(buf[2]) << 16); - } else { - mBits = kUnsupportedLanguage; - // We don't understand anything other than two-letter or three-letter - // language codes, so we skip parsing the rest of the string. - return; - } - size_t next; - for (i++; i < size; i = next + 1) { - for (next = i; next < size; next++) { - uint16_t c = buf[next]; - if (c == '-' || c == '_') break; - } - if (next - i == 4) { - if (buf[i] == 'H' && buf[i+1] == 'a' && buf[i+2] == 'n') { - if (buf[i+3] == 's') { - bits |= kHansFlag; - } else if (buf[i+3] == 't') { - bits |= kHantFlag; - } - } else if (buf[i] == 'Q' && buf[i+1] == 'a' && buf[i+2] == 'a'&& buf[i+3] == 'e') { - bits |= kEmojiFlag; - } - } - // TODO: this might be a good place to infer script from country (zh_TW -> Hant), - // but perhaps it's up to the client to do that, before passing a string. - } - mBits = bits; -} - -std::string FontLanguage::getString() const { - if (mBits == kUnsupportedLanguage) { - return "und"; - } - char buf[16]; - size_t i = 0; - if (mBits & kBaseLangMask) { - buf[i++] = mBits & 0xFFu; - buf[i++] = (mBits >> 8) & 0xFFu; - char third_letter = (mBits >> 16) & 0xFFu; - if (third_letter != 0) buf[i++] = third_letter; - } - if (mBits & kScriptMask) { - if (!i) { - // This should not happen, but as it apparently has, we fill the language code part - // with "und". - buf[i++] = 'u'; - buf[i++] = 'n'; - buf[i++] = 'd'; - } - buf[i++] = '-'; - if (mBits & kEmojiFlag) { - buf[i++] = 'Q'; - buf[i++] = 'a'; - buf[i++] = 'a'; - buf[i++] = 'e'; - } else { - buf[i++] = 'H'; - buf[i++] = 'a'; - buf[i++] = 'n'; - buf[i++] = (mBits & kHansFlag) ? 's' : 't'; - } - } - return std::string(buf, i); -} - -int FontLanguage::match(const FontLanguage other) const { - return *this == other; -} - -FontLanguages::FontLanguages(const char* buf, size_t size) { - std::unordered_set seen; - mLangs.clear(); - const char* bufEnd = buf + size; - const char* lastStart = buf; - bool isLastLang = false; - while (true) { - const char* commaLoc = static_cast( - memchr(lastStart, ',', bufEnd - lastStart)); - if (commaLoc == NULL) { - commaLoc = bufEnd; - isLastLang = true; - } - FontLanguage lang(lastStart, commaLoc - lastStart); - if (isLastLang && mLangs.size() == 0) { - // Make sure the list has at least one member - mLangs.push_back(lang); - return; - } - uint32_t bits = lang.bits(); - if (bits != FontLanguage::kUnsupportedLanguage && seen.count(bits) == 0) { - mLangs.push_back(lang); - if (isLastLang) return; - seen.insert(bits); - } - if (isLastLang) return; - lastStart = commaLoc + 1; - } -} - FontStyle::FontStyle(int variant, int weight, bool italic) : FontStyle(FontLanguageListCache::kEmptyListId, variant, weight, italic) { } @@ -177,6 +65,9 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { return (weight & kWeightMask) | (italic ? kItalicMask : 0) | (variant << kVariantShift); } +FontFamily::FontFamily(int variant) : FontFamily(FontLanguageListCache::kEmptyListId, variant) { +} + FontFamily::~FontFamily() { for (size_t i = 0; i < mFonts.size(); i++) { mFonts[i].typeface->UnrefLocked(); @@ -210,7 +101,8 @@ void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { addFontLocked(typeface, style); } -void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { typeface->RefLocked(); +void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { + typeface->RefLocked(); mFonts.push_back(Font(typeface, style)); mCoverageValid = false; } diff --git a/engine/src/flutter/libs/minikin/FontLanguage.cpp b/engine/src/flutter/libs/minikin/FontLanguage.cpp new file mode 100644 index 0000000000..3c12e06c6f --- /dev/null +++ b/engine/src/flutter/libs/minikin/FontLanguage.cpp @@ -0,0 +1,135 @@ +/* + * 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. + */ + +#define LOG_TAG "Minikin" + +#include "FontLanguage.h" + +#include +#include + +namespace android { + +#define SCRIPT_TAG(c1, c2, c3, c4) \ + ((uint32_t)(c1)) << 24 | ((uint32_t)(c2)) << 16 | ((uint32_t)(c3)) << 8 | ((uint32_t)(c4)) + +// Parse BCP 47 language identifier into internal structure +FontLanguage::FontLanguage(const char* buf, size_t length) : FontLanguage() { + size_t i; + for (i = 0; i < length; i++) { + char c = buf[i]; + if (c == '-' || c == '_') break; + } + if (i == 2 || i == 3) { // only accept two or three letter language code. + mLanguage = buf[0] | (buf[1] << 8) | ((i == 3) ? (buf[2] << 16) : 0); + } else { + // We don't understand anything other than two-letter or three-letter + // language codes, so we skip parsing the rest of the string. + mLanguage = 0ul; + return; + } + + size_t next; + for (i++; i < length; i = next + 1) { + for (next = i; next < length; next++) { + char c = buf[next]; + if (c == '-' || c == '_') break; + } + if (next - i == 4 && 'A' <= buf[i] && buf[i] <= 'Z') { + mScript = SCRIPT_TAG(buf[i], buf[i + 1], buf[i + 2], buf[i + 3]); + } + } + + mSubScriptBits = scriptToSubScriptBits(mScript); +} + +//static +uint8_t FontLanguage::scriptToSubScriptBits(uint32_t script) { + uint8_t subScriptBits = 0u; + switch (script) { + case SCRIPT_TAG('H', 'a', 'n', 'g'): + subScriptBits = kHangulFlag; + break; + case SCRIPT_TAG('H', 'a', 'n', 'i'): + subScriptBits = kHanFlag; + break; + case SCRIPT_TAG('H', 'a', 'n', 's'): + subScriptBits = kHanFlag | kSimplifiedChineseFlag; + break; + case SCRIPT_TAG('H', 'a', 'n', 't'): + subScriptBits = kHanFlag | kTraditionalChineseFlag; + break; + case SCRIPT_TAG('H', 'i', 'r', 'a'): + subScriptBits = kHiraganaFlag; + break; + case SCRIPT_TAG('H', 'r', 'k', 't'): + subScriptBits = kKatakanaFlag | kHiraganaFlag; + break; + case SCRIPT_TAG('J', 'p', 'a', 'n'): + subScriptBits = kHanFlag | kKatakanaFlag | kHiraganaFlag; + break; + case SCRIPT_TAG('K', 'a', 'n', 'a'): + subScriptBits = kKatakanaFlag; + break; + case SCRIPT_TAG('K', 'o', 'r', 'e'): + subScriptBits = kHanFlag | kHangulFlag; + break; + case SCRIPT_TAG('Q', 'a', 'a', 'e'): + subScriptBits = kEmojiFlag; + break; + } + return subScriptBits; +} + +std::string FontLanguage::getString() const { + if (mLanguage == 0ul) { + return "und"; + } + char buf[16]; + size_t i = 0; + buf[i++] = mLanguage & 0xFF ; + buf[i++] = (mLanguage >> 8) & 0xFF; + char third_letter = (mLanguage >> 16) & 0xFF; + if (third_letter != 0) buf[i++] = third_letter; + if (mScript != 0) { + buf[i++] = '-'; + buf[i++] = (mScript >> 24) & 0xFFu; + buf[i++] = (mScript >> 16) & 0xFFu; + buf[i++] = (mScript >> 8) & 0xFFu; + buf[i++] = mScript & 0xFFu; + } + return std::string(buf, i); +} + +bool FontLanguage::isEqualScript(const FontLanguage other) const { + return other.mScript == mScript; +} + +bool FontLanguage::supportsHbScript(hb_script_t script) const { + static_assert(SCRIPT_TAG('J', 'p', 'a', 'n') == HB_TAG('J', 'p', 'a', 'n'), + "The Minikin script and HarfBuzz hb_script_t have different encodings."); + if (script == mScript) return true; + uint8_t requestedBits = scriptToSubScriptBits(script); + return requestedBits != 0 && (mSubScriptBits & requestedBits) == requestedBits; +} + +int FontLanguage::match(const FontLanguage other) const { + // TODO: Use script for matching. + return *this == other; +} + +#undef SCRIPT_TAG +} // namespace android diff --git a/engine/src/flutter/libs/minikin/FontLanguage.h b/engine/src/flutter/libs/minikin/FontLanguage.h new file mode 100644 index 0000000000..abe7d13179 --- /dev/null +++ b/engine/src/flutter/libs/minikin/FontLanguage.h @@ -0,0 +1,89 @@ +/* + * 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. + */ + +#ifndef MINIKIN_FONT_LANGUAGE_H +#define MINIKIN_FONT_LANGUAGE_H + +#include +#include + +#include + +namespace android { + +// FontLanguage is a compact representation of a BCP 47 language tag. It +// does not capture all possible information, only what directly affects +// font rendering. +struct FontLanguage { +public: + // Default constructor creates the unsupported language. + FontLanguage() : mScript(0ul), mLanguage(0ul), mSubScriptBits(0ul) {} + + // Parse from string + FontLanguage(const char* buf, size_t length); + + bool operator==(const FontLanguage other) const { + return !isUnsupported() && isEqualScript(other) && isEqualLanguage(other); + } + + bool operator!=(const FontLanguage other) const { + return !(*this == other); + } + + bool isUnsupported() const { return mLanguage == 0ul; } + bool hasEmojiFlag() const { return mSubScriptBits & kEmojiFlag; } + + bool isEqualLanguage(const FontLanguage other) const { return mLanguage == other.mLanguage; } + bool isEqualScript(const FontLanguage other) const; + + // Returns true if this script supports the given script. For example, ja-Jpan supports Hira, + // ja-Hira doesn't support Jpan. + bool supportsHbScript(hb_script_t script) const; + + std::string getString() const; + + // 0 = no match, 1 = language matches + int match(const FontLanguage other) const; + + uint64_t getIdentifier() const { return (uint64_t)mScript << 32 | (uint64_t)mLanguage; } + +private: + // ISO 15924 compliant script code. The 4 chars script code are packed into a 32 bit integer. + uint32_t mScript; + + // ISO 639-1 or ISO 639-2 compliant language code. + // The two or three letter language code is packed into 32 bit integer. + // mLanguage = 0 means the FontLanguage is unsupported. + uint32_t mLanguage; + + // For faster comparing, use 7 bits for specific scripts. + static const uint8_t kEmojiFlag = 1u; + static const uint8_t kHanFlag = 1u << 1; + static const uint8_t kHangulFlag = 1u << 2; + static const uint8_t kHiraganaFlag = 1u << 3; + static const uint8_t kKatakanaFlag = 1u << 4; + static const uint8_t kSimplifiedChineseFlag = 1u << 5; + static const uint8_t kTraditionalChineseFlag = 1u << 6; + uint8_t mSubScriptBits; + + static uint8_t scriptToSubScriptBits(uint32_t script); +}; + +typedef std::vector FontLanguages; + +} // namespace android + +#endif // MINIKIN_FONT_LANGUAGE_H diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp index e1c2343dda..2d64998e7a 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp @@ -19,13 +19,92 @@ #include "FontLanguageListCache.h" #include +#include +#include #include "MinikinInternal.h" +#include "FontLanguage.h" namespace android { const uint32_t FontLanguageListCache::kEmptyListId; +// Returns the text length of output. +static size_t toLanguageTag(char* output, size_t outSize, const std::string& locale) { + output[0] = '\0'; + if (locale.empty()) { + return 0; + } + + size_t outLength = 0; + UErrorCode uErr = U_ZERO_ERROR; + outLength = uloc_canonicalize(locale.c_str(), output, outSize, &uErr); + if (U_FAILURE(uErr)) { + // unable to build a proper language identifier + ALOGD("uloc_canonicalize(\"%s\") failed: %s", locale.c_str(), u_errorName(uErr)); + output[0] = '\0'; + return 0; + } + + // Preserve "und" and "und-****" since uloc_addLikelySubtags changes "und" to "en-Latn-US". + if (strncmp(output, "und", 3) == 0 && + (outLength == 3 || (outLength == 8 && output[3] == '_'))) { + return outLength; + } + + char likelyChars[ULOC_FULLNAME_CAPACITY]; + uErr = U_ZERO_ERROR; + uloc_addLikelySubtags(output, likelyChars, ULOC_FULLNAME_CAPACITY, &uErr); + if (U_FAILURE(uErr)) { + // unable to build a proper language identifier + ALOGD("uloc_addLikelySubtags(\"%s\") failed: %s", output, u_errorName(uErr)); + output[0] = '\0'; + return 0; + } + + uErr = U_ZERO_ERROR; + outLength = uloc_toLanguageTag(likelyChars, output, outSize, FALSE, &uErr); + if (U_FAILURE(uErr)) { + // unable to build a proper language identifier + ALOGD("uloc_toLanguageTag(\"%s\") failed: %s", likelyChars, u_errorName(uErr)); + output[0] = '\0'; + return 0; + } +#ifdef VERBOSE_DEBUG + ALOGD("ICU normalized '%s' to '%s'", locale.c_str(), output); +#endif + return outLength; +} + +static FontLanguages constructFontLanguages(const std::string& input) { + FontLanguages result; + size_t currentIdx = 0; + size_t commaLoc = 0; + char langTag[ULOC_FULLNAME_CAPACITY]; + std::unordered_set seen; + std::string locale(input.size(), 0); + + while ((commaLoc = input.find_first_of(',', currentIdx)) != std::string::npos) { + locale.assign(input, currentIdx, commaLoc - currentIdx); + currentIdx = commaLoc + 1; + size_t length = toLanguageTag(langTag, ULOC_FULLNAME_CAPACITY, locale); + FontLanguage lang(langTag, length); + uint64_t identifier = lang.getIdentifier(); + if (!lang.isUnsupported() && seen.count(identifier) == 0) { + result.push_back(lang); + seen.insert(identifier); + } + } + locale.assign(input, currentIdx, input.size() - currentIdx); + size_t length = toLanguageTag(langTag, ULOC_FULLNAME_CAPACITY, locale); + FontLanguage lang(langTag, length); + uint64_t identifier = lang.getIdentifier(); + if (!lang.isUnsupported() && seen.count(identifier) == 0) { + result.push_back(lang); + } + return result; +} + // static uint32_t FontLanguageListCache::getId(const std::string& languages) { FontLanguageListCache* inst = FontLanguageListCache::getInstance(); @@ -37,7 +116,11 @@ uint32_t FontLanguageListCache::getId(const std::string& languages) { // Given language list is not in cache. Insert it and return newly assigned ID. const uint32_t nextId = inst->mLanguageLists.size(); - inst->mLanguageLists.push_back(FontLanguages(languages.c_str(), languages.size())); + FontLanguages fontLanguages = constructFontLanguages(languages); + if (fontLanguages.empty()) { + return kEmptyListId; + } + inst->mLanguageLists.push_back(fontLanguages); inst->mLanguageListLookupTable.insert(std::make_pair(languages, nextId)); return nextId; } @@ -56,8 +139,9 @@ FontLanguageListCache* FontLanguageListCache::getInstance() { if (instance == nullptr) { instance = new FontLanguageListCache(); - // Insert an empty language list for mapping empty language list to kEmptyListId. - instance->mLanguageLists.push_back(FontLanguages()); + // Insert an empty language list for mapping default language list to kEmptyListId. + // The default language list has only one FontLanguage and it is the unsupported language. + instance->mLanguageLists.push_back(FontLanguages({FontLanguage()})); instance->mLanguageListLookupTable.insert(std::make_pair("", kEmptyListId)); } return instance; diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.h b/engine/src/flutter/libs/minikin/FontLanguageListCache.h index 7d627b562e..c961882f0a 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.h +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.h @@ -20,6 +20,7 @@ #include #include +#include "FontLanguage.h" namespace android { diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index af5e6fe75a..2e206a20fc 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -34,6 +34,7 @@ #include #include +#include "FontLanguage.h" #include "FontLanguageListCache.h" #include "LayoutUtils.h" #include "HbFaceCache.h" @@ -746,9 +747,15 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t const FontLanguages& langList = FontLanguageListCache::getById(ctx->style.getLanguageListId()); if (langList.size() != 0) { - // TODO: use all languages in langList. - string lang = langList[0].getString(); - hb_buffer_set_language(buffer, hb_language_from_string(lang.c_str(), -1)); + const FontLanguage* hbLanguage = &langList[0]; + for (size_t i = 0; i < langList.size(); ++i) { + if (langList[i].supportsHbScript(script)) { + hbLanguage = &langList[i]; + break; + } + } + hb_buffer_set_language(buffer, + hb_language_from_string(hbLanguage->getString().c_str(), -1)); } hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); if (ctx->paint.hyphenEdit.hasHyphen() && srunend > srunstart) { diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 85d76afccb..cf9b704efa 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -16,7 +16,9 @@ #include +#include "FontLanguage.h" #include "FontTestUtils.h" +#include "ICUTestBase.h" #include "MinikinFontForTest.h" #include "UnicodeUtils.h" @@ -42,6 +44,8 @@ const char kColorEmojiFont[] = kTestFontDir "ColorEmojiFont.ttf"; const char kTextEmojiFont[] = kTestFontDir "TextEmojiFont.ttf"; const char kMixedEmojiFont[] = kTestFontDir "ColorTextMixedEmojiFont.ttf"; +typedef ICUTestBase FontCollectionItemizeTest; + // Utility function for calling itemize function. void itemize(FontCollection* collection, const char* str, FontStyle style, std::vector* result) { @@ -60,7 +64,7 @@ const std::string& getFontPath(const FontCollection::Run& run) { return ((MinikinFontForTest*)run.fakedFont.font)->fontPath(); } -TEST(FontCollectionItemizeTest, itemize_latin) { +TEST_F(FontCollectionItemizeTest, itemize_latin) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -130,7 +134,7 @@ TEST(FontCollectionItemizeTest, itemize_latin) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); } -TEST(FontCollectionItemizeTest, itemize_emoji) { +TEST_F(FontCollectionItemizeTest, itemize_emoji) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -191,7 +195,7 @@ TEST(FontCollectionItemizeTest, itemize_emoji) { EXPECT_FALSE(runs[1].fakedFont.fakery.isFakeItalic()); } -TEST(FontCollectionItemizeTest, itemize_non_latin) { +TEST_F(FontCollectionItemizeTest, itemize_non_latin) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -280,7 +284,7 @@ TEST(FontCollectionItemizeTest, itemize_non_latin) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); } -TEST(FontCollectionItemizeTest, itemize_mixed) { +TEST_F(FontCollectionItemizeTest, itemize_mixed) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -319,7 +323,7 @@ TEST(FontCollectionItemizeTest, itemize_mixed) { EXPECT_FALSE(runs[4].fakedFont.fakery.isFakeItalic()); } -TEST(FontCollectionItemizeTest, itemize_variationSelector) { +TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -458,7 +462,7 @@ TEST(FontCollectionItemizeTest, itemize_variationSelector) { EXPECT_EQ(kLatinFont, getFontPath(runs[0])); } -TEST(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { +TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -583,7 +587,7 @@ TEST(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontPath(runs[0])); } -TEST(FontCollectionItemizeTest, itemize_no_crash) { +TEST_F(FontCollectionItemizeTest, itemize_no_crash) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -607,7 +611,7 @@ TEST(FontCollectionItemizeTest, itemize_no_crash) { itemize(collection.get(), "U+FE00 U+302D U+E0100", FontStyle(), &runs); } -TEST(FontCollectionItemizeTest, itemize_fakery) { +TEST_F(FontCollectionItemizeTest, itemize_fakery) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -647,18 +651,18 @@ TEST(FontCollectionItemizeTest, itemize_fakery) { EXPECT_TRUE(runs[0].fakedFont.fakery.isFakeItalic()); } -TEST(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { +TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { // kVSTestFont supports U+717D U+FE02 but doesn't support U+717D. // kVSTestFont should be selected for U+717D U+FE02 even if it does not support the base code // point. const std::string kVSTestFont = kTestFontDir "VarioationSelectorTest-Regular.ttf"; std::vector families; - FontFamily* family1 = new FontFamily(FontLanguage(), android::VARIANT_DEFAULT); + FontFamily* family1 = new FontFamily(android::VARIANT_DEFAULT); family1->addFont(new MinikinFontForTest(kLatinFont)); families.push_back(family1); - FontFamily* family2 = new FontFamily(FontLanguage(), android::VARIANT_DEFAULT); + FontFamily* family2 = new FontFamily(android::VARIANT_DEFAULT); family2->addFont(new MinikinFontForTest(kVSTestFont)); families.push_back(family2); @@ -676,7 +680,7 @@ TEST(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { family2->Unref(); } -TEST(FontCollectionItemizeTest, itemize_emojiSelection) { +TEST_F(FontCollectionItemizeTest, itemize_emojiSelection) { std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); std::vector runs; @@ -748,7 +752,7 @@ TEST(FontCollectionItemizeTest, itemize_emojiSelection) { EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); } -TEST(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { +TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); std::vector runs; @@ -830,7 +834,7 @@ TEST(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { EXPECT_EQ(kMixedEmojiFont, getFontPath(runs[0])); } -TEST(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { +TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); std::vector runs; diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index fc44e6c636..ac7616fada 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -17,74 +17,261 @@ #include #include + +#include + #include "FontLanguageListCache.h" +#include "ICUTestBase.h" #include "MinikinFontForTest.h" #include "MinikinInternal.h" namespace android { -TEST(FontLanguagesTest, basicTests) { +typedef ICUTestBase FontLanguagesTest; +typedef ICUTestBase FontLanguageTest; + +static FontLanguages createFontLanguages(const std::string& input) { + uint32_t langId = FontLanguageListCache::getId(input); + return FontLanguageListCache::getById(langId); +} + +static FontLanguage createFontLanguage(const std::string& input) { + uint32_t langId = FontLanguageListCache::getId(input); + return FontLanguageListCache::getById(langId)[0]; +} + +TEST_F(FontLanguageTest, basicTests) { + FontLanguage defaultLang; + FontLanguage emptyLang("", 0); + FontLanguage english = createFontLanguage("en"); + FontLanguage french = createFontLanguage("fr"); + FontLanguage und = createFontLanguage("und"); + FontLanguage undQaae = createFontLanguage("und-Qaae"); + + EXPECT_EQ(english, english); + EXPECT_EQ(french, french); + + EXPECT_TRUE(defaultLang != defaultLang); + EXPECT_TRUE(emptyLang != emptyLang); + EXPECT_TRUE(defaultLang != emptyLang); + EXPECT_TRUE(defaultLang != und); + EXPECT_TRUE(emptyLang != und); + EXPECT_TRUE(english != defaultLang); + EXPECT_TRUE(english != emptyLang); + EXPECT_TRUE(english != french); + EXPECT_TRUE(english != undQaae); + EXPECT_TRUE(und != undQaae); + EXPECT_TRUE(english != und); + + EXPECT_TRUE(defaultLang.isUnsupported()); + EXPECT_TRUE(emptyLang.isUnsupported()); + + EXPECT_FALSE(english.isUnsupported()); + EXPECT_FALSE(french.isUnsupported()); + EXPECT_FALSE(und.isUnsupported()); + EXPECT_FALSE(undQaae.isUnsupported()); +} + +TEST_F(FontLanguageTest, getStringTest) { + EXPECT_EQ("en-Latn", createFontLanguage("en").getString()); + EXPECT_EQ("en-Latn", createFontLanguage("en-Latn").getString()); + + // Capitalized language code or lowercased script should be normalized. + EXPECT_EQ("en-Latn", createFontLanguage("EN-LATN").getString()); + EXPECT_EQ("en-Latn", createFontLanguage("EN-latn").getString()); + EXPECT_EQ("en-Latn", createFontLanguage("en-latn").getString()); + + // Invalid script should be kept. + EXPECT_EQ("en-Xyzt", createFontLanguage("en-xyzt").getString()); + + EXPECT_EQ("en-Latn", createFontLanguage("en-Latn-US").getString()); + EXPECT_EQ("ja-Jpan", createFontLanguage("ja").getString()); + EXPECT_EQ("und", createFontLanguage("und").getString()); + EXPECT_EQ("und", createFontLanguage("UND").getString()); + EXPECT_EQ("und", createFontLanguage("Und").getString()); + EXPECT_EQ("und-Qaae", createFontLanguage("und-Qaae").getString()); + EXPECT_EQ("und-Qaae", createFontLanguage("Und-QAAE").getString()); + EXPECT_EQ("und-Qaae", createFontLanguage("Und-qaae").getString()); + + EXPECT_EQ("de-Latn", createFontLanguage("de-1901").getString()); + + // This is not a necessary desired behavior, just known behavior. + EXPECT_EQ("en-Latn", createFontLanguage("und-Abcdefgh").getString()); +} + +TEST_F(FontLanguageTest, ScriptEqualTest) { + EXPECT_TRUE(createFontLanguage("en").isEqualScript(createFontLanguage("en"))); + EXPECT_TRUE(createFontLanguage("en-Latn").isEqualScript(createFontLanguage("en"))); + EXPECT_TRUE(createFontLanguage("jp-Latn").isEqualScript(createFontLanguage("en-Latn"))); + EXPECT_TRUE(createFontLanguage("en-Jpan").isEqualScript(createFontLanguage("en-Jpan"))); + + EXPECT_FALSE(createFontLanguage("en-Jpan").isEqualScript(createFontLanguage("en-Hira"))); + EXPECT_FALSE(createFontLanguage("en-Jpan").isEqualScript(createFontLanguage("en-Hani"))); +} + +TEST_F(FontLanguageTest, ScriptMatchTest) { + const bool SUPPORTED = true; + const bool NOT_SUPPORTED = false; + + struct TestCase { + const std::string baseScript; + const std::string requestedScript; + bool isSupported; + } testCases[] = { + // Same scripts + { "en-Latn", "Latn", SUPPORTED }, + { "ja-Jpan", "Jpan", SUPPORTED }, + { "ja-Hira", "Hira", SUPPORTED }, + { "ja-Kana", "Kana", SUPPORTED }, + { "ja-Hrkt", "Hrkt", SUPPORTED }, + { "zh-Hans", "Hans", SUPPORTED }, + { "zh-Hant", "Hant", SUPPORTED }, + { "zh-Hani", "Hani", SUPPORTED }, + { "ko-Kore", "Kore", SUPPORTED }, + { "ko-Hang", "Hang", SUPPORTED }, + + // Japanese supports Hiragana, Katakanara, etc. + { "ja-Jpan", "Hira", SUPPORTED }, + { "ja-Jpan", "Kana", SUPPORTED }, + { "ja-Jpan", "Hrkt", SUPPORTED }, + { "ja-Hrkt", "Hira", SUPPORTED }, + { "ja-Hrkt", "Kana", SUPPORTED }, + + // Chinese supports Han. + { "zh-Hans", "Hani", SUPPORTED }, + { "zh-Hant", "Hani", SUPPORTED }, + + // Korean supports Hangul. + { "ko-Kore", "Hang", SUPPORTED }, + + // Different scripts + { "ja-Jpan", "Latn", NOT_SUPPORTED }, + { "en-Latn", "Jpan", NOT_SUPPORTED }, + { "ja-Jpan", "Hant", NOT_SUPPORTED }, + { "zh-Hant", "Jpan", NOT_SUPPORTED }, + { "ja-Jpan", "Hans", NOT_SUPPORTED }, + { "zh-Hans", "Jpan", NOT_SUPPORTED }, + { "ja-Jpan", "Kore", NOT_SUPPORTED }, + { "ko-Kore", "Jpan", NOT_SUPPORTED }, + { "zh-Hans", "Hant", NOT_SUPPORTED }, + { "zh-Hant", "Hans", NOT_SUPPORTED }, + { "zh-Hans", "Kore", NOT_SUPPORTED }, + { "ko-Kore", "Hans", NOT_SUPPORTED }, + { "zh-Hant", "Kore", NOT_SUPPORTED }, + { "ko-Kore", "Hant", NOT_SUPPORTED }, + + // Hiragana doesn't support Japanese, etc. + { "ja-Hira", "Jpan", NOT_SUPPORTED }, + { "ja-Kana", "Jpan", NOT_SUPPORTED }, + { "ja-Hrkt", "Jpan", NOT_SUPPORTED }, + { "ja-Hani", "Jpan", NOT_SUPPORTED }, + { "ja-Hira", "Hrkt", NOT_SUPPORTED }, + { "ja-Kana", "Hrkt", NOT_SUPPORTED }, + { "ja-Hani", "Hrkt", NOT_SUPPORTED }, + { "ja-Hani", "Hira", NOT_SUPPORTED }, + { "ja-Hani", "Kana", NOT_SUPPORTED }, + + // Kanji doesn't support Chinese, etc. + { "zh-Hani", "Hant", NOT_SUPPORTED }, + { "zh-Hani", "Hans", NOT_SUPPORTED }, + + // Hangul doesn't support Korean, etc. + { "ko-Hang", "Kore", NOT_SUPPORTED }, + { "ko-Hani", "Kore", NOT_SUPPORTED }, + { "ko-Hani", "Hang", NOT_SUPPORTED }, + { "ko-Hang", "Hani", NOT_SUPPORTED }, + }; + + for (auto testCase : testCases) { + hb_script_t script = hb_script_from_iso15924_tag( + HB_TAG(testCase.requestedScript[0], testCase.requestedScript[1], + testCase.requestedScript[2], testCase.requestedScript[3])); + if (testCase.isSupported) { + EXPECT_TRUE( + createFontLanguage(testCase.baseScript).supportsHbScript(script)) + << testCase.baseScript << " should support " << testCase.requestedScript; + } else { + EXPECT_FALSE( + createFontLanguage(testCase.baseScript).supportsHbScript(script)) + << testCase.baseScript << " shouldn't support " << testCase.requestedScript; + } + } +} + +TEST_F(FontLanguagesTest, basicTests) { FontLanguages emptyLangs; EXPECT_EQ(0u, emptyLangs.size()); - FontLanguage english("en", 2); - FontLanguages singletonLangs("en", 2); + FontLanguage english = createFontLanguage("en"); + FontLanguages singletonLangs = createFontLanguages("en"); EXPECT_EQ(1u, singletonLangs.size()); EXPECT_EQ(english, singletonLangs[0]); - FontLanguage french("fr", 2); - FontLanguages twoLangs("en,fr", 5); + FontLanguage french = createFontLanguage("fr"); + FontLanguages twoLangs = createFontLanguages("en,fr"); EXPECT_EQ(2u, twoLangs.size()); EXPECT_EQ(english, twoLangs[0]); EXPECT_EQ(french, twoLangs[1]); } -TEST(FontLanguagesTest, unsupportedLanguageTests) { - FontLanguage unsupportedLang("x-example", 9); +TEST_F(FontLanguagesTest, unsupportedLanguageTests) { + FontLanguage unsupportedLang = createFontLanguage("abcd"); ASSERT_TRUE(unsupportedLang.isUnsupported()); - FontLanguages oneUnsupported("x-example", 9); + FontLanguages oneUnsupported = createFontLanguages("abcd-example"); EXPECT_EQ(1u, oneUnsupported.size()); EXPECT_TRUE(oneUnsupported[0].isUnsupported()); - FontLanguages twoUnsupporteds("x-example,x-example", 19); + FontLanguages twoUnsupporteds = createFontLanguages("abcd-example,abcd-example"); EXPECT_EQ(1u, twoUnsupporteds.size()); EXPECT_TRUE(twoUnsupporteds[0].isUnsupported()); - FontLanguage english("en", 2); - FontLanguages firstUnsupported("x-example,en", 12); + FontLanguage english = createFontLanguage("en"); + FontLanguages firstUnsupported = createFontLanguages("abcd-example,en"); EXPECT_EQ(1u, firstUnsupported.size()); EXPECT_EQ(english, firstUnsupported[0]); - FontLanguages lastUnsupported("en,x-example", 12); + FontLanguages lastUnsupported = createFontLanguages("en,abcd-example"); EXPECT_EQ(1u, lastUnsupported.size()); EXPECT_EQ(english, lastUnsupported[0]); } -TEST(FontLanguagesTest, repeatedLanguageTests) { - FontLanguage english("en", 2); - FontLanguage englishInLatn("en-Latn", 2); +TEST_F(FontLanguagesTest, repeatedLanguageTests) { + FontLanguage english = createFontLanguage("en"); + FontLanguage french = createFontLanguage("fr"); + FontLanguage englishInLatn = createFontLanguage("en-Latn"); ASSERT_TRUE(english == englishInLatn); - FontLanguages langs("en,en-Latn", 10); + FontLanguages langs = createFontLanguages("en,en-Latn"); EXPECT_EQ(1u, langs.size()); EXPECT_EQ(english, langs[0]); + + // Country codes are ignored. + FontLanguages fr = createFontLanguages("fr,fr-CA,fr-FR"); + EXPECT_EQ(1u, fr.size()); + EXPECT_EQ(french, fr[0]); + + // The order should be kept. + langs = createFontLanguages("en,fr,en-Latn"); + EXPECT_EQ(2u, langs.size()); + EXPECT_EQ(english, langs[0]); + EXPECT_EQ(french, langs[1]); } -TEST(FontLanguagesTest, undEmojiTests) { - FontLanguage emoji("und-Qaae", 8); +TEST_F(FontLanguagesTest, undEmojiTests) { + FontLanguage emoji = createFontLanguage("und-Qaae"); EXPECT_TRUE(emoji.hasEmojiFlag()); - FontLanguage und("und", 3); + FontLanguage und = createFontLanguage("und"); EXPECT_FALSE(und.hasEmojiFlag()); EXPECT_FALSE(emoji == und); - FontLanguage undExample("und-example", 10); + FontLanguage undExample = createFontLanguage("und-example"); EXPECT_FALSE(undExample.hasEmojiFlag()); EXPECT_FALSE(emoji == undExample); } -TEST(FontLanguagesTest, registerLanguageListTest) { +TEST_F(FontLanguagesTest, registerLanguageListTest) { EXPECT_EQ(0UL, FontStyle::registerLanguageList("")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en")); EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); @@ -122,9 +309,10 @@ TEST(FontLanguagesTest, registerLanguageListTest) { // U+717D U+E0103 (VS20) const char kVsTestFont[] = kTestFontDir "VarioationSelectorTest-Regular.ttf"; -class FontFamilyTest : public testing::Test { +class FontFamilyTest : public ICUTestBase { public: virtual void SetUp() override { + ICUTestBase::SetUp(); if (access(kVsTestFont, R_OK) != 0) { FAIL() << "Unable to read " << kVsTestFont << ". " << "Please prepare the test data directory. " diff --git a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp index 29757fedce..f83988c1f5 100644 --- a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp +++ b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp @@ -17,11 +17,15 @@ #include #include + #include "FontLanguageListCache.h" +#include "ICUTestBase.h" namespace android { -TEST(FontLanguageListCacheTest, getId) { +typedef ICUTestBase FontLanguageListCacheTest; + +TEST_F(FontLanguageListCacheTest, getId) { EXPECT_EQ(0UL, FontLanguageListCache::getId("")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en")); EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); @@ -42,11 +46,15 @@ TEST(FontLanguageListCacheTest, getId) { FontLanguageListCache::getId("en,zh-Hant")); } -TEST(FontLanguageListCacheTest, getById) { - FontLanguage english("en", 2); - FontLanguage japanese("jp", 2); +TEST_F(FontLanguageListCacheTest, getById) { + uint32_t enLangId = FontLanguageListCache::getId("en"); + uint32_t jpLangId = FontLanguageListCache::getId("jp"); + FontLanguage english = FontLanguageListCache::getById(enLangId)[0]; + FontLanguage japanese = FontLanguageListCache::getById(jpLangId)[0]; - EXPECT_EQ(0UL, FontLanguageListCache::getById(0).size()); + FontLanguages defLangs = FontLanguageListCache::getById(0); + EXPECT_EQ(1UL, defLangs.size()); + EXPECT_TRUE(defLangs[0].isUnsupported()); FontLanguages langs = FontLanguageListCache::getById(FontLanguageListCache::getId("en")); ASSERT_EQ(1UL, langs.size()); diff --git a/engine/src/flutter/tests/FontTestUtils.cpp b/engine/src/flutter/tests/FontTestUtils.cpp index 8e1d184adc..98dab5121b 100644 --- a/engine/src/flutter/tests/FontTestUtils.cpp +++ b/engine/src/flutter/tests/FontTestUtils.cpp @@ -20,6 +20,8 @@ #include #include + +#include "FontLanguage.h" #include "MinikinFontForTest.h" std::unique_ptr getFontCollection( @@ -44,9 +46,10 @@ std::unique_ptr getFontCollection( } xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); + uint32_t langId = android::FontStyle::registerLanguageList( + std::string((const char*)lang, xmlStrlen(lang))); - android::FontFamily* family = new android::FontFamily( - android::FontLanguage((const char*)lang, xmlStrlen(lang)), variant); + android::FontFamily* family = new android::FontFamily(langId, variant); for (xmlNode* fontNode = familyNode->children; fontNode; fontNode = fontNode->next) { if (xmlStrcmp(fontNode->name, (const xmlChar*)"font") != 0) { diff --git a/engine/src/flutter/tests/ICUTestBase.h b/engine/src/flutter/tests/ICUTestBase.h new file mode 100644 index 0000000000..3bcfaf3694 --- /dev/null +++ b/engine/src/flutter/tests/ICUTestBase.h @@ -0,0 +1,52 @@ +/* + * 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. + */ + +#ifndef MINIKIN_TEST_ICU_TEST_BASE_H +#define MINIKIN_TEST_ICU_TEST_BASE_H + +#include +#include +#include + +// low level file access for mapping ICU data +#include +#include +#include + +class ICUTestBase : public testing::Test { +protected: + virtual void SetUp() override { + const char* fn = "/system/usr/icu/" U_ICUDATA_NAME ".dat"; + int fd = open(fn, O_RDONLY); + ASSERT_NE(-1, fd); + struct stat sb; + ASSERT_EQ(0, fstat(fd, &sb)); + void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd, 0); + + UErrorCode errorCode = U_ZERO_ERROR; + udata_setCommonData(data, &errorCode); + ASSERT_TRUE(U_SUCCESS(errorCode)); + u_init(&errorCode); + ASSERT_TRUE(U_SUCCESS(errorCode)); + } + + virtual void TearDown() override { + u_cleanup(); + } +}; + + +#endif // MINIKIN_TEST_ICU_TEST_BASE_H From 40c8b088bdcb459b6eae9359aeca10b30e9bec58 Mon Sep 17 00:00:00 2001 From: Bart Sears Date: Tue, 22 Dec 2015 09:06:03 +0000 Subject: [PATCH 134/364] Revert "Save all kind of script tags into FontLanguage." This reverts commit bb5c10092c3ec3246a9f4c52cd6b620e86fa5bd8. Change-Id: I761e0e41906742fbe3d3ac34170af3101e18042a --- .../src/flutter/include/minikin/FontFamily.h | 64 ++++- engine/src/flutter/libs/minikin/Android.mk | 1 - .../flutter/libs/minikin/FontCollection.cpp | 10 +- .../src/flutter/libs/minikin/FontFamily.cpp | 120 ++++++++- .../src/flutter/libs/minikin/FontLanguage.cpp | 135 ---------- .../src/flutter/libs/minikin/FontLanguage.h | 89 ------- .../libs/minikin/FontLanguageListCache.cpp | 90 +------ .../libs/minikin/FontLanguageListCache.h | 1 - engine/src/flutter/libs/minikin/Layout.cpp | 13 +- .../tests/FontCollectionItemizeTest.cpp | 32 ++- engine/src/flutter/tests/FontFamilyTest.cpp | 232 ++---------------- .../tests/FontLanguageListCacheTest.cpp | 18 +- engine/src/flutter/tests/FontTestUtils.cpp | 7 +- engine/src/flutter/tests/ICUTestBase.h | 52 ---- 14 files changed, 225 insertions(+), 639 deletions(-) delete mode 100644 engine/src/flutter/libs/minikin/FontLanguage.cpp delete mode 100644 engine/src/flutter/libs/minikin/FontLanguage.h delete mode 100644 engine/src/flutter/tests/ICUTestBase.h diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index aa2e0ac2e4..00130e6f5d 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -30,6 +30,62 @@ namespace android { class MinikinFont; +// FontLanguage is a compact representation of a bcp-47 language tag. It +// does not capture all possible information, only what directly affects +// font rendering. +class FontLanguage { + friend class FontStyle; + friend class FontLanguages; +public: + FontLanguage() : mBits(0) { } + + // Parse from string + FontLanguage(const char* buf, size_t size); + + bool operator==(const FontLanguage other) const { + return mBits != kUnsupportedLanguage && mBits == other.mBits; + } + operator bool() const { return mBits != 0; } + + bool isUnsupported() const { return mBits == kUnsupportedLanguage; } + bool hasEmojiFlag() const { return isUnsupported() ? false : (mBits & kEmojiFlag); } + + std::string getString() const; + + // 0 = no match, 1 = language matches + int match(const FontLanguage other) const; + +private: + explicit FontLanguage(uint32_t bits) : mBits(bits) { } + + uint32_t bits() const { return mBits; } + + static const uint32_t kUnsupportedLanguage = 0xFFFFFFFFu; + static const uint32_t kBaseLangMask = 0xFFFFFFu; + static const uint32_t kHansFlag = 1u << 24; + static const uint32_t kHantFlag = 1u << 25; + static const uint32_t kEmojiFlag = 1u << 26; + static const uint32_t kScriptMask = kHansFlag | kHantFlag | kEmojiFlag; + uint32_t mBits; +}; + +// A list of zero or more instances of FontLanguage, in the order of +// preference. Used for further resolution of rendering results. +class FontLanguages { +public: + FontLanguages() { mLangs.clear(); } + + // Parse from string, which is a comma-separated list of languages + FontLanguages(const char* buf, size_t size); + + const FontLanguage& operator[](size_t index) const { return mLangs.at(index); } + + size_t size() const { return mLangs.size(); } + +private: + std::vector mLangs; +}; + // FontStyle represents all style information needed to select an actual font // from a collection. The implementation is packed into two 32-bit words // so it can be efficiently copied, embedded in other objects, etc. @@ -102,9 +158,7 @@ class FontFamily : public MinikinRefCounted { public: FontFamily() : mHbFont(nullptr) { } - FontFamily(int variant); - - FontFamily(uint32_t langId, int variant) : mLangId(langId), mVariant(variant), mHbFont(nullptr) { + FontFamily(FontLanguage lang, int variant) : mLang(lang), mVariant(variant), mHbFont(nullptr) { } ~FontFamily(); @@ -115,7 +169,7 @@ public: void addFont(MinikinFont* typeface, FontStyle style); FakedFont getClosestMatch(FontStyle style) const; - uint32_t langId() const { return mLangId; } + FontLanguage lang() const { return mLang; } int variant() const { return mVariant; } // API's for enumerating the fonts in a family. These don't guarantee any particular order @@ -146,7 +200,7 @@ private: MinikinFont* typeface; FontStyle style; }; - uint32_t mLangId; + FontLanguage mLang; int mVariant; std::vector mFonts; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 42fdca3919..4c945a60c9 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -21,7 +21,6 @@ minikin_src_files := \ CmapCoverage.cpp \ FontCollection.cpp \ FontFamily.cpp \ - FontLanguage.cpp \ FontLanguageListCache.cpp \ GraphemeBreak.cpp \ HbFaceCache.cpp \ diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 62c70310c0..bba2ef9535 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -22,7 +22,6 @@ #include "unicode/unistr.h" #include "unicode/unorm2.h" -#include "FontLanguage.h" #include "FontLanguageListCache.h" #include "MinikinInternal.h" #include @@ -151,17 +150,14 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, // always use it. return family; } - - // TODO use all language in the list. - FontLanguage fontLang = FontLanguageListCache::getById(family->langId())[0]; - int score = lang.match(fontLang) * 2; + int score = lang.match(family->lang()) * 2; if (family->variant() == 0 || family->variant() == variant) { score++; } if (hasVSGlyph) { score += 8; - } else if (((vs == 0xFE0F) && fontLang.hasEmojiFlag()) || - ((vs == 0xFE0E) && !fontLang.hasEmojiFlag())) { + } else if (((vs == 0xFE0F) && family->lang().hasEmojiFlag()) || + ((vs == 0xFE0E) && !family->lang().hasEmojiFlag())) { score += 4; } if (score > bestScore) { diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 1405789028..7639831240 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -16,6 +16,8 @@ #define LOG_TAG "Minikin" +#include + #include #include #include @@ -26,7 +28,6 @@ #include -#include "FontLanguage.h" #include "FontLanguageListCache.h" #include "HbFaceCache.h" #include "MinikinInternal.h" @@ -40,6 +41,117 @@ using std::vector; namespace android { +// Parse bcp-47 language identifier into internal structure +FontLanguage::FontLanguage(const char* buf, size_t size) { + uint32_t bits = 0; + size_t i; + for (i = 0; i < size; i++) { + uint16_t c = buf[i]; + if (c == '-' || c == '_') break; + } + if (i == 2) { + bits = uint8_t(buf[0]) | (uint8_t(buf[1]) << 8); + } else if (i == 3) { + bits = uint8_t(buf[0]) | (uint8_t(buf[1]) << 8) | (uint8_t(buf[2]) << 16); + } else { + mBits = kUnsupportedLanguage; + // We don't understand anything other than two-letter or three-letter + // language codes, so we skip parsing the rest of the string. + return; + } + size_t next; + for (i++; i < size; i = next + 1) { + for (next = i; next < size; next++) { + uint16_t c = buf[next]; + if (c == '-' || c == '_') break; + } + if (next - i == 4) { + if (buf[i] == 'H' && buf[i+1] == 'a' && buf[i+2] == 'n') { + if (buf[i+3] == 's') { + bits |= kHansFlag; + } else if (buf[i+3] == 't') { + bits |= kHantFlag; + } + } else if (buf[i] == 'Q' && buf[i+1] == 'a' && buf[i+2] == 'a'&& buf[i+3] == 'e') { + bits |= kEmojiFlag; + } + } + // TODO: this might be a good place to infer script from country (zh_TW -> Hant), + // but perhaps it's up to the client to do that, before passing a string. + } + mBits = bits; +} + +std::string FontLanguage::getString() const { + if (mBits == kUnsupportedLanguage) { + return "und"; + } + char buf[16]; + size_t i = 0; + if (mBits & kBaseLangMask) { + buf[i++] = mBits & 0xFFu; + buf[i++] = (mBits >> 8) & 0xFFu; + char third_letter = (mBits >> 16) & 0xFFu; + if (third_letter != 0) buf[i++] = third_letter; + } + if (mBits & kScriptMask) { + if (!i) { + // This should not happen, but as it apparently has, we fill the language code part + // with "und". + buf[i++] = 'u'; + buf[i++] = 'n'; + buf[i++] = 'd'; + } + buf[i++] = '-'; + if (mBits & kEmojiFlag) { + buf[i++] = 'Q'; + buf[i++] = 'a'; + buf[i++] = 'a'; + buf[i++] = 'e'; + } else { + buf[i++] = 'H'; + buf[i++] = 'a'; + buf[i++] = 'n'; + buf[i++] = (mBits & kHansFlag) ? 's' : 't'; + } + } + return std::string(buf, i); +} + +int FontLanguage::match(const FontLanguage other) const { + return *this == other; +} + +FontLanguages::FontLanguages(const char* buf, size_t size) { + std::unordered_set seen; + mLangs.clear(); + const char* bufEnd = buf + size; + const char* lastStart = buf; + bool isLastLang = false; + while (true) { + const char* commaLoc = static_cast( + memchr(lastStart, ',', bufEnd - lastStart)); + if (commaLoc == NULL) { + commaLoc = bufEnd; + isLastLang = true; + } + FontLanguage lang(lastStart, commaLoc - lastStart); + if (isLastLang && mLangs.size() == 0) { + // Make sure the list has at least one member + mLangs.push_back(lang); + return; + } + uint32_t bits = lang.bits(); + if (bits != FontLanguage::kUnsupportedLanguage && seen.count(bits) == 0) { + mLangs.push_back(lang); + if (isLastLang) return; + seen.insert(bits); + } + if (isLastLang) return; + lastStart = commaLoc + 1; + } +} + FontStyle::FontStyle(int variant, int weight, bool italic) : FontStyle(FontLanguageListCache::kEmptyListId, variant, weight, italic) { } @@ -65,9 +177,6 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { return (weight & kWeightMask) | (italic ? kItalicMask : 0) | (variant << kVariantShift); } -FontFamily::FontFamily(int variant) : FontFamily(FontLanguageListCache::kEmptyListId, variant) { -} - FontFamily::~FontFamily() { for (size_t i = 0; i < mFonts.size(); i++) { mFonts[i].typeface->UnrefLocked(); @@ -101,8 +210,7 @@ void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { addFontLocked(typeface, style); } -void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { - typeface->RefLocked(); +void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { typeface->RefLocked(); mFonts.push_back(Font(typeface, style)); mCoverageValid = false; } diff --git a/engine/src/flutter/libs/minikin/FontLanguage.cpp b/engine/src/flutter/libs/minikin/FontLanguage.cpp deleted file mode 100644 index 3c12e06c6f..0000000000 --- a/engine/src/flutter/libs/minikin/FontLanguage.cpp +++ /dev/null @@ -1,135 +0,0 @@ -/* - * 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. - */ - -#define LOG_TAG "Minikin" - -#include "FontLanguage.h" - -#include -#include - -namespace android { - -#define SCRIPT_TAG(c1, c2, c3, c4) \ - ((uint32_t)(c1)) << 24 | ((uint32_t)(c2)) << 16 | ((uint32_t)(c3)) << 8 | ((uint32_t)(c4)) - -// Parse BCP 47 language identifier into internal structure -FontLanguage::FontLanguage(const char* buf, size_t length) : FontLanguage() { - size_t i; - for (i = 0; i < length; i++) { - char c = buf[i]; - if (c == '-' || c == '_') break; - } - if (i == 2 || i == 3) { // only accept two or three letter language code. - mLanguage = buf[0] | (buf[1] << 8) | ((i == 3) ? (buf[2] << 16) : 0); - } else { - // We don't understand anything other than two-letter or three-letter - // language codes, so we skip parsing the rest of the string. - mLanguage = 0ul; - return; - } - - size_t next; - for (i++; i < length; i = next + 1) { - for (next = i; next < length; next++) { - char c = buf[next]; - if (c == '-' || c == '_') break; - } - if (next - i == 4 && 'A' <= buf[i] && buf[i] <= 'Z') { - mScript = SCRIPT_TAG(buf[i], buf[i + 1], buf[i + 2], buf[i + 3]); - } - } - - mSubScriptBits = scriptToSubScriptBits(mScript); -} - -//static -uint8_t FontLanguage::scriptToSubScriptBits(uint32_t script) { - uint8_t subScriptBits = 0u; - switch (script) { - case SCRIPT_TAG('H', 'a', 'n', 'g'): - subScriptBits = kHangulFlag; - break; - case SCRIPT_TAG('H', 'a', 'n', 'i'): - subScriptBits = kHanFlag; - break; - case SCRIPT_TAG('H', 'a', 'n', 's'): - subScriptBits = kHanFlag | kSimplifiedChineseFlag; - break; - case SCRIPT_TAG('H', 'a', 'n', 't'): - subScriptBits = kHanFlag | kTraditionalChineseFlag; - break; - case SCRIPT_TAG('H', 'i', 'r', 'a'): - subScriptBits = kHiraganaFlag; - break; - case SCRIPT_TAG('H', 'r', 'k', 't'): - subScriptBits = kKatakanaFlag | kHiraganaFlag; - break; - case SCRIPT_TAG('J', 'p', 'a', 'n'): - subScriptBits = kHanFlag | kKatakanaFlag | kHiraganaFlag; - break; - case SCRIPT_TAG('K', 'a', 'n', 'a'): - subScriptBits = kKatakanaFlag; - break; - case SCRIPT_TAG('K', 'o', 'r', 'e'): - subScriptBits = kHanFlag | kHangulFlag; - break; - case SCRIPT_TAG('Q', 'a', 'a', 'e'): - subScriptBits = kEmojiFlag; - break; - } - return subScriptBits; -} - -std::string FontLanguage::getString() const { - if (mLanguage == 0ul) { - return "und"; - } - char buf[16]; - size_t i = 0; - buf[i++] = mLanguage & 0xFF ; - buf[i++] = (mLanguage >> 8) & 0xFF; - char third_letter = (mLanguage >> 16) & 0xFF; - if (third_letter != 0) buf[i++] = third_letter; - if (mScript != 0) { - buf[i++] = '-'; - buf[i++] = (mScript >> 24) & 0xFFu; - buf[i++] = (mScript >> 16) & 0xFFu; - buf[i++] = (mScript >> 8) & 0xFFu; - buf[i++] = mScript & 0xFFu; - } - return std::string(buf, i); -} - -bool FontLanguage::isEqualScript(const FontLanguage other) const { - return other.mScript == mScript; -} - -bool FontLanguage::supportsHbScript(hb_script_t script) const { - static_assert(SCRIPT_TAG('J', 'p', 'a', 'n') == HB_TAG('J', 'p', 'a', 'n'), - "The Minikin script and HarfBuzz hb_script_t have different encodings."); - if (script == mScript) return true; - uint8_t requestedBits = scriptToSubScriptBits(script); - return requestedBits != 0 && (mSubScriptBits & requestedBits) == requestedBits; -} - -int FontLanguage::match(const FontLanguage other) const { - // TODO: Use script for matching. - return *this == other; -} - -#undef SCRIPT_TAG -} // namespace android diff --git a/engine/src/flutter/libs/minikin/FontLanguage.h b/engine/src/flutter/libs/minikin/FontLanguage.h deleted file mode 100644 index abe7d13179..0000000000 --- a/engine/src/flutter/libs/minikin/FontLanguage.h +++ /dev/null @@ -1,89 +0,0 @@ -/* - * 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. - */ - -#ifndef MINIKIN_FONT_LANGUAGE_H -#define MINIKIN_FONT_LANGUAGE_H - -#include -#include - -#include - -namespace android { - -// FontLanguage is a compact representation of a BCP 47 language tag. It -// does not capture all possible information, only what directly affects -// font rendering. -struct FontLanguage { -public: - // Default constructor creates the unsupported language. - FontLanguage() : mScript(0ul), mLanguage(0ul), mSubScriptBits(0ul) {} - - // Parse from string - FontLanguage(const char* buf, size_t length); - - bool operator==(const FontLanguage other) const { - return !isUnsupported() && isEqualScript(other) && isEqualLanguage(other); - } - - bool operator!=(const FontLanguage other) const { - return !(*this == other); - } - - bool isUnsupported() const { return mLanguage == 0ul; } - bool hasEmojiFlag() const { return mSubScriptBits & kEmojiFlag; } - - bool isEqualLanguage(const FontLanguage other) const { return mLanguage == other.mLanguage; } - bool isEqualScript(const FontLanguage other) const; - - // Returns true if this script supports the given script. For example, ja-Jpan supports Hira, - // ja-Hira doesn't support Jpan. - bool supportsHbScript(hb_script_t script) const; - - std::string getString() const; - - // 0 = no match, 1 = language matches - int match(const FontLanguage other) const; - - uint64_t getIdentifier() const { return (uint64_t)mScript << 32 | (uint64_t)mLanguage; } - -private: - // ISO 15924 compliant script code. The 4 chars script code are packed into a 32 bit integer. - uint32_t mScript; - - // ISO 639-1 or ISO 639-2 compliant language code. - // The two or three letter language code is packed into 32 bit integer. - // mLanguage = 0 means the FontLanguage is unsupported. - uint32_t mLanguage; - - // For faster comparing, use 7 bits for specific scripts. - static const uint8_t kEmojiFlag = 1u; - static const uint8_t kHanFlag = 1u << 1; - static const uint8_t kHangulFlag = 1u << 2; - static const uint8_t kHiraganaFlag = 1u << 3; - static const uint8_t kKatakanaFlag = 1u << 4; - static const uint8_t kSimplifiedChineseFlag = 1u << 5; - static const uint8_t kTraditionalChineseFlag = 1u << 6; - uint8_t mSubScriptBits; - - static uint8_t scriptToSubScriptBits(uint32_t script); -}; - -typedef std::vector FontLanguages; - -} // namespace android - -#endif // MINIKIN_FONT_LANGUAGE_H diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp index 2d64998e7a..e1c2343dda 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp @@ -19,92 +19,13 @@ #include "FontLanguageListCache.h" #include -#include -#include #include "MinikinInternal.h" -#include "FontLanguage.h" namespace android { const uint32_t FontLanguageListCache::kEmptyListId; -// Returns the text length of output. -static size_t toLanguageTag(char* output, size_t outSize, const std::string& locale) { - output[0] = '\0'; - if (locale.empty()) { - return 0; - } - - size_t outLength = 0; - UErrorCode uErr = U_ZERO_ERROR; - outLength = uloc_canonicalize(locale.c_str(), output, outSize, &uErr); - if (U_FAILURE(uErr)) { - // unable to build a proper language identifier - ALOGD("uloc_canonicalize(\"%s\") failed: %s", locale.c_str(), u_errorName(uErr)); - output[0] = '\0'; - return 0; - } - - // Preserve "und" and "und-****" since uloc_addLikelySubtags changes "und" to "en-Latn-US". - if (strncmp(output, "und", 3) == 0 && - (outLength == 3 || (outLength == 8 && output[3] == '_'))) { - return outLength; - } - - char likelyChars[ULOC_FULLNAME_CAPACITY]; - uErr = U_ZERO_ERROR; - uloc_addLikelySubtags(output, likelyChars, ULOC_FULLNAME_CAPACITY, &uErr); - if (U_FAILURE(uErr)) { - // unable to build a proper language identifier - ALOGD("uloc_addLikelySubtags(\"%s\") failed: %s", output, u_errorName(uErr)); - output[0] = '\0'; - return 0; - } - - uErr = U_ZERO_ERROR; - outLength = uloc_toLanguageTag(likelyChars, output, outSize, FALSE, &uErr); - if (U_FAILURE(uErr)) { - // unable to build a proper language identifier - ALOGD("uloc_toLanguageTag(\"%s\") failed: %s", likelyChars, u_errorName(uErr)); - output[0] = '\0'; - return 0; - } -#ifdef VERBOSE_DEBUG - ALOGD("ICU normalized '%s' to '%s'", locale.c_str(), output); -#endif - return outLength; -} - -static FontLanguages constructFontLanguages(const std::string& input) { - FontLanguages result; - size_t currentIdx = 0; - size_t commaLoc = 0; - char langTag[ULOC_FULLNAME_CAPACITY]; - std::unordered_set seen; - std::string locale(input.size(), 0); - - while ((commaLoc = input.find_first_of(',', currentIdx)) != std::string::npos) { - locale.assign(input, currentIdx, commaLoc - currentIdx); - currentIdx = commaLoc + 1; - size_t length = toLanguageTag(langTag, ULOC_FULLNAME_CAPACITY, locale); - FontLanguage lang(langTag, length); - uint64_t identifier = lang.getIdentifier(); - if (!lang.isUnsupported() && seen.count(identifier) == 0) { - result.push_back(lang); - seen.insert(identifier); - } - } - locale.assign(input, currentIdx, input.size() - currentIdx); - size_t length = toLanguageTag(langTag, ULOC_FULLNAME_CAPACITY, locale); - FontLanguage lang(langTag, length); - uint64_t identifier = lang.getIdentifier(); - if (!lang.isUnsupported() && seen.count(identifier) == 0) { - result.push_back(lang); - } - return result; -} - // static uint32_t FontLanguageListCache::getId(const std::string& languages) { FontLanguageListCache* inst = FontLanguageListCache::getInstance(); @@ -116,11 +37,7 @@ uint32_t FontLanguageListCache::getId(const std::string& languages) { // Given language list is not in cache. Insert it and return newly assigned ID. const uint32_t nextId = inst->mLanguageLists.size(); - FontLanguages fontLanguages = constructFontLanguages(languages); - if (fontLanguages.empty()) { - return kEmptyListId; - } - inst->mLanguageLists.push_back(fontLanguages); + inst->mLanguageLists.push_back(FontLanguages(languages.c_str(), languages.size())); inst->mLanguageListLookupTable.insert(std::make_pair(languages, nextId)); return nextId; } @@ -139,9 +56,8 @@ FontLanguageListCache* FontLanguageListCache::getInstance() { if (instance == nullptr) { instance = new FontLanguageListCache(); - // Insert an empty language list for mapping default language list to kEmptyListId. - // The default language list has only one FontLanguage and it is the unsupported language. - instance->mLanguageLists.push_back(FontLanguages({FontLanguage()})); + // Insert an empty language list for mapping empty language list to kEmptyListId. + instance->mLanguageLists.push_back(FontLanguages()); instance->mLanguageListLookupTable.insert(std::make_pair("", kEmptyListId)); } return instance; diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.h b/engine/src/flutter/libs/minikin/FontLanguageListCache.h index c961882f0a..7d627b562e 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.h +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.h @@ -20,7 +20,6 @@ #include #include -#include "FontLanguage.h" namespace android { diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 2e206a20fc..af5e6fe75a 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -34,7 +34,6 @@ #include #include -#include "FontLanguage.h" #include "FontLanguageListCache.h" #include "LayoutUtils.h" #include "HbFaceCache.h" @@ -747,15 +746,9 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t const FontLanguages& langList = FontLanguageListCache::getById(ctx->style.getLanguageListId()); if (langList.size() != 0) { - const FontLanguage* hbLanguage = &langList[0]; - for (size_t i = 0; i < langList.size(); ++i) { - if (langList[i].supportsHbScript(script)) { - hbLanguage = &langList[i]; - break; - } - } - hb_buffer_set_language(buffer, - hb_language_from_string(hbLanguage->getString().c_str(), -1)); + // TODO: use all languages in langList. + string lang = langList[0].getString(); + hb_buffer_set_language(buffer, hb_language_from_string(lang.c_str(), -1)); } hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); if (ctx->paint.hyphenEdit.hasHyphen() && srunend > srunstart) { diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index cf9b704efa..85d76afccb 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -16,9 +16,7 @@ #include -#include "FontLanguage.h" #include "FontTestUtils.h" -#include "ICUTestBase.h" #include "MinikinFontForTest.h" #include "UnicodeUtils.h" @@ -44,8 +42,6 @@ const char kColorEmojiFont[] = kTestFontDir "ColorEmojiFont.ttf"; const char kTextEmojiFont[] = kTestFontDir "TextEmojiFont.ttf"; const char kMixedEmojiFont[] = kTestFontDir "ColorTextMixedEmojiFont.ttf"; -typedef ICUTestBase FontCollectionItemizeTest; - // Utility function for calling itemize function. void itemize(FontCollection* collection, const char* str, FontStyle style, std::vector* result) { @@ -64,7 +60,7 @@ const std::string& getFontPath(const FontCollection::Run& run) { return ((MinikinFontForTest*)run.fakedFont.font)->fontPath(); } -TEST_F(FontCollectionItemizeTest, itemize_latin) { +TEST(FontCollectionItemizeTest, itemize_latin) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -134,7 +130,7 @@ TEST_F(FontCollectionItemizeTest, itemize_latin) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); } -TEST_F(FontCollectionItemizeTest, itemize_emoji) { +TEST(FontCollectionItemizeTest, itemize_emoji) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -195,7 +191,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emoji) { EXPECT_FALSE(runs[1].fakedFont.fakery.isFakeItalic()); } -TEST_F(FontCollectionItemizeTest, itemize_non_latin) { +TEST(FontCollectionItemizeTest, itemize_non_latin) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -284,7 +280,7 @@ TEST_F(FontCollectionItemizeTest, itemize_non_latin) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); } -TEST_F(FontCollectionItemizeTest, itemize_mixed) { +TEST(FontCollectionItemizeTest, itemize_mixed) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -323,7 +319,7 @@ TEST_F(FontCollectionItemizeTest, itemize_mixed) { EXPECT_FALSE(runs[4].fakedFont.fakery.isFakeItalic()); } -TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { +TEST(FontCollectionItemizeTest, itemize_variationSelector) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -462,7 +458,7 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { EXPECT_EQ(kLatinFont, getFontPath(runs[0])); } -TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { +TEST(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -587,7 +583,7 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontPath(runs[0])); } -TEST_F(FontCollectionItemizeTest, itemize_no_crash) { +TEST(FontCollectionItemizeTest, itemize_no_crash) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -611,7 +607,7 @@ TEST_F(FontCollectionItemizeTest, itemize_no_crash) { itemize(collection.get(), "U+FE00 U+302D U+E0100", FontStyle(), &runs); } -TEST_F(FontCollectionItemizeTest, itemize_fakery) { +TEST(FontCollectionItemizeTest, itemize_fakery) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -651,18 +647,18 @@ TEST_F(FontCollectionItemizeTest, itemize_fakery) { EXPECT_TRUE(runs[0].fakedFont.fakery.isFakeItalic()); } -TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { +TEST(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { // kVSTestFont supports U+717D U+FE02 but doesn't support U+717D. // kVSTestFont should be selected for U+717D U+FE02 even if it does not support the base code // point. const std::string kVSTestFont = kTestFontDir "VarioationSelectorTest-Regular.ttf"; std::vector families; - FontFamily* family1 = new FontFamily(android::VARIANT_DEFAULT); + FontFamily* family1 = new FontFamily(FontLanguage(), android::VARIANT_DEFAULT); family1->addFont(new MinikinFontForTest(kLatinFont)); families.push_back(family1); - FontFamily* family2 = new FontFamily(android::VARIANT_DEFAULT); + FontFamily* family2 = new FontFamily(FontLanguage(), android::VARIANT_DEFAULT); family2->addFont(new MinikinFontForTest(kVSTestFont)); families.push_back(family2); @@ -680,7 +676,7 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { family2->Unref(); } -TEST_F(FontCollectionItemizeTest, itemize_emojiSelection) { +TEST(FontCollectionItemizeTest, itemize_emojiSelection) { std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); std::vector runs; @@ -752,7 +748,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection) { EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); } -TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { +TEST(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); std::vector runs; @@ -834,7 +830,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { EXPECT_EQ(kMixedEmojiFont, getFontPath(runs[0])); } -TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { +TEST(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); std::vector runs; diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index ac7616fada..fc44e6c636 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -17,261 +17,74 @@ #include #include - -#include - #include "FontLanguageListCache.h" -#include "ICUTestBase.h" #include "MinikinFontForTest.h" #include "MinikinInternal.h" namespace android { -typedef ICUTestBase FontLanguagesTest; -typedef ICUTestBase FontLanguageTest; - -static FontLanguages createFontLanguages(const std::string& input) { - uint32_t langId = FontLanguageListCache::getId(input); - return FontLanguageListCache::getById(langId); -} - -static FontLanguage createFontLanguage(const std::string& input) { - uint32_t langId = FontLanguageListCache::getId(input); - return FontLanguageListCache::getById(langId)[0]; -} - -TEST_F(FontLanguageTest, basicTests) { - FontLanguage defaultLang; - FontLanguage emptyLang("", 0); - FontLanguage english = createFontLanguage("en"); - FontLanguage french = createFontLanguage("fr"); - FontLanguage und = createFontLanguage("und"); - FontLanguage undQaae = createFontLanguage("und-Qaae"); - - EXPECT_EQ(english, english); - EXPECT_EQ(french, french); - - EXPECT_TRUE(defaultLang != defaultLang); - EXPECT_TRUE(emptyLang != emptyLang); - EXPECT_TRUE(defaultLang != emptyLang); - EXPECT_TRUE(defaultLang != und); - EXPECT_TRUE(emptyLang != und); - EXPECT_TRUE(english != defaultLang); - EXPECT_TRUE(english != emptyLang); - EXPECT_TRUE(english != french); - EXPECT_TRUE(english != undQaae); - EXPECT_TRUE(und != undQaae); - EXPECT_TRUE(english != und); - - EXPECT_TRUE(defaultLang.isUnsupported()); - EXPECT_TRUE(emptyLang.isUnsupported()); - - EXPECT_FALSE(english.isUnsupported()); - EXPECT_FALSE(french.isUnsupported()); - EXPECT_FALSE(und.isUnsupported()); - EXPECT_FALSE(undQaae.isUnsupported()); -} - -TEST_F(FontLanguageTest, getStringTest) { - EXPECT_EQ("en-Latn", createFontLanguage("en").getString()); - EXPECT_EQ("en-Latn", createFontLanguage("en-Latn").getString()); - - // Capitalized language code or lowercased script should be normalized. - EXPECT_EQ("en-Latn", createFontLanguage("EN-LATN").getString()); - EXPECT_EQ("en-Latn", createFontLanguage("EN-latn").getString()); - EXPECT_EQ("en-Latn", createFontLanguage("en-latn").getString()); - - // Invalid script should be kept. - EXPECT_EQ("en-Xyzt", createFontLanguage("en-xyzt").getString()); - - EXPECT_EQ("en-Latn", createFontLanguage("en-Latn-US").getString()); - EXPECT_EQ("ja-Jpan", createFontLanguage("ja").getString()); - EXPECT_EQ("und", createFontLanguage("und").getString()); - EXPECT_EQ("und", createFontLanguage("UND").getString()); - EXPECT_EQ("und", createFontLanguage("Und").getString()); - EXPECT_EQ("und-Qaae", createFontLanguage("und-Qaae").getString()); - EXPECT_EQ("und-Qaae", createFontLanguage("Und-QAAE").getString()); - EXPECT_EQ("und-Qaae", createFontLanguage("Und-qaae").getString()); - - EXPECT_EQ("de-Latn", createFontLanguage("de-1901").getString()); - - // This is not a necessary desired behavior, just known behavior. - EXPECT_EQ("en-Latn", createFontLanguage("und-Abcdefgh").getString()); -} - -TEST_F(FontLanguageTest, ScriptEqualTest) { - EXPECT_TRUE(createFontLanguage("en").isEqualScript(createFontLanguage("en"))); - EXPECT_TRUE(createFontLanguage("en-Latn").isEqualScript(createFontLanguage("en"))); - EXPECT_TRUE(createFontLanguage("jp-Latn").isEqualScript(createFontLanguage("en-Latn"))); - EXPECT_TRUE(createFontLanguage("en-Jpan").isEqualScript(createFontLanguage("en-Jpan"))); - - EXPECT_FALSE(createFontLanguage("en-Jpan").isEqualScript(createFontLanguage("en-Hira"))); - EXPECT_FALSE(createFontLanguage("en-Jpan").isEqualScript(createFontLanguage("en-Hani"))); -} - -TEST_F(FontLanguageTest, ScriptMatchTest) { - const bool SUPPORTED = true; - const bool NOT_SUPPORTED = false; - - struct TestCase { - const std::string baseScript; - const std::string requestedScript; - bool isSupported; - } testCases[] = { - // Same scripts - { "en-Latn", "Latn", SUPPORTED }, - { "ja-Jpan", "Jpan", SUPPORTED }, - { "ja-Hira", "Hira", SUPPORTED }, - { "ja-Kana", "Kana", SUPPORTED }, - { "ja-Hrkt", "Hrkt", SUPPORTED }, - { "zh-Hans", "Hans", SUPPORTED }, - { "zh-Hant", "Hant", SUPPORTED }, - { "zh-Hani", "Hani", SUPPORTED }, - { "ko-Kore", "Kore", SUPPORTED }, - { "ko-Hang", "Hang", SUPPORTED }, - - // Japanese supports Hiragana, Katakanara, etc. - { "ja-Jpan", "Hira", SUPPORTED }, - { "ja-Jpan", "Kana", SUPPORTED }, - { "ja-Jpan", "Hrkt", SUPPORTED }, - { "ja-Hrkt", "Hira", SUPPORTED }, - { "ja-Hrkt", "Kana", SUPPORTED }, - - // Chinese supports Han. - { "zh-Hans", "Hani", SUPPORTED }, - { "zh-Hant", "Hani", SUPPORTED }, - - // Korean supports Hangul. - { "ko-Kore", "Hang", SUPPORTED }, - - // Different scripts - { "ja-Jpan", "Latn", NOT_SUPPORTED }, - { "en-Latn", "Jpan", NOT_SUPPORTED }, - { "ja-Jpan", "Hant", NOT_SUPPORTED }, - { "zh-Hant", "Jpan", NOT_SUPPORTED }, - { "ja-Jpan", "Hans", NOT_SUPPORTED }, - { "zh-Hans", "Jpan", NOT_SUPPORTED }, - { "ja-Jpan", "Kore", NOT_SUPPORTED }, - { "ko-Kore", "Jpan", NOT_SUPPORTED }, - { "zh-Hans", "Hant", NOT_SUPPORTED }, - { "zh-Hant", "Hans", NOT_SUPPORTED }, - { "zh-Hans", "Kore", NOT_SUPPORTED }, - { "ko-Kore", "Hans", NOT_SUPPORTED }, - { "zh-Hant", "Kore", NOT_SUPPORTED }, - { "ko-Kore", "Hant", NOT_SUPPORTED }, - - // Hiragana doesn't support Japanese, etc. - { "ja-Hira", "Jpan", NOT_SUPPORTED }, - { "ja-Kana", "Jpan", NOT_SUPPORTED }, - { "ja-Hrkt", "Jpan", NOT_SUPPORTED }, - { "ja-Hani", "Jpan", NOT_SUPPORTED }, - { "ja-Hira", "Hrkt", NOT_SUPPORTED }, - { "ja-Kana", "Hrkt", NOT_SUPPORTED }, - { "ja-Hani", "Hrkt", NOT_SUPPORTED }, - { "ja-Hani", "Hira", NOT_SUPPORTED }, - { "ja-Hani", "Kana", NOT_SUPPORTED }, - - // Kanji doesn't support Chinese, etc. - { "zh-Hani", "Hant", NOT_SUPPORTED }, - { "zh-Hani", "Hans", NOT_SUPPORTED }, - - // Hangul doesn't support Korean, etc. - { "ko-Hang", "Kore", NOT_SUPPORTED }, - { "ko-Hani", "Kore", NOT_SUPPORTED }, - { "ko-Hani", "Hang", NOT_SUPPORTED }, - { "ko-Hang", "Hani", NOT_SUPPORTED }, - }; - - for (auto testCase : testCases) { - hb_script_t script = hb_script_from_iso15924_tag( - HB_TAG(testCase.requestedScript[0], testCase.requestedScript[1], - testCase.requestedScript[2], testCase.requestedScript[3])); - if (testCase.isSupported) { - EXPECT_TRUE( - createFontLanguage(testCase.baseScript).supportsHbScript(script)) - << testCase.baseScript << " should support " << testCase.requestedScript; - } else { - EXPECT_FALSE( - createFontLanguage(testCase.baseScript).supportsHbScript(script)) - << testCase.baseScript << " shouldn't support " << testCase.requestedScript; - } - } -} - -TEST_F(FontLanguagesTest, basicTests) { +TEST(FontLanguagesTest, basicTests) { FontLanguages emptyLangs; EXPECT_EQ(0u, emptyLangs.size()); - FontLanguage english = createFontLanguage("en"); - FontLanguages singletonLangs = createFontLanguages("en"); + FontLanguage english("en", 2); + FontLanguages singletonLangs("en", 2); EXPECT_EQ(1u, singletonLangs.size()); EXPECT_EQ(english, singletonLangs[0]); - FontLanguage french = createFontLanguage("fr"); - FontLanguages twoLangs = createFontLanguages("en,fr"); + FontLanguage french("fr", 2); + FontLanguages twoLangs("en,fr", 5); EXPECT_EQ(2u, twoLangs.size()); EXPECT_EQ(english, twoLangs[0]); EXPECT_EQ(french, twoLangs[1]); } -TEST_F(FontLanguagesTest, unsupportedLanguageTests) { - FontLanguage unsupportedLang = createFontLanguage("abcd"); +TEST(FontLanguagesTest, unsupportedLanguageTests) { + FontLanguage unsupportedLang("x-example", 9); ASSERT_TRUE(unsupportedLang.isUnsupported()); - FontLanguages oneUnsupported = createFontLanguages("abcd-example"); + FontLanguages oneUnsupported("x-example", 9); EXPECT_EQ(1u, oneUnsupported.size()); EXPECT_TRUE(oneUnsupported[0].isUnsupported()); - FontLanguages twoUnsupporteds = createFontLanguages("abcd-example,abcd-example"); + FontLanguages twoUnsupporteds("x-example,x-example", 19); EXPECT_EQ(1u, twoUnsupporteds.size()); EXPECT_TRUE(twoUnsupporteds[0].isUnsupported()); - FontLanguage english = createFontLanguage("en"); - FontLanguages firstUnsupported = createFontLanguages("abcd-example,en"); + FontLanguage english("en", 2); + FontLanguages firstUnsupported("x-example,en", 12); EXPECT_EQ(1u, firstUnsupported.size()); EXPECT_EQ(english, firstUnsupported[0]); - FontLanguages lastUnsupported = createFontLanguages("en,abcd-example"); + FontLanguages lastUnsupported("en,x-example", 12); EXPECT_EQ(1u, lastUnsupported.size()); EXPECT_EQ(english, lastUnsupported[0]); } -TEST_F(FontLanguagesTest, repeatedLanguageTests) { - FontLanguage english = createFontLanguage("en"); - FontLanguage french = createFontLanguage("fr"); - FontLanguage englishInLatn = createFontLanguage("en-Latn"); +TEST(FontLanguagesTest, repeatedLanguageTests) { + FontLanguage english("en", 2); + FontLanguage englishInLatn("en-Latn", 2); ASSERT_TRUE(english == englishInLatn); - FontLanguages langs = createFontLanguages("en,en-Latn"); + FontLanguages langs("en,en-Latn", 10); EXPECT_EQ(1u, langs.size()); EXPECT_EQ(english, langs[0]); - - // Country codes are ignored. - FontLanguages fr = createFontLanguages("fr,fr-CA,fr-FR"); - EXPECT_EQ(1u, fr.size()); - EXPECT_EQ(french, fr[0]); - - // The order should be kept. - langs = createFontLanguages("en,fr,en-Latn"); - EXPECT_EQ(2u, langs.size()); - EXPECT_EQ(english, langs[0]); - EXPECT_EQ(french, langs[1]); } -TEST_F(FontLanguagesTest, undEmojiTests) { - FontLanguage emoji = createFontLanguage("und-Qaae"); +TEST(FontLanguagesTest, undEmojiTests) { + FontLanguage emoji("und-Qaae", 8); EXPECT_TRUE(emoji.hasEmojiFlag()); - FontLanguage und = createFontLanguage("und"); + FontLanguage und("und", 3); EXPECT_FALSE(und.hasEmojiFlag()); EXPECT_FALSE(emoji == und); - FontLanguage undExample = createFontLanguage("und-example"); + FontLanguage undExample("und-example", 10); EXPECT_FALSE(undExample.hasEmojiFlag()); EXPECT_FALSE(emoji == undExample); } -TEST_F(FontLanguagesTest, registerLanguageListTest) { +TEST(FontLanguagesTest, registerLanguageListTest) { EXPECT_EQ(0UL, FontStyle::registerLanguageList("")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en")); EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); @@ -309,10 +122,9 @@ TEST_F(FontLanguagesTest, registerLanguageListTest) { // U+717D U+E0103 (VS20) const char kVsTestFont[] = kTestFontDir "VarioationSelectorTest-Regular.ttf"; -class FontFamilyTest : public ICUTestBase { +class FontFamilyTest : public testing::Test { public: virtual void SetUp() override { - ICUTestBase::SetUp(); if (access(kVsTestFont, R_OK) != 0) { FAIL() << "Unable to read " << kVsTestFont << ". " << "Please prepare the test data directory. " diff --git a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp index f83988c1f5..29757fedce 100644 --- a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp +++ b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp @@ -17,15 +17,11 @@ #include #include - #include "FontLanguageListCache.h" -#include "ICUTestBase.h" namespace android { -typedef ICUTestBase FontLanguageListCacheTest; - -TEST_F(FontLanguageListCacheTest, getId) { +TEST(FontLanguageListCacheTest, getId) { EXPECT_EQ(0UL, FontLanguageListCache::getId("")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en")); EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); @@ -46,15 +42,11 @@ TEST_F(FontLanguageListCacheTest, getId) { FontLanguageListCache::getId("en,zh-Hant")); } -TEST_F(FontLanguageListCacheTest, getById) { - uint32_t enLangId = FontLanguageListCache::getId("en"); - uint32_t jpLangId = FontLanguageListCache::getId("jp"); - FontLanguage english = FontLanguageListCache::getById(enLangId)[0]; - FontLanguage japanese = FontLanguageListCache::getById(jpLangId)[0]; +TEST(FontLanguageListCacheTest, getById) { + FontLanguage english("en", 2); + FontLanguage japanese("jp", 2); - FontLanguages defLangs = FontLanguageListCache::getById(0); - EXPECT_EQ(1UL, defLangs.size()); - EXPECT_TRUE(defLangs[0].isUnsupported()); + EXPECT_EQ(0UL, FontLanguageListCache::getById(0).size()); FontLanguages langs = FontLanguageListCache::getById(FontLanguageListCache::getId("en")); ASSERT_EQ(1UL, langs.size()); diff --git a/engine/src/flutter/tests/FontTestUtils.cpp b/engine/src/flutter/tests/FontTestUtils.cpp index 98dab5121b..8e1d184adc 100644 --- a/engine/src/flutter/tests/FontTestUtils.cpp +++ b/engine/src/flutter/tests/FontTestUtils.cpp @@ -20,8 +20,6 @@ #include #include - -#include "FontLanguage.h" #include "MinikinFontForTest.h" std::unique_ptr getFontCollection( @@ -46,10 +44,9 @@ std::unique_ptr getFontCollection( } xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); - uint32_t langId = android::FontStyle::registerLanguageList( - std::string((const char*)lang, xmlStrlen(lang))); - android::FontFamily* family = new android::FontFamily(langId, variant); + android::FontFamily* family = new android::FontFamily( + android::FontLanguage((const char*)lang, xmlStrlen(lang)), variant); for (xmlNode* fontNode = familyNode->children; fontNode; fontNode = fontNode->next) { if (xmlStrcmp(fontNode->name, (const xmlChar*)"font") != 0) { diff --git a/engine/src/flutter/tests/ICUTestBase.h b/engine/src/flutter/tests/ICUTestBase.h deleted file mode 100644 index 3bcfaf3694..0000000000 --- a/engine/src/flutter/tests/ICUTestBase.h +++ /dev/null @@ -1,52 +0,0 @@ -/* - * 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. - */ - -#ifndef MINIKIN_TEST_ICU_TEST_BASE_H -#define MINIKIN_TEST_ICU_TEST_BASE_H - -#include -#include -#include - -// low level file access for mapping ICU data -#include -#include -#include - -class ICUTestBase : public testing::Test { -protected: - virtual void SetUp() override { - const char* fn = "/system/usr/icu/" U_ICUDATA_NAME ".dat"; - int fd = open(fn, O_RDONLY); - ASSERT_NE(-1, fd); - struct stat sb; - ASSERT_EQ(0, fstat(fd, &sb)); - void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd, 0); - - UErrorCode errorCode = U_ZERO_ERROR; - udata_setCommonData(data, &errorCode); - ASSERT_TRUE(U_SUCCESS(errorCode)); - u_init(&errorCode); - ASSERT_TRUE(U_SUCCESS(errorCode)); - } - - virtual void TearDown() override { - u_cleanup(); - } -}; - - -#endif // MINIKIN_TEST_ICU_TEST_BASE_H From 5bacbeb51400c6c9491b1a3b3267aec71252a200 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Mon, 14 Dec 2015 18:33:23 -0800 Subject: [PATCH 135/364] Save all kind of script tags into FontLanguage. This is 2nd attempt of I8df992a6851021903478972601a9a5c9424b100c. The main purpose of this CL is expanding FontLanguage to be able to save full script tag. Previously, FontLangauge kept only limited script tags. With this CL, FontLanguage keeps all script tags. This CL contains the following changes: - FontLanguage changes: -- Moved to private directory not to be instantiated outside of Minikin. -- Removed bool(), bits(), FontLanguage(uint32_t) methods which are no longer used. -- Change the FontLanguage internal data structure. -- Introduces script match logic. - FontLanguages changes: -- Moved to private directory not to be instantiated outside of Minikin. -- This is now std::vector - FontLanguageListCache changes: -- Now FontLanguageListCache::getId through FontStyle::registerLanguageList is the only way to instantiate the FontLanguage. -- Normalize input to be BCP47 compliant identifier by ICU. Bug: 26168983 Change-Id: I431b3f361a7635497c05b85e8ecbeb48d9aef63e --- .../src/flutter/include/minikin/FontFamily.h | 64 +---- engine/src/flutter/libs/minikin/Android.mk | 1 + .../flutter/libs/minikin/FontCollection.cpp | 10 +- .../src/flutter/libs/minikin/FontFamily.cpp | 120 +-------- .../src/flutter/libs/minikin/FontLanguage.cpp | 136 ++++++++++ .../src/flutter/libs/minikin/FontLanguage.h | 89 +++++++ .../libs/minikin/FontLanguageListCache.cpp | 90 ++++++- .../libs/minikin/FontLanguageListCache.h | 1 + engine/src/flutter/libs/minikin/Layout.cpp | 13 +- .../tests/FontCollectionItemizeTest.cpp | 32 +-- engine/src/flutter/tests/FontFamilyTest.cpp | 232 ++++++++++++++++-- .../tests/FontLanguageListCacheTest.cpp | 18 +- engine/src/flutter/tests/FontTestUtils.cpp | 7 +- engine/src/flutter/tests/ICUTestBase.h | 52 ++++ 14 files changed, 640 insertions(+), 225 deletions(-) create mode 100644 engine/src/flutter/libs/minikin/FontLanguage.cpp create mode 100644 engine/src/flutter/libs/minikin/FontLanguage.h create mode 100644 engine/src/flutter/tests/ICUTestBase.h diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 00130e6f5d..aa2e0ac2e4 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -30,62 +30,6 @@ namespace android { class MinikinFont; -// FontLanguage is a compact representation of a bcp-47 language tag. It -// does not capture all possible information, only what directly affects -// font rendering. -class FontLanguage { - friend class FontStyle; - friend class FontLanguages; -public: - FontLanguage() : mBits(0) { } - - // Parse from string - FontLanguage(const char* buf, size_t size); - - bool operator==(const FontLanguage other) const { - return mBits != kUnsupportedLanguage && mBits == other.mBits; - } - operator bool() const { return mBits != 0; } - - bool isUnsupported() const { return mBits == kUnsupportedLanguage; } - bool hasEmojiFlag() const { return isUnsupported() ? false : (mBits & kEmojiFlag); } - - std::string getString() const; - - // 0 = no match, 1 = language matches - int match(const FontLanguage other) const; - -private: - explicit FontLanguage(uint32_t bits) : mBits(bits) { } - - uint32_t bits() const { return mBits; } - - static const uint32_t kUnsupportedLanguage = 0xFFFFFFFFu; - static const uint32_t kBaseLangMask = 0xFFFFFFu; - static const uint32_t kHansFlag = 1u << 24; - static const uint32_t kHantFlag = 1u << 25; - static const uint32_t kEmojiFlag = 1u << 26; - static const uint32_t kScriptMask = kHansFlag | kHantFlag | kEmojiFlag; - uint32_t mBits; -}; - -// A list of zero or more instances of FontLanguage, in the order of -// preference. Used for further resolution of rendering results. -class FontLanguages { -public: - FontLanguages() { mLangs.clear(); } - - // Parse from string, which is a comma-separated list of languages - FontLanguages(const char* buf, size_t size); - - const FontLanguage& operator[](size_t index) const { return mLangs.at(index); } - - size_t size() const { return mLangs.size(); } - -private: - std::vector mLangs; -}; - // FontStyle represents all style information needed to select an actual font // from a collection. The implementation is packed into two 32-bit words // so it can be efficiently copied, embedded in other objects, etc. @@ -158,7 +102,9 @@ class FontFamily : public MinikinRefCounted { public: FontFamily() : mHbFont(nullptr) { } - FontFamily(FontLanguage lang, int variant) : mLang(lang), mVariant(variant), mHbFont(nullptr) { + FontFamily(int variant); + + FontFamily(uint32_t langId, int variant) : mLangId(langId), mVariant(variant), mHbFont(nullptr) { } ~FontFamily(); @@ -169,7 +115,7 @@ public: void addFont(MinikinFont* typeface, FontStyle style); FakedFont getClosestMatch(FontStyle style) const; - FontLanguage lang() const { return mLang; } + uint32_t langId() const { return mLangId; } int variant() const { return mVariant; } // API's for enumerating the fonts in a family. These don't guarantee any particular order @@ -200,7 +146,7 @@ private: MinikinFont* typeface; FontStyle style; }; - FontLanguage mLang; + uint32_t mLangId; int mVariant; std::vector mFonts; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 4c945a60c9..42fdca3919 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -21,6 +21,7 @@ minikin_src_files := \ CmapCoverage.cpp \ FontCollection.cpp \ FontFamily.cpp \ + FontLanguage.cpp \ FontLanguageListCache.cpp \ GraphemeBreak.cpp \ HbFaceCache.cpp \ diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index bba2ef9535..62c70310c0 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -22,6 +22,7 @@ #include "unicode/unistr.h" #include "unicode/unorm2.h" +#include "FontLanguage.h" #include "FontLanguageListCache.h" #include "MinikinInternal.h" #include @@ -150,14 +151,17 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, // always use it. return family; } - int score = lang.match(family->lang()) * 2; + + // TODO use all language in the list. + FontLanguage fontLang = FontLanguageListCache::getById(family->langId())[0]; + int score = lang.match(fontLang) * 2; if (family->variant() == 0 || family->variant() == variant) { score++; } if (hasVSGlyph) { score += 8; - } else if (((vs == 0xFE0F) && family->lang().hasEmojiFlag()) || - ((vs == 0xFE0E) && !family->lang().hasEmojiFlag())) { + } else if (((vs == 0xFE0F) && fontLang.hasEmojiFlag()) || + ((vs == 0xFE0E) && !fontLang.hasEmojiFlag())) { score += 4; } if (score > bestScore) { diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 7639831240..1405789028 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -16,8 +16,6 @@ #define LOG_TAG "Minikin" -#include - #include #include #include @@ -28,6 +26,7 @@ #include +#include "FontLanguage.h" #include "FontLanguageListCache.h" #include "HbFaceCache.h" #include "MinikinInternal.h" @@ -41,117 +40,6 @@ using std::vector; namespace android { -// Parse bcp-47 language identifier into internal structure -FontLanguage::FontLanguage(const char* buf, size_t size) { - uint32_t bits = 0; - size_t i; - for (i = 0; i < size; i++) { - uint16_t c = buf[i]; - if (c == '-' || c == '_') break; - } - if (i == 2) { - bits = uint8_t(buf[0]) | (uint8_t(buf[1]) << 8); - } else if (i == 3) { - bits = uint8_t(buf[0]) | (uint8_t(buf[1]) << 8) | (uint8_t(buf[2]) << 16); - } else { - mBits = kUnsupportedLanguage; - // We don't understand anything other than two-letter or three-letter - // language codes, so we skip parsing the rest of the string. - return; - } - size_t next; - for (i++; i < size; i = next + 1) { - for (next = i; next < size; next++) { - uint16_t c = buf[next]; - if (c == '-' || c == '_') break; - } - if (next - i == 4) { - if (buf[i] == 'H' && buf[i+1] == 'a' && buf[i+2] == 'n') { - if (buf[i+3] == 's') { - bits |= kHansFlag; - } else if (buf[i+3] == 't') { - bits |= kHantFlag; - } - } else if (buf[i] == 'Q' && buf[i+1] == 'a' && buf[i+2] == 'a'&& buf[i+3] == 'e') { - bits |= kEmojiFlag; - } - } - // TODO: this might be a good place to infer script from country (zh_TW -> Hant), - // but perhaps it's up to the client to do that, before passing a string. - } - mBits = bits; -} - -std::string FontLanguage::getString() const { - if (mBits == kUnsupportedLanguage) { - return "und"; - } - char buf[16]; - size_t i = 0; - if (mBits & kBaseLangMask) { - buf[i++] = mBits & 0xFFu; - buf[i++] = (mBits >> 8) & 0xFFu; - char third_letter = (mBits >> 16) & 0xFFu; - if (third_letter != 0) buf[i++] = third_letter; - } - if (mBits & kScriptMask) { - if (!i) { - // This should not happen, but as it apparently has, we fill the language code part - // with "und". - buf[i++] = 'u'; - buf[i++] = 'n'; - buf[i++] = 'd'; - } - buf[i++] = '-'; - if (mBits & kEmojiFlag) { - buf[i++] = 'Q'; - buf[i++] = 'a'; - buf[i++] = 'a'; - buf[i++] = 'e'; - } else { - buf[i++] = 'H'; - buf[i++] = 'a'; - buf[i++] = 'n'; - buf[i++] = (mBits & kHansFlag) ? 's' : 't'; - } - } - return std::string(buf, i); -} - -int FontLanguage::match(const FontLanguage other) const { - return *this == other; -} - -FontLanguages::FontLanguages(const char* buf, size_t size) { - std::unordered_set seen; - mLangs.clear(); - const char* bufEnd = buf + size; - const char* lastStart = buf; - bool isLastLang = false; - while (true) { - const char* commaLoc = static_cast( - memchr(lastStart, ',', bufEnd - lastStart)); - if (commaLoc == NULL) { - commaLoc = bufEnd; - isLastLang = true; - } - FontLanguage lang(lastStart, commaLoc - lastStart); - if (isLastLang && mLangs.size() == 0) { - // Make sure the list has at least one member - mLangs.push_back(lang); - return; - } - uint32_t bits = lang.bits(); - if (bits != FontLanguage::kUnsupportedLanguage && seen.count(bits) == 0) { - mLangs.push_back(lang); - if (isLastLang) return; - seen.insert(bits); - } - if (isLastLang) return; - lastStart = commaLoc + 1; - } -} - FontStyle::FontStyle(int variant, int weight, bool italic) : FontStyle(FontLanguageListCache::kEmptyListId, variant, weight, italic) { } @@ -177,6 +65,9 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { return (weight & kWeightMask) | (italic ? kItalicMask : 0) | (variant << kVariantShift); } +FontFamily::FontFamily(int variant) : FontFamily(FontLanguageListCache::kEmptyListId, variant) { +} + FontFamily::~FontFamily() { for (size_t i = 0; i < mFonts.size(); i++) { mFonts[i].typeface->UnrefLocked(); @@ -210,7 +101,8 @@ void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { addFontLocked(typeface, style); } -void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { typeface->RefLocked(); +void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { + typeface->RefLocked(); mFonts.push_back(Font(typeface, style)); mCoverageValid = false; } diff --git a/engine/src/flutter/libs/minikin/FontLanguage.cpp b/engine/src/flutter/libs/minikin/FontLanguage.cpp new file mode 100644 index 0000000000..bb8d608ac3 --- /dev/null +++ b/engine/src/flutter/libs/minikin/FontLanguage.cpp @@ -0,0 +1,136 @@ +/* + * 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. + */ + +#define LOG_TAG "Minikin" + +#include "FontLanguage.h" + +#include +#include + +namespace android { + +#define SCRIPT_TAG(c1, c2, c3, c4) \ + (((uint32_t)(c1)) << 24 | ((uint32_t)(c2)) << 16 | ((uint32_t)(c3)) << 8 | \ + ((uint32_t)(c4))) + +// Parse BCP 47 language identifier into internal structure +FontLanguage::FontLanguage(const char* buf, size_t length) : FontLanguage() { + size_t i; + for (i = 0; i < length; i++) { + char c = buf[i]; + if (c == '-' || c == '_') break; + } + if (i == 2 || i == 3) { // only accept two or three letter language code. + mLanguage = buf[0] | (buf[1] << 8) | ((i == 3) ? (buf[2] << 16) : 0); + } else { + // We don't understand anything other than two-letter or three-letter + // language codes, so we skip parsing the rest of the string. + mLanguage = 0ul; + return; + } + + size_t next; + for (i++; i < length; i = next + 1) { + for (next = i; next < length; next++) { + char c = buf[next]; + if (c == '-' || c == '_') break; + } + if (next - i == 4 && 'A' <= buf[i] && buf[i] <= 'Z') { + mScript = SCRIPT_TAG(buf[i], buf[i + 1], buf[i + 2], buf[i + 3]); + } + } + + mSubScriptBits = scriptToSubScriptBits(mScript); +} + +//static +uint8_t FontLanguage::scriptToSubScriptBits(uint32_t script) { + uint8_t subScriptBits = 0u; + switch (script) { + case SCRIPT_TAG('H', 'a', 'n', 'g'): + subScriptBits = kHangulFlag; + break; + case SCRIPT_TAG('H', 'a', 'n', 'i'): + subScriptBits = kHanFlag; + break; + case SCRIPT_TAG('H', 'a', 'n', 's'): + subScriptBits = kHanFlag | kSimplifiedChineseFlag; + break; + case SCRIPT_TAG('H', 'a', 'n', 't'): + subScriptBits = kHanFlag | kTraditionalChineseFlag; + break; + case SCRIPT_TAG('H', 'i', 'r', 'a'): + subScriptBits = kHiraganaFlag; + break; + case SCRIPT_TAG('H', 'r', 'k', 't'): + subScriptBits = kKatakanaFlag | kHiraganaFlag; + break; + case SCRIPT_TAG('J', 'p', 'a', 'n'): + subScriptBits = kHanFlag | kKatakanaFlag | kHiraganaFlag; + break; + case SCRIPT_TAG('K', 'a', 'n', 'a'): + subScriptBits = kKatakanaFlag; + break; + case SCRIPT_TAG('K', 'o', 'r', 'e'): + subScriptBits = kHanFlag | kHangulFlag; + break; + case SCRIPT_TAG('Q', 'a', 'a', 'e'): + subScriptBits = kEmojiFlag; + break; + } + return subScriptBits; +} + +std::string FontLanguage::getString() const { + if (mLanguage == 0ul) { + return "und"; + } + char buf[16]; + size_t i = 0; + buf[i++] = mLanguage & 0xFF ; + buf[i++] = (mLanguage >> 8) & 0xFF; + char third_letter = (mLanguage >> 16) & 0xFF; + if (third_letter != 0) buf[i++] = third_letter; + if (mScript != 0) { + buf[i++] = '-'; + buf[i++] = (mScript >> 24) & 0xFFu; + buf[i++] = (mScript >> 16) & 0xFFu; + buf[i++] = (mScript >> 8) & 0xFFu; + buf[i++] = mScript & 0xFFu; + } + return std::string(buf, i); +} + +bool FontLanguage::isEqualScript(const FontLanguage other) const { + return other.mScript == mScript; +} + +bool FontLanguage::supportsHbScript(hb_script_t script) const { + static_assert(SCRIPT_TAG('J', 'p', 'a', 'n') == HB_TAG('J', 'p', 'a', 'n'), + "The Minikin script and HarfBuzz hb_script_t have different encodings."); + if (script == mScript) return true; + uint8_t requestedBits = scriptToSubScriptBits(script); + return requestedBits != 0 && (mSubScriptBits & requestedBits) == requestedBits; +} + +int FontLanguage::match(const FontLanguage other) const { + // TODO: Use script for matching. + return *this == other; +} + +#undef SCRIPT_TAG +} // namespace android diff --git a/engine/src/flutter/libs/minikin/FontLanguage.h b/engine/src/flutter/libs/minikin/FontLanguage.h new file mode 100644 index 0000000000..abe7d13179 --- /dev/null +++ b/engine/src/flutter/libs/minikin/FontLanguage.h @@ -0,0 +1,89 @@ +/* + * 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. + */ + +#ifndef MINIKIN_FONT_LANGUAGE_H +#define MINIKIN_FONT_LANGUAGE_H + +#include +#include + +#include + +namespace android { + +// FontLanguage is a compact representation of a BCP 47 language tag. It +// does not capture all possible information, only what directly affects +// font rendering. +struct FontLanguage { +public: + // Default constructor creates the unsupported language. + FontLanguage() : mScript(0ul), mLanguage(0ul), mSubScriptBits(0ul) {} + + // Parse from string + FontLanguage(const char* buf, size_t length); + + bool operator==(const FontLanguage other) const { + return !isUnsupported() && isEqualScript(other) && isEqualLanguage(other); + } + + bool operator!=(const FontLanguage other) const { + return !(*this == other); + } + + bool isUnsupported() const { return mLanguage == 0ul; } + bool hasEmojiFlag() const { return mSubScriptBits & kEmojiFlag; } + + bool isEqualLanguage(const FontLanguage other) const { return mLanguage == other.mLanguage; } + bool isEqualScript(const FontLanguage other) const; + + // Returns true if this script supports the given script. For example, ja-Jpan supports Hira, + // ja-Hira doesn't support Jpan. + bool supportsHbScript(hb_script_t script) const; + + std::string getString() const; + + // 0 = no match, 1 = language matches + int match(const FontLanguage other) const; + + uint64_t getIdentifier() const { return (uint64_t)mScript << 32 | (uint64_t)mLanguage; } + +private: + // ISO 15924 compliant script code. The 4 chars script code are packed into a 32 bit integer. + uint32_t mScript; + + // ISO 639-1 or ISO 639-2 compliant language code. + // The two or three letter language code is packed into 32 bit integer. + // mLanguage = 0 means the FontLanguage is unsupported. + uint32_t mLanguage; + + // For faster comparing, use 7 bits for specific scripts. + static const uint8_t kEmojiFlag = 1u; + static const uint8_t kHanFlag = 1u << 1; + static const uint8_t kHangulFlag = 1u << 2; + static const uint8_t kHiraganaFlag = 1u << 3; + static const uint8_t kKatakanaFlag = 1u << 4; + static const uint8_t kSimplifiedChineseFlag = 1u << 5; + static const uint8_t kTraditionalChineseFlag = 1u << 6; + uint8_t mSubScriptBits; + + static uint8_t scriptToSubScriptBits(uint32_t script); +}; + +typedef std::vector FontLanguages; + +} // namespace android + +#endif // MINIKIN_FONT_LANGUAGE_H diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp index e1c2343dda..2d64998e7a 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp @@ -19,13 +19,92 @@ #include "FontLanguageListCache.h" #include +#include +#include #include "MinikinInternal.h" +#include "FontLanguage.h" namespace android { const uint32_t FontLanguageListCache::kEmptyListId; +// Returns the text length of output. +static size_t toLanguageTag(char* output, size_t outSize, const std::string& locale) { + output[0] = '\0'; + if (locale.empty()) { + return 0; + } + + size_t outLength = 0; + UErrorCode uErr = U_ZERO_ERROR; + outLength = uloc_canonicalize(locale.c_str(), output, outSize, &uErr); + if (U_FAILURE(uErr)) { + // unable to build a proper language identifier + ALOGD("uloc_canonicalize(\"%s\") failed: %s", locale.c_str(), u_errorName(uErr)); + output[0] = '\0'; + return 0; + } + + // Preserve "und" and "und-****" since uloc_addLikelySubtags changes "und" to "en-Latn-US". + if (strncmp(output, "und", 3) == 0 && + (outLength == 3 || (outLength == 8 && output[3] == '_'))) { + return outLength; + } + + char likelyChars[ULOC_FULLNAME_CAPACITY]; + uErr = U_ZERO_ERROR; + uloc_addLikelySubtags(output, likelyChars, ULOC_FULLNAME_CAPACITY, &uErr); + if (U_FAILURE(uErr)) { + // unable to build a proper language identifier + ALOGD("uloc_addLikelySubtags(\"%s\") failed: %s", output, u_errorName(uErr)); + output[0] = '\0'; + return 0; + } + + uErr = U_ZERO_ERROR; + outLength = uloc_toLanguageTag(likelyChars, output, outSize, FALSE, &uErr); + if (U_FAILURE(uErr)) { + // unable to build a proper language identifier + ALOGD("uloc_toLanguageTag(\"%s\") failed: %s", likelyChars, u_errorName(uErr)); + output[0] = '\0'; + return 0; + } +#ifdef VERBOSE_DEBUG + ALOGD("ICU normalized '%s' to '%s'", locale.c_str(), output); +#endif + return outLength; +} + +static FontLanguages constructFontLanguages(const std::string& input) { + FontLanguages result; + size_t currentIdx = 0; + size_t commaLoc = 0; + char langTag[ULOC_FULLNAME_CAPACITY]; + std::unordered_set seen; + std::string locale(input.size(), 0); + + while ((commaLoc = input.find_first_of(',', currentIdx)) != std::string::npos) { + locale.assign(input, currentIdx, commaLoc - currentIdx); + currentIdx = commaLoc + 1; + size_t length = toLanguageTag(langTag, ULOC_FULLNAME_CAPACITY, locale); + FontLanguage lang(langTag, length); + uint64_t identifier = lang.getIdentifier(); + if (!lang.isUnsupported() && seen.count(identifier) == 0) { + result.push_back(lang); + seen.insert(identifier); + } + } + locale.assign(input, currentIdx, input.size() - currentIdx); + size_t length = toLanguageTag(langTag, ULOC_FULLNAME_CAPACITY, locale); + FontLanguage lang(langTag, length); + uint64_t identifier = lang.getIdentifier(); + if (!lang.isUnsupported() && seen.count(identifier) == 0) { + result.push_back(lang); + } + return result; +} + // static uint32_t FontLanguageListCache::getId(const std::string& languages) { FontLanguageListCache* inst = FontLanguageListCache::getInstance(); @@ -37,7 +116,11 @@ uint32_t FontLanguageListCache::getId(const std::string& languages) { // Given language list is not in cache. Insert it and return newly assigned ID. const uint32_t nextId = inst->mLanguageLists.size(); - inst->mLanguageLists.push_back(FontLanguages(languages.c_str(), languages.size())); + FontLanguages fontLanguages = constructFontLanguages(languages); + if (fontLanguages.empty()) { + return kEmptyListId; + } + inst->mLanguageLists.push_back(fontLanguages); inst->mLanguageListLookupTable.insert(std::make_pair(languages, nextId)); return nextId; } @@ -56,8 +139,9 @@ FontLanguageListCache* FontLanguageListCache::getInstance() { if (instance == nullptr) { instance = new FontLanguageListCache(); - // Insert an empty language list for mapping empty language list to kEmptyListId. - instance->mLanguageLists.push_back(FontLanguages()); + // Insert an empty language list for mapping default language list to kEmptyListId. + // The default language list has only one FontLanguage and it is the unsupported language. + instance->mLanguageLists.push_back(FontLanguages({FontLanguage()})); instance->mLanguageListLookupTable.insert(std::make_pair("", kEmptyListId)); } return instance; diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.h b/engine/src/flutter/libs/minikin/FontLanguageListCache.h index 7d627b562e..c961882f0a 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.h +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.h @@ -20,6 +20,7 @@ #include #include +#include "FontLanguage.h" namespace android { diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index af5e6fe75a..2e206a20fc 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -34,6 +34,7 @@ #include #include +#include "FontLanguage.h" #include "FontLanguageListCache.h" #include "LayoutUtils.h" #include "HbFaceCache.h" @@ -746,9 +747,15 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t const FontLanguages& langList = FontLanguageListCache::getById(ctx->style.getLanguageListId()); if (langList.size() != 0) { - // TODO: use all languages in langList. - string lang = langList[0].getString(); - hb_buffer_set_language(buffer, hb_language_from_string(lang.c_str(), -1)); + const FontLanguage* hbLanguage = &langList[0]; + for (size_t i = 0; i < langList.size(); ++i) { + if (langList[i].supportsHbScript(script)) { + hbLanguage = &langList[i]; + break; + } + } + hb_buffer_set_language(buffer, + hb_language_from_string(hbLanguage->getString().c_str(), -1)); } hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); if (ctx->paint.hyphenEdit.hasHyphen() && srunend > srunstart) { diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 85d76afccb..cf9b704efa 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -16,7 +16,9 @@ #include +#include "FontLanguage.h" #include "FontTestUtils.h" +#include "ICUTestBase.h" #include "MinikinFontForTest.h" #include "UnicodeUtils.h" @@ -42,6 +44,8 @@ const char kColorEmojiFont[] = kTestFontDir "ColorEmojiFont.ttf"; const char kTextEmojiFont[] = kTestFontDir "TextEmojiFont.ttf"; const char kMixedEmojiFont[] = kTestFontDir "ColorTextMixedEmojiFont.ttf"; +typedef ICUTestBase FontCollectionItemizeTest; + // Utility function for calling itemize function. void itemize(FontCollection* collection, const char* str, FontStyle style, std::vector* result) { @@ -60,7 +64,7 @@ const std::string& getFontPath(const FontCollection::Run& run) { return ((MinikinFontForTest*)run.fakedFont.font)->fontPath(); } -TEST(FontCollectionItemizeTest, itemize_latin) { +TEST_F(FontCollectionItemizeTest, itemize_latin) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -130,7 +134,7 @@ TEST(FontCollectionItemizeTest, itemize_latin) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); } -TEST(FontCollectionItemizeTest, itemize_emoji) { +TEST_F(FontCollectionItemizeTest, itemize_emoji) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -191,7 +195,7 @@ TEST(FontCollectionItemizeTest, itemize_emoji) { EXPECT_FALSE(runs[1].fakedFont.fakery.isFakeItalic()); } -TEST(FontCollectionItemizeTest, itemize_non_latin) { +TEST_F(FontCollectionItemizeTest, itemize_non_latin) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -280,7 +284,7 @@ TEST(FontCollectionItemizeTest, itemize_non_latin) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); } -TEST(FontCollectionItemizeTest, itemize_mixed) { +TEST_F(FontCollectionItemizeTest, itemize_mixed) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -319,7 +323,7 @@ TEST(FontCollectionItemizeTest, itemize_mixed) { EXPECT_FALSE(runs[4].fakedFont.fakery.isFakeItalic()); } -TEST(FontCollectionItemizeTest, itemize_variationSelector) { +TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -458,7 +462,7 @@ TEST(FontCollectionItemizeTest, itemize_variationSelector) { EXPECT_EQ(kLatinFont, getFontPath(runs[0])); } -TEST(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { +TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -583,7 +587,7 @@ TEST(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontPath(runs[0])); } -TEST(FontCollectionItemizeTest, itemize_no_crash) { +TEST_F(FontCollectionItemizeTest, itemize_no_crash) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -607,7 +611,7 @@ TEST(FontCollectionItemizeTest, itemize_no_crash) { itemize(collection.get(), "U+FE00 U+302D U+E0100", FontStyle(), &runs); } -TEST(FontCollectionItemizeTest, itemize_fakery) { +TEST_F(FontCollectionItemizeTest, itemize_fakery) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -647,18 +651,18 @@ TEST(FontCollectionItemizeTest, itemize_fakery) { EXPECT_TRUE(runs[0].fakedFont.fakery.isFakeItalic()); } -TEST(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { +TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { // kVSTestFont supports U+717D U+FE02 but doesn't support U+717D. // kVSTestFont should be selected for U+717D U+FE02 even if it does not support the base code // point. const std::string kVSTestFont = kTestFontDir "VarioationSelectorTest-Regular.ttf"; std::vector families; - FontFamily* family1 = new FontFamily(FontLanguage(), android::VARIANT_DEFAULT); + FontFamily* family1 = new FontFamily(android::VARIANT_DEFAULT); family1->addFont(new MinikinFontForTest(kLatinFont)); families.push_back(family1); - FontFamily* family2 = new FontFamily(FontLanguage(), android::VARIANT_DEFAULT); + FontFamily* family2 = new FontFamily(android::VARIANT_DEFAULT); family2->addFont(new MinikinFontForTest(kVSTestFont)); families.push_back(family2); @@ -676,7 +680,7 @@ TEST(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { family2->Unref(); } -TEST(FontCollectionItemizeTest, itemize_emojiSelection) { +TEST_F(FontCollectionItemizeTest, itemize_emojiSelection) { std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); std::vector runs; @@ -748,7 +752,7 @@ TEST(FontCollectionItemizeTest, itemize_emojiSelection) { EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); } -TEST(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { +TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); std::vector runs; @@ -830,7 +834,7 @@ TEST(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { EXPECT_EQ(kMixedEmojiFont, getFontPath(runs[0])); } -TEST(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { +TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); std::vector runs; diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index fc44e6c636..ac7616fada 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -17,74 +17,261 @@ #include #include + +#include + #include "FontLanguageListCache.h" +#include "ICUTestBase.h" #include "MinikinFontForTest.h" #include "MinikinInternal.h" namespace android { -TEST(FontLanguagesTest, basicTests) { +typedef ICUTestBase FontLanguagesTest; +typedef ICUTestBase FontLanguageTest; + +static FontLanguages createFontLanguages(const std::string& input) { + uint32_t langId = FontLanguageListCache::getId(input); + return FontLanguageListCache::getById(langId); +} + +static FontLanguage createFontLanguage(const std::string& input) { + uint32_t langId = FontLanguageListCache::getId(input); + return FontLanguageListCache::getById(langId)[0]; +} + +TEST_F(FontLanguageTest, basicTests) { + FontLanguage defaultLang; + FontLanguage emptyLang("", 0); + FontLanguage english = createFontLanguage("en"); + FontLanguage french = createFontLanguage("fr"); + FontLanguage und = createFontLanguage("und"); + FontLanguage undQaae = createFontLanguage("und-Qaae"); + + EXPECT_EQ(english, english); + EXPECT_EQ(french, french); + + EXPECT_TRUE(defaultLang != defaultLang); + EXPECT_TRUE(emptyLang != emptyLang); + EXPECT_TRUE(defaultLang != emptyLang); + EXPECT_TRUE(defaultLang != und); + EXPECT_TRUE(emptyLang != und); + EXPECT_TRUE(english != defaultLang); + EXPECT_TRUE(english != emptyLang); + EXPECT_TRUE(english != french); + EXPECT_TRUE(english != undQaae); + EXPECT_TRUE(und != undQaae); + EXPECT_TRUE(english != und); + + EXPECT_TRUE(defaultLang.isUnsupported()); + EXPECT_TRUE(emptyLang.isUnsupported()); + + EXPECT_FALSE(english.isUnsupported()); + EXPECT_FALSE(french.isUnsupported()); + EXPECT_FALSE(und.isUnsupported()); + EXPECT_FALSE(undQaae.isUnsupported()); +} + +TEST_F(FontLanguageTest, getStringTest) { + EXPECT_EQ("en-Latn", createFontLanguage("en").getString()); + EXPECT_EQ("en-Latn", createFontLanguage("en-Latn").getString()); + + // Capitalized language code or lowercased script should be normalized. + EXPECT_EQ("en-Latn", createFontLanguage("EN-LATN").getString()); + EXPECT_EQ("en-Latn", createFontLanguage("EN-latn").getString()); + EXPECT_EQ("en-Latn", createFontLanguage("en-latn").getString()); + + // Invalid script should be kept. + EXPECT_EQ("en-Xyzt", createFontLanguage("en-xyzt").getString()); + + EXPECT_EQ("en-Latn", createFontLanguage("en-Latn-US").getString()); + EXPECT_EQ("ja-Jpan", createFontLanguage("ja").getString()); + EXPECT_EQ("und", createFontLanguage("und").getString()); + EXPECT_EQ("und", createFontLanguage("UND").getString()); + EXPECT_EQ("und", createFontLanguage("Und").getString()); + EXPECT_EQ("und-Qaae", createFontLanguage("und-Qaae").getString()); + EXPECT_EQ("und-Qaae", createFontLanguage("Und-QAAE").getString()); + EXPECT_EQ("und-Qaae", createFontLanguage("Und-qaae").getString()); + + EXPECT_EQ("de-Latn", createFontLanguage("de-1901").getString()); + + // This is not a necessary desired behavior, just known behavior. + EXPECT_EQ("en-Latn", createFontLanguage("und-Abcdefgh").getString()); +} + +TEST_F(FontLanguageTest, ScriptEqualTest) { + EXPECT_TRUE(createFontLanguage("en").isEqualScript(createFontLanguage("en"))); + EXPECT_TRUE(createFontLanguage("en-Latn").isEqualScript(createFontLanguage("en"))); + EXPECT_TRUE(createFontLanguage("jp-Latn").isEqualScript(createFontLanguage("en-Latn"))); + EXPECT_TRUE(createFontLanguage("en-Jpan").isEqualScript(createFontLanguage("en-Jpan"))); + + EXPECT_FALSE(createFontLanguage("en-Jpan").isEqualScript(createFontLanguage("en-Hira"))); + EXPECT_FALSE(createFontLanguage("en-Jpan").isEqualScript(createFontLanguage("en-Hani"))); +} + +TEST_F(FontLanguageTest, ScriptMatchTest) { + const bool SUPPORTED = true; + const bool NOT_SUPPORTED = false; + + struct TestCase { + const std::string baseScript; + const std::string requestedScript; + bool isSupported; + } testCases[] = { + // Same scripts + { "en-Latn", "Latn", SUPPORTED }, + { "ja-Jpan", "Jpan", SUPPORTED }, + { "ja-Hira", "Hira", SUPPORTED }, + { "ja-Kana", "Kana", SUPPORTED }, + { "ja-Hrkt", "Hrkt", SUPPORTED }, + { "zh-Hans", "Hans", SUPPORTED }, + { "zh-Hant", "Hant", SUPPORTED }, + { "zh-Hani", "Hani", SUPPORTED }, + { "ko-Kore", "Kore", SUPPORTED }, + { "ko-Hang", "Hang", SUPPORTED }, + + // Japanese supports Hiragana, Katakanara, etc. + { "ja-Jpan", "Hira", SUPPORTED }, + { "ja-Jpan", "Kana", SUPPORTED }, + { "ja-Jpan", "Hrkt", SUPPORTED }, + { "ja-Hrkt", "Hira", SUPPORTED }, + { "ja-Hrkt", "Kana", SUPPORTED }, + + // Chinese supports Han. + { "zh-Hans", "Hani", SUPPORTED }, + { "zh-Hant", "Hani", SUPPORTED }, + + // Korean supports Hangul. + { "ko-Kore", "Hang", SUPPORTED }, + + // Different scripts + { "ja-Jpan", "Latn", NOT_SUPPORTED }, + { "en-Latn", "Jpan", NOT_SUPPORTED }, + { "ja-Jpan", "Hant", NOT_SUPPORTED }, + { "zh-Hant", "Jpan", NOT_SUPPORTED }, + { "ja-Jpan", "Hans", NOT_SUPPORTED }, + { "zh-Hans", "Jpan", NOT_SUPPORTED }, + { "ja-Jpan", "Kore", NOT_SUPPORTED }, + { "ko-Kore", "Jpan", NOT_SUPPORTED }, + { "zh-Hans", "Hant", NOT_SUPPORTED }, + { "zh-Hant", "Hans", NOT_SUPPORTED }, + { "zh-Hans", "Kore", NOT_SUPPORTED }, + { "ko-Kore", "Hans", NOT_SUPPORTED }, + { "zh-Hant", "Kore", NOT_SUPPORTED }, + { "ko-Kore", "Hant", NOT_SUPPORTED }, + + // Hiragana doesn't support Japanese, etc. + { "ja-Hira", "Jpan", NOT_SUPPORTED }, + { "ja-Kana", "Jpan", NOT_SUPPORTED }, + { "ja-Hrkt", "Jpan", NOT_SUPPORTED }, + { "ja-Hani", "Jpan", NOT_SUPPORTED }, + { "ja-Hira", "Hrkt", NOT_SUPPORTED }, + { "ja-Kana", "Hrkt", NOT_SUPPORTED }, + { "ja-Hani", "Hrkt", NOT_SUPPORTED }, + { "ja-Hani", "Hira", NOT_SUPPORTED }, + { "ja-Hani", "Kana", NOT_SUPPORTED }, + + // Kanji doesn't support Chinese, etc. + { "zh-Hani", "Hant", NOT_SUPPORTED }, + { "zh-Hani", "Hans", NOT_SUPPORTED }, + + // Hangul doesn't support Korean, etc. + { "ko-Hang", "Kore", NOT_SUPPORTED }, + { "ko-Hani", "Kore", NOT_SUPPORTED }, + { "ko-Hani", "Hang", NOT_SUPPORTED }, + { "ko-Hang", "Hani", NOT_SUPPORTED }, + }; + + for (auto testCase : testCases) { + hb_script_t script = hb_script_from_iso15924_tag( + HB_TAG(testCase.requestedScript[0], testCase.requestedScript[1], + testCase.requestedScript[2], testCase.requestedScript[3])); + if (testCase.isSupported) { + EXPECT_TRUE( + createFontLanguage(testCase.baseScript).supportsHbScript(script)) + << testCase.baseScript << " should support " << testCase.requestedScript; + } else { + EXPECT_FALSE( + createFontLanguage(testCase.baseScript).supportsHbScript(script)) + << testCase.baseScript << " shouldn't support " << testCase.requestedScript; + } + } +} + +TEST_F(FontLanguagesTest, basicTests) { FontLanguages emptyLangs; EXPECT_EQ(0u, emptyLangs.size()); - FontLanguage english("en", 2); - FontLanguages singletonLangs("en", 2); + FontLanguage english = createFontLanguage("en"); + FontLanguages singletonLangs = createFontLanguages("en"); EXPECT_EQ(1u, singletonLangs.size()); EXPECT_EQ(english, singletonLangs[0]); - FontLanguage french("fr", 2); - FontLanguages twoLangs("en,fr", 5); + FontLanguage french = createFontLanguage("fr"); + FontLanguages twoLangs = createFontLanguages("en,fr"); EXPECT_EQ(2u, twoLangs.size()); EXPECT_EQ(english, twoLangs[0]); EXPECT_EQ(french, twoLangs[1]); } -TEST(FontLanguagesTest, unsupportedLanguageTests) { - FontLanguage unsupportedLang("x-example", 9); +TEST_F(FontLanguagesTest, unsupportedLanguageTests) { + FontLanguage unsupportedLang = createFontLanguage("abcd"); ASSERT_TRUE(unsupportedLang.isUnsupported()); - FontLanguages oneUnsupported("x-example", 9); + FontLanguages oneUnsupported = createFontLanguages("abcd-example"); EXPECT_EQ(1u, oneUnsupported.size()); EXPECT_TRUE(oneUnsupported[0].isUnsupported()); - FontLanguages twoUnsupporteds("x-example,x-example", 19); + FontLanguages twoUnsupporteds = createFontLanguages("abcd-example,abcd-example"); EXPECT_EQ(1u, twoUnsupporteds.size()); EXPECT_TRUE(twoUnsupporteds[0].isUnsupported()); - FontLanguage english("en", 2); - FontLanguages firstUnsupported("x-example,en", 12); + FontLanguage english = createFontLanguage("en"); + FontLanguages firstUnsupported = createFontLanguages("abcd-example,en"); EXPECT_EQ(1u, firstUnsupported.size()); EXPECT_EQ(english, firstUnsupported[0]); - FontLanguages lastUnsupported("en,x-example", 12); + FontLanguages lastUnsupported = createFontLanguages("en,abcd-example"); EXPECT_EQ(1u, lastUnsupported.size()); EXPECT_EQ(english, lastUnsupported[0]); } -TEST(FontLanguagesTest, repeatedLanguageTests) { - FontLanguage english("en", 2); - FontLanguage englishInLatn("en-Latn", 2); +TEST_F(FontLanguagesTest, repeatedLanguageTests) { + FontLanguage english = createFontLanguage("en"); + FontLanguage french = createFontLanguage("fr"); + FontLanguage englishInLatn = createFontLanguage("en-Latn"); ASSERT_TRUE(english == englishInLatn); - FontLanguages langs("en,en-Latn", 10); + FontLanguages langs = createFontLanguages("en,en-Latn"); EXPECT_EQ(1u, langs.size()); EXPECT_EQ(english, langs[0]); + + // Country codes are ignored. + FontLanguages fr = createFontLanguages("fr,fr-CA,fr-FR"); + EXPECT_EQ(1u, fr.size()); + EXPECT_EQ(french, fr[0]); + + // The order should be kept. + langs = createFontLanguages("en,fr,en-Latn"); + EXPECT_EQ(2u, langs.size()); + EXPECT_EQ(english, langs[0]); + EXPECT_EQ(french, langs[1]); } -TEST(FontLanguagesTest, undEmojiTests) { - FontLanguage emoji("und-Qaae", 8); +TEST_F(FontLanguagesTest, undEmojiTests) { + FontLanguage emoji = createFontLanguage("und-Qaae"); EXPECT_TRUE(emoji.hasEmojiFlag()); - FontLanguage und("und", 3); + FontLanguage und = createFontLanguage("und"); EXPECT_FALSE(und.hasEmojiFlag()); EXPECT_FALSE(emoji == und); - FontLanguage undExample("und-example", 10); + FontLanguage undExample = createFontLanguage("und-example"); EXPECT_FALSE(undExample.hasEmojiFlag()); EXPECT_FALSE(emoji == undExample); } -TEST(FontLanguagesTest, registerLanguageListTest) { +TEST_F(FontLanguagesTest, registerLanguageListTest) { EXPECT_EQ(0UL, FontStyle::registerLanguageList("")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en")); EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); @@ -122,9 +309,10 @@ TEST(FontLanguagesTest, registerLanguageListTest) { // U+717D U+E0103 (VS20) const char kVsTestFont[] = kTestFontDir "VarioationSelectorTest-Regular.ttf"; -class FontFamilyTest : public testing::Test { +class FontFamilyTest : public ICUTestBase { public: virtual void SetUp() override { + ICUTestBase::SetUp(); if (access(kVsTestFont, R_OK) != 0) { FAIL() << "Unable to read " << kVsTestFont << ". " << "Please prepare the test data directory. " diff --git a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp index 29757fedce..f83988c1f5 100644 --- a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp +++ b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp @@ -17,11 +17,15 @@ #include #include + #include "FontLanguageListCache.h" +#include "ICUTestBase.h" namespace android { -TEST(FontLanguageListCacheTest, getId) { +typedef ICUTestBase FontLanguageListCacheTest; + +TEST_F(FontLanguageListCacheTest, getId) { EXPECT_EQ(0UL, FontLanguageListCache::getId("")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en")); EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); @@ -42,11 +46,15 @@ TEST(FontLanguageListCacheTest, getId) { FontLanguageListCache::getId("en,zh-Hant")); } -TEST(FontLanguageListCacheTest, getById) { - FontLanguage english("en", 2); - FontLanguage japanese("jp", 2); +TEST_F(FontLanguageListCacheTest, getById) { + uint32_t enLangId = FontLanguageListCache::getId("en"); + uint32_t jpLangId = FontLanguageListCache::getId("jp"); + FontLanguage english = FontLanguageListCache::getById(enLangId)[0]; + FontLanguage japanese = FontLanguageListCache::getById(jpLangId)[0]; - EXPECT_EQ(0UL, FontLanguageListCache::getById(0).size()); + FontLanguages defLangs = FontLanguageListCache::getById(0); + EXPECT_EQ(1UL, defLangs.size()); + EXPECT_TRUE(defLangs[0].isUnsupported()); FontLanguages langs = FontLanguageListCache::getById(FontLanguageListCache::getId("en")); ASSERT_EQ(1UL, langs.size()); diff --git a/engine/src/flutter/tests/FontTestUtils.cpp b/engine/src/flutter/tests/FontTestUtils.cpp index 8e1d184adc..98dab5121b 100644 --- a/engine/src/flutter/tests/FontTestUtils.cpp +++ b/engine/src/flutter/tests/FontTestUtils.cpp @@ -20,6 +20,8 @@ #include #include + +#include "FontLanguage.h" #include "MinikinFontForTest.h" std::unique_ptr getFontCollection( @@ -44,9 +46,10 @@ std::unique_ptr getFontCollection( } xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); + uint32_t langId = android::FontStyle::registerLanguageList( + std::string((const char*)lang, xmlStrlen(lang))); - android::FontFamily* family = new android::FontFamily( - android::FontLanguage((const char*)lang, xmlStrlen(lang)), variant); + android::FontFamily* family = new android::FontFamily(langId, variant); for (xmlNode* fontNode = familyNode->children; fontNode; fontNode = fontNode->next) { if (xmlStrcmp(fontNode->name, (const xmlChar*)"font") != 0) { diff --git a/engine/src/flutter/tests/ICUTestBase.h b/engine/src/flutter/tests/ICUTestBase.h new file mode 100644 index 0000000000..3bcfaf3694 --- /dev/null +++ b/engine/src/flutter/tests/ICUTestBase.h @@ -0,0 +1,52 @@ +/* + * 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. + */ + +#ifndef MINIKIN_TEST_ICU_TEST_BASE_H +#define MINIKIN_TEST_ICU_TEST_BASE_H + +#include +#include +#include + +// low level file access for mapping ICU data +#include +#include +#include + +class ICUTestBase : public testing::Test { +protected: + virtual void SetUp() override { + const char* fn = "/system/usr/icu/" U_ICUDATA_NAME ".dat"; + int fd = open(fn, O_RDONLY); + ASSERT_NE(-1, fd); + struct stat sb; + ASSERT_EQ(0, fstat(fd, &sb)); + void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd, 0); + + UErrorCode errorCode = U_ZERO_ERROR; + udata_setCommonData(data, &errorCode); + ASSERT_TRUE(U_SUCCESS(errorCode)); + u_init(&errorCode); + ASSERT_TRUE(U_SUCCESS(errorCode)); + } + + virtual void TearDown() override { + u_cleanup(); + } +}; + + +#endif // MINIKIN_TEST_ICU_TEST_BASE_H From 9d30380ce99c14af63f3b5ece14603ea0125d762 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 22 Dec 2015 13:22:12 +0900 Subject: [PATCH 136/364] Replace Qaae script with Zsye The emoji variant script "Zsye" is registered in ISO 15924. Bug: 26226285 Change-Id: Ibc2bc740d57c48f99b6f66b1ad7595bfa8c3cff4 --- engine/src/flutter/libs/minikin/FontLanguage.cpp | 2 +- engine/src/flutter/tests/FontFamilyTest.cpp | 16 ++++++++-------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontLanguage.cpp b/engine/src/flutter/libs/minikin/FontLanguage.cpp index 3c12e06c6f..43190d7a7d 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguage.cpp @@ -87,7 +87,7 @@ uint8_t FontLanguage::scriptToSubScriptBits(uint32_t script) { case SCRIPT_TAG('K', 'o', 'r', 'e'): subScriptBits = kHanFlag | kHangulFlag; break; - case SCRIPT_TAG('Q', 'a', 'a', 'e'): + case SCRIPT_TAG('Z', 's', 'y', 'e'): subScriptBits = kEmojiFlag; break; } diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index ac7616fada..5b4b28b316 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -46,7 +46,7 @@ TEST_F(FontLanguageTest, basicTests) { FontLanguage english = createFontLanguage("en"); FontLanguage french = createFontLanguage("fr"); FontLanguage und = createFontLanguage("und"); - FontLanguage undQaae = createFontLanguage("und-Qaae"); + FontLanguage undZsye = createFontLanguage("und-Zsye"); EXPECT_EQ(english, english); EXPECT_EQ(french, french); @@ -59,8 +59,8 @@ TEST_F(FontLanguageTest, basicTests) { EXPECT_TRUE(english != defaultLang); EXPECT_TRUE(english != emptyLang); EXPECT_TRUE(english != french); - EXPECT_TRUE(english != undQaae); - EXPECT_TRUE(und != undQaae); + EXPECT_TRUE(english != undZsye); + EXPECT_TRUE(und != undZsye); EXPECT_TRUE(english != und); EXPECT_TRUE(defaultLang.isUnsupported()); @@ -69,7 +69,7 @@ TEST_F(FontLanguageTest, basicTests) { EXPECT_FALSE(english.isUnsupported()); EXPECT_FALSE(french.isUnsupported()); EXPECT_FALSE(und.isUnsupported()); - EXPECT_FALSE(undQaae.isUnsupported()); + EXPECT_FALSE(undZsye.isUnsupported()); } TEST_F(FontLanguageTest, getStringTest) { @@ -89,9 +89,9 @@ TEST_F(FontLanguageTest, getStringTest) { EXPECT_EQ("und", createFontLanguage("und").getString()); EXPECT_EQ("und", createFontLanguage("UND").getString()); EXPECT_EQ("und", createFontLanguage("Und").getString()); - EXPECT_EQ("und-Qaae", createFontLanguage("und-Qaae").getString()); - EXPECT_EQ("und-Qaae", createFontLanguage("Und-QAAE").getString()); - EXPECT_EQ("und-Qaae", createFontLanguage("Und-qaae").getString()); + EXPECT_EQ("und-Zsye", createFontLanguage("und-Zsye").getString()); + EXPECT_EQ("und-Zsye", createFontLanguage("Und-ZSYE").getString()); + EXPECT_EQ("und-Zsye", createFontLanguage("Und-zsye").getString()); EXPECT_EQ("de-Latn", createFontLanguage("de-1901").getString()); @@ -259,7 +259,7 @@ TEST_F(FontLanguagesTest, repeatedLanguageTests) { } TEST_F(FontLanguagesTest, undEmojiTests) { - FontLanguage emoji = createFontLanguage("und-Qaae"); + FontLanguage emoji = createFontLanguage("und-Zsye"); EXPECT_TRUE(emoji.hasEmojiFlag()); FontLanguage und = createFontLanguage("und"); From 147ce0acb9ccb2c7594e47512ac0f5d68eafb580 Mon Sep 17 00:00:00 2001 From: Dan Austin Date: Tue, 5 Jan 2016 17:36:31 -0800 Subject: [PATCH 137/364] Enable integer sanitization in libminikin. Enable signed and unsigned integer sanitization in libminikin. Bug: 25884483 Change-Id: I53abf6affea8e2bb3a5abd381a9f19003a306b36 --- engine/src/flutter/libs/minikin/Android.mk | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index c3e70db267..e51e4668f9 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -50,7 +50,8 @@ LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) - +LOCAL_CLANG := true +LOCAL_SANITIZE := signed-integer-overflow unsigned-integer-overflow include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) @@ -61,6 +62,8 @@ LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) +LOCAL_CLANG := true +LOCAL_SANITIZE := signed-integer-overflow unsigned-integer-overflow include $(BUILD_STATIC_LIBRARY) @@ -73,6 +76,8 @@ LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := liblog libicuuc-host +LOCAL_CLANG := true +LOCAL_SANITIZE := signed-integer-overflow unsigned-integer-overflow LOCAL_SRC_FILES := Hyphenator.cpp From 5f7e7e239e73a3d3ec796660d3f10afd435c0858 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 5 Jan 2016 15:20:39 +0900 Subject: [PATCH 138/364] Fix race condition in Paint.hasGlyph() The caller of FontFamily::hasVariationSelector needs to acquire the lock before calling it, but FontCollection::hasVariationSelector didn't acquire the lock. This caused a race condition. This CL fixes this race condition. Also, it turned out that assertMinikinLocked didn't assert even on eng or userdebug device. This CL enables assertion on eng and userdebug device since this assertion must be treated as bug. BUG: 26323806 Change-Id: I9c4b1e1f09c6793e387fbdb8bb654cc0a13c65d5 --- engine/src/flutter/libs/minikin/Android.mk | 13 ++++++++++--- engine/src/flutter/libs/minikin/FontCollection.cpp | 1 + engine/src/flutter/libs/minikin/MinikinInternal.cpp | 4 +++- 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 4c945a60c9..b2e1dc8293 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -47,11 +47,18 @@ minikin_shared_libraries := \ libicuuc \ libutils +ifneq (,$(filter userdebug eng, $(TARGET_BUILD_VARIANT))) +# Enable race detection on eng and userdebug build. +enable_race_detection := -DENABLE_RACE_DETECTION +else +enable_race_detection := +endif + LOCAL_MODULE := libminikin LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra +LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) include $(BUILD_SHARED_LIBRARY) @@ -63,7 +70,7 @@ LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra +LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) include $(BUILD_STATIC_LIBRARY) @@ -76,7 +83,7 @@ LOCAL_MODULE := libminikin_host LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra +LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) LOCAL_SHARED_LIBRARIES := liblog libicuuc-host LOCAL_SRC_FILES := Hyphenator.cpp diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index bba2ef9535..529b5c03a3 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -223,6 +223,7 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, // Currently mRanges can not be used here since it isn't aware of the variation sequence. // TODO: Use mRanges for narrowing down the search range. for (size_t i = 0; i < mFamilies.size(); i++) { + AutoMutex _l(gMinikinLock); if (mFamilies[i]->hasVariationSelector(baseCodepoint, variationSelector)) { return true; } diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 5a21ef9862..c2aa01ac19 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -25,7 +25,9 @@ namespace android { Mutex gMinikinLock; void assertMinikinLocked() { - LOG_FATAL_IF(gMinikinLock.tryLock() == 0); +#ifdef ENABLE_RACE_DETECTION + LOG_ALWAYS_FATAL_IF(gMinikinLock.tryLock() == 0); +#endif } } From 02345a5e8f47faeed80e62730874194575a0dc46 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Wed, 6 Jan 2016 22:49:33 +0900 Subject: [PATCH 139/364] Fix lock assertion failures in unit test. The assertion for the lock state has now activated by I9c4b1e1f09c6793e387fbdb8bb654cc0a13c65d5. This CL fixes the assertion failure in the unit tests by acquiring lock before calling the functions. Change-Id: I6a6afefb4de01e8610c2abfe6c779afa9442cc67 --- engine/src/flutter/tests/FontCollectionItemizeTest.cpp | 4 ++++ engine/src/flutter/tests/FontFamilyTest.cpp | 2 ++ engine/src/flutter/tests/FontLanguageListCacheTest.cpp | 6 +++++- 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index cf9b704efa..57409a5e62 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -20,12 +20,15 @@ #include "FontTestUtils.h" #include "ICUTestBase.h" #include "MinikinFontForTest.h" +#include "MinikinInternal.h" #include "UnicodeUtils.h" +using android::AutoMutex; using android::FontCollection; using android::FontFamily; using android::FontLanguage; using android::FontStyle; +using android::gMinikinLock; const char kItemizeFontXml[] = kTestFontDir "itemize.xml"; const char kEmojiFont[] = kTestFontDir "Emoji.ttf"; @@ -55,6 +58,7 @@ void itemize(FontCollection* collection, const char* str, FontStyle style, result->clear(); ParseUnicode(buf, BUF_SIZE, str, &len, NULL); + AutoMutex _l(gMinikinLock); collection->itemize(buf, len, style, result); } diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index 5b4b28b316..6b32689081 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -31,11 +31,13 @@ typedef ICUTestBase FontLanguagesTest; typedef ICUTestBase FontLanguageTest; static FontLanguages createFontLanguages(const std::string& input) { + AutoMutex _l(gMinikinLock); uint32_t langId = FontLanguageListCache::getId(input); return FontLanguageListCache::getById(langId); } static FontLanguage createFontLanguage(const std::string& input) { + AutoMutex _l(gMinikinLock); uint32_t langId = FontLanguageListCache::getId(input); return FontLanguageListCache::getById(langId)[0]; } diff --git a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp index f83988c1f5..fbbd9376f0 100644 --- a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp +++ b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp @@ -20,17 +20,20 @@ #include "FontLanguageListCache.h" #include "ICUTestBase.h" +#include "MinikinInternal.h" namespace android { typedef ICUTestBase FontLanguageListCacheTest; TEST_F(FontLanguageListCacheTest, getId) { - EXPECT_EQ(0UL, FontLanguageListCache::getId("")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en")); EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en,zh-Hans")); + AutoMutex _l(gMinikinLock); + EXPECT_EQ(0UL, FontLanguageListCache::getId("")); + EXPECT_EQ(FontLanguageListCache::getId("en"), FontLanguageListCache::getId("en")); EXPECT_NE(FontLanguageListCache::getId("en"), FontLanguageListCache::getId("jp")); @@ -47,6 +50,7 @@ TEST_F(FontLanguageListCacheTest, getId) { } TEST_F(FontLanguageListCacheTest, getById) { + AutoMutex _l(gMinikinLock); uint32_t enLangId = FontLanguageListCache::getId("en"); uint32_t jpLangId = FontLanguageListCache::getId("jp"); FontLanguage english = FontLanguageListCache::getById(enLangId)[0]; From 2ffc28610290d221109105ba17969db83b317ca1 Mon Sep 17 00:00:00 2001 From: Dan Austin Date: Wed, 6 Jan 2016 18:31:38 +0000 Subject: [PATCH 140/364] Revert "Enable integer sanitization in libminikin." This reverts commit 147ce0acb9ccb2c7594e47512ac0f5d68eafb580. Change-Id: Iecd1f61a5fdf5955d871a920cb243553857d46ff --- engine/src/flutter/libs/minikin/Android.mk | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index e51e4668f9..c3e70db267 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -50,8 +50,7 @@ LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) -LOCAL_CLANG := true -LOCAL_SANITIZE := signed-integer-overflow unsigned-integer-overflow + include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) @@ -62,8 +61,6 @@ LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) -LOCAL_CLANG := true -LOCAL_SANITIZE := signed-integer-overflow unsigned-integer-overflow include $(BUILD_STATIC_LIBRARY) @@ -76,8 +73,6 @@ LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := liblog libicuuc-host -LOCAL_CLANG := true -LOCAL_SANITIZE := signed-integer-overflow unsigned-integer-overflow LOCAL_SRC_FILES := Hyphenator.cpp From da13d5e835bf4657246e2410dcf29c0b4a61887b Mon Sep 17 00:00:00 2001 From: Dan Austin Date: Wed, 6 Jan 2016 12:30:12 -0800 Subject: [PATCH 141/364] Enable integer sanitization in libminikin Enable signed and unsigned integer sanitization in libminikin. Bug: 25884483 Change-Id: I98905827174d16138d20bb443fe2e1d7228ea1a3 --- engine/src/flutter/libs/minikin/Android.mk | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index c3e70db267..428f49b495 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -50,6 +50,8 @@ LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) +LOCAL_CLANG := true +LOCAL_SANITIZE := signed-integer-overflow unsigned-integer-overflow include $(BUILD_SHARED_LIBRARY) @@ -61,6 +63,8 @@ LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) +LOCAL_CLANG := true +LOCAL_SANITIZE := signed-integer-overflow unsigned-integer-overflow include $(BUILD_STATIC_LIBRARY) From 251f4772fb6996b5b8555fa94dd67f97a0377650 Mon Sep 17 00:00:00 2001 From: Andreas Gampe Date: Wed, 6 Jan 2016 20:28:52 -0800 Subject: [PATCH 142/364] Minikin: Disable sanitizer on x86 Disable unsigned-integer-overflow sanitizer on x86, as it crashes. Bug: 25884483 Bug: 26432628 Change-Id: Ia658ed56a6c81660a36edf71f7116118056aa917 --- engine/src/flutter/libs/minikin/Android.mk | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 428f49b495..f91a4a80d3 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -51,7 +51,11 @@ LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) LOCAL_CLANG := true -LOCAL_SANITIZE := signed-integer-overflow unsigned-integer-overflow +LOCAL_SANITIZE := signed-integer-overflow +# b/26432628. +ifeq ($(filter x86%,$(TARGET_ARCH)),) + LOCAL_SANITIZE += unsigned-integer-overflow +endif include $(BUILD_SHARED_LIBRARY) @@ -64,7 +68,11 @@ LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) LOCAL_CLANG := true -LOCAL_SANITIZE := signed-integer-overflow unsigned-integer-overflow +LOCAL_SANITIZE := signed-integer-overflow +# b/26432628. +ifeq ($(filter x86%,$(TARGET_ARCH)),) + LOCAL_SANITIZE += unsigned-integer-overflow +endif include $(BUILD_STATIC_LIBRARY) From 116708d9a3c237490fc6642a38598bf83c8e3d58 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 6 Jan 2016 14:31:23 -0800 Subject: [PATCH 143/364] Reject fonts with invalid ranges in cmap A corrupt or malicious font may have a negative size in its cmap range, which in turn could lead to memory corruption. This patch detects the case and rejects the font, and also includes an assertion in the sparse bit set implementation if we missed any such case. External issue: https://code.google.com/p/android/issues/detail?id=192618 Bug: 26413177 Change-Id: Icc0c80e4ef389abba0964495b89aa0fae3e9f4b2 --- .../src/flutter/libs/minikin/CmapCoverage.cpp | 41 +++++++++++-------- .../src/flutter/libs/minikin/SparseBitSet.cpp | 2 + 2 files changed, 27 insertions(+), 16 deletions(-) diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index 64310006fd..9f3447e62a 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -49,7 +49,7 @@ static void addRange(vector &coverage, uint32_t start, uint32_t end) { } } -// Get the coverage information out of a Format 12 subtable, storing it in the coverage vector +// Get the coverage information out of a Format 4 subtable, storing it in the coverage vector static bool getCoverageFormat4(vector& coverage, const uint8_t* data, size_t size) { const size_t kSegCountOffset = 6; const size_t kEndCountOffset = 14; @@ -63,29 +63,33 @@ static bool getCoverageFormat4(vector& coverage, const uint8_t* data, return false; } for (size_t i = 0; i < segCount; i++) { - int end = readU16(data, kEndCountOffset + 2 * i); - int start = readU16(data, kHeaderSize + 2 * (segCount + i)); - int rangeOffset = readU16(data, kHeaderSize + 2 * (3 * segCount + i)); + uint32_t end = readU16(data, kEndCountOffset + 2 * i); + uint32_t start = readU16(data, kHeaderSize + 2 * (segCount + i)); + if (end < start) { + // invalid segment range: size must be positive + return false; + } + uint32_t rangeOffset = readU16(data, kHeaderSize + 2 * (3 * segCount + i)); if (rangeOffset == 0) { - int delta = readU16(data, kHeaderSize + 2 * (2 * segCount + i)); + uint32_t delta = readU16(data, kHeaderSize + 2 * (2 * segCount + i)); if (((end + delta) & 0xffff) > end - start) { addRange(coverage, start, end + 1); } else { - for (int j = start; j < end + 1; j++) { + for (uint32_t j = start; j < end + 1; j++) { if (((j + delta) & 0xffff) != 0) { addRange(coverage, j, j + 1); } } } } else { - for (int j = start; j < end + 1; j++) { + for (uint32_t j = start; j < end + 1; j++) { uint32_t actualRangeOffset = kHeaderSize + 6 * segCount + rangeOffset + (i + j - start) * 2; if (actualRangeOffset + 2 > size) { // invalid rangeOffset is considered a "warning" by OpenType Sanitizer continue; } - int glyphId = readU16(data, actualRangeOffset); + uint32_t glyphId = readU16(data, actualRangeOffset); if (glyphId != 0) { addRange(coverage, j, j + 1); } @@ -115,6 +119,10 @@ static bool getCoverageFormat12(vector& coverage, const uint8_t* data, uint32_t groupOffset = kFirstGroupOffset + i * kGroupSize; uint32_t start = readU32(data, groupOffset + kStartCharCodeOffset); uint32_t end = readU32(data, groupOffset + kEndCharCodeOffset); + if (end < start) { + // invalid group range: size must be positive + return false; + } addRange(coverage, start, end + 1); // file is inclusive, vector is exclusive } return true; @@ -128,18 +136,19 @@ bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, const size_t kPlatformIdOffset = 0; const size_t kEncodingIdOffset = 2; const size_t kOffsetOffset = 4; - const int kMicrosoftPlatformId = 3; - const int kUnicodeBmpEncodingId = 1; - const int kUnicodeUcs4EncodingId = 10; + const uint16_t kMicrosoftPlatformId = 3; + const uint16_t kUnicodeBmpEncodingId = 1; + const uint16_t kUnicodeUcs4EncodingId = 10; + const uint32_t kNoTable = UINT32_MAX; if (kHeaderSize > cmap_size) { return false; } - int numTables = readU16(cmap_data, kNumTablesOffset); + uint32_t numTables = readU16(cmap_data, kNumTablesOffset); if (kHeaderSize + numTables * kTableSize > cmap_size) { return false; } - int bestTable = -1; - for (int i = 0; i < numTables; i++) { + uint32_t bestTable = kNoTable; + for (uint32_t i = 0; i < numTables; i++) { uint16_t platformId = readU16(cmap_data, kHeaderSize + i * kTableSize + kPlatformIdOffset); uint16_t encodingId = readU16(cmap_data, kHeaderSize + i * kTableSize + kEncodingIdOffset); if (platformId == kMicrosoftPlatformId && encodingId == kUnicodeUcs4EncodingId) { @@ -152,11 +161,11 @@ bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, #ifdef VERBOSE_DEBUG ALOGD("best table = %d\n", bestTable); #endif - if (bestTable < 0) { + if (bestTable == kNoTable) { return false; } uint32_t offset = readU32(cmap_data, kHeaderSize + bestTable * kTableSize + kOffsetOffset); - if (offset + 2 > cmap_size) { + if (offset > cmap_size - 2) { return false; } uint16_t format = readU16(cmap_data, offset); diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp index 9d1fd308bc..de0791445c 100644 --- a/engine/src/flutter/libs/minikin/SparseBitSet.cpp +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -14,6 +14,7 @@ * limitations under the License. */ +#include #include #include #include @@ -71,6 +72,7 @@ void SparseBitSet::initFromRanges(const uint32_t* ranges, size_t nRanges) { for (size_t i = 0; i < nRanges; i++) { uint32_t start = ranges[i * 2]; uint32_t end = ranges[i * 2 + 1]; + LOG_ALWAYS_FATAL_IF(end < start); // make sure range size is nonnegative uint32_t startPage = start >> kLogValuesPerPage; uint32_t endPage = (end - 1) >> kLogValuesPerPage; if (startPage >= nonzeroPageEnd) { From f5d2fa97bbdbf5075e293fb641cd2e5dbaa29cfa Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 6 Jan 2016 14:31:23 -0800 Subject: [PATCH 144/364] Reject fonts with invalid ranges in cmap A corrupt or malicious font may have a negative size in its cmap range, which in turn could lead to memory corruption. This patch detects the case and rejects the font, and also includes an assertion in the sparse bit set implementation if we missed any such case. External issue: https://code.google.com/p/android/issues/detail?id=192618 Bug: 26413177 Change-Id: Icc0c80e4ef389abba0964495b89aa0fae3e9f4b2 --- .../src/flutter/libs/minikin/CmapCoverage.cpp | 41 +++++++++++-------- .../src/flutter/libs/minikin/SparseBitSet.cpp | 2 + 2 files changed, 27 insertions(+), 16 deletions(-) diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index 8be45d173c..4c9643a1d4 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -50,7 +50,7 @@ static void addRange(vector &coverage, uint32_t start, uint32_t end) { } } -// Get the coverage information out of a Format 12 subtable, storing it in the coverage vector +// Get the coverage information out of a Format 4 subtable, storing it in the coverage vector static bool getCoverageFormat4(vector& coverage, const uint8_t* data, size_t size) { const size_t kSegCountOffset = 6; const size_t kEndCountOffset = 14; @@ -64,28 +64,32 @@ static bool getCoverageFormat4(vector& coverage, const uint8_t* data, return false; } for (size_t i = 0; i < segCount; i++) { - int end = readU16(data, kEndCountOffset + 2 * i); - int start = readU16(data, kHeaderSize + 2 * (segCount + i)); - int rangeOffset = readU16(data, kHeaderSize + 2 * (3 * segCount + i)); + uint32_t end = readU16(data, kEndCountOffset + 2 * i); + uint32_t start = readU16(data, kHeaderSize + 2 * (segCount + i)); + if (end < start) { + // invalid segment range: size must be positive + return false; + } + uint32_t rangeOffset = readU16(data, kHeaderSize + 2 * (3 * segCount + i)); if (rangeOffset == 0) { - int delta = readU16(data, kHeaderSize + 2 * (2 * segCount + i)); + uint32_t delta = readU16(data, kHeaderSize + 2 * (2 * segCount + i)); if (((end + delta) & 0xffff) > end - start) { addRange(coverage, start, end + 1); } else { - for (int j = start; j < end + 1; j++) { + for (uint32_t j = start; j < end + 1; j++) { if (((j + delta) & 0xffff) != 0) { addRange(coverage, j, j + 1); } } } } else { - for (int j = start; j < end + 1; j++) { + for (uint32_t j = start; j < end + 1; j++) { uint32_t actualRangeOffset = kHeaderSize + 6 * segCount + rangeOffset + (i + j - start) * 2; if (actualRangeOffset + 2 > size) { return false; } - int glyphId = readU16(data, actualRangeOffset); + uint32_t glyphId = readU16(data, actualRangeOffset); if (glyphId != 0) { addRange(coverage, j, j + 1); } @@ -115,6 +119,10 @@ static bool getCoverageFormat12(vector& coverage, const uint8_t* data, uint32_t groupOffset = kFirstGroupOffset + i * kGroupSize; uint32_t start = readU32(data, groupOffset + kStartCharCodeOffset); uint32_t end = readU32(data, groupOffset + kEndCharCodeOffset); + if (end < start) { + // invalid group range: size must be positive + return false; + } addRange(coverage, start, end + 1); // file is inclusive, vector is exclusive } return true; @@ -128,18 +136,19 @@ bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, const size_t kPlatformIdOffset = 0; const size_t kEncodingIdOffset = 2; const size_t kOffsetOffset = 4; - const int kMicrosoftPlatformId = 3; - const int kUnicodeBmpEncodingId = 1; - const int kUnicodeUcs4EncodingId = 10; + const uint16_t kMicrosoftPlatformId = 3; + const uint16_t kUnicodeBmpEncodingId = 1; + const uint16_t kUnicodeUcs4EncodingId = 10; + const uint32_t kNoTable = UINT32_MAX; if (kHeaderSize > cmap_size) { return false; } - int numTables = readU16(cmap_data, kNumTablesOffset); + uint32_t numTables = readU16(cmap_data, kNumTablesOffset); if (kHeaderSize + numTables * kTableSize > cmap_size) { return false; } - int bestTable = -1; - for (int i = 0; i < numTables; i++) { + uint32_t bestTable = kNoTable; + for (uint32_t i = 0; i < numTables; i++) { uint16_t platformId = readU16(cmap_data, kHeaderSize + i * kTableSize + kPlatformIdOffset); uint16_t encodingId = readU16(cmap_data, kHeaderSize + i * kTableSize + kEncodingIdOffset); if (platformId == kMicrosoftPlatformId && encodingId == kUnicodeUcs4EncodingId) { @@ -152,11 +161,11 @@ bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, #ifdef PRINTF_DEBUG printf("best table = %d\n", bestTable); #endif - if (bestTable < 0) { + if (bestTable == kNoTable) { return false; } uint32_t offset = readU32(cmap_data, kHeaderSize + bestTable * kTableSize + kOffsetOffset); - if (offset + 2 > cmap_size) { + if (offset > cmap_size - 2) { return false; } uint16_t format = readU16(cmap_data, offset); diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp index 7acb7ba345..2265ff2bb2 100644 --- a/engine/src/flutter/libs/minikin/SparseBitSet.cpp +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -14,6 +14,7 @@ * limitations under the License. */ +#include #include #include #include @@ -71,6 +72,7 @@ void SparseBitSet::initFromRanges(const uint32_t* ranges, size_t nRanges) { for (size_t i = 0; i < nRanges; i++) { uint32_t start = ranges[i * 2]; uint32_t end = ranges[i * 2 + 1]; + LOG_ALWAYS_FATAL_IF(end < start); // make sure range size is nonnegative uint32_t startPage = start >> kLogValuesPerPage; uint32_t endPage = (end - 1) >> kLogValuesPerPage; if (startPage >= nonzeroPageEnd) { From 4760a9f19038820734f31cc9e51b0ae5352b185e Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 29 Oct 2015 14:06:07 -0700 Subject: [PATCH 145/364] Tailor grapheme boundaries so sequence emoji are one grapheme Make it so it's not possible to position the cursor inside an emoji formed by a sequence including zero-width joiners. Bug: 25368653 Change-Id: I67ec0874cd1505f3c82ab91492ffc3d39a52fae6 --- .../flutter/libs/minikin/GraphemeBreak.cpp | 26 +++++++++++++++++++ .../src/flutter/tests/GraphemeBreakTests.cpp | 15 +++++++++++ 2 files changed, 41 insertions(+) diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index eca74b178c..7865d1d045 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -64,6 +64,19 @@ bool isPureKiller(uint32_t c) { || c == 0xA953 || c == 0xABED || c == 0x11134 || c == 0x112EA || c == 0x1172B); } +// Returns true if the character appears before or after zwj in a zwj emoji sequence. See +// http://www.unicode.org/emoji/charts/emoji-zwj-sequences.html +bool isZwjEmoji(uint32_t c) { + return (c == 0x2764 // HEAVY BLACK HEART + || c == 0x1F468 // MAN + || c == 0x1F469 // WOMAN + || c == 0x1F48B // KISS MARK + || c == 0x1F466 // BOY + || c == 0x1F467 // GIRL + || c == 0x1F441 // EYE + || c == 0x1F5E8); // LEFT SPEECH BUBBLE +} + bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t count, size_t offset) { // This implementation closely follows Unicode Standard Annex #29 on @@ -139,6 +152,19 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co && u_getIntPropertyValue(c2, UCHAR_GENERAL_CATEGORY) == U_OTHER_LETTER) { return false; } + // Tailoring: make emoji sequences with ZWJ a single grapheme cluster + if (c1 == 0x200D && isZwjEmoji(c2) && offset_back > start) { + // look at character before ZWJ to see that both can participate in an emoji zwj sequence + uint32_t c0 = 0; + U16_PREV(buf, start, offset_back, c0); + if (c0 == 0xFE0F && offset_back > start) { + // skip over emoji variation selector + U16_PREV(buf, start, offset_back, c0); + } + if (isZwjEmoji(c0)) { + return false; + } + } // Rule GB10, Any ÷ Any return true; } diff --git a/engine/src/flutter/tests/GraphemeBreakTests.cpp b/engine/src/flutter/tests/GraphemeBreakTests.cpp index 6eda4da9fd..d6746bc2b0 100644 --- a/engine/src/flutter/tests/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/GraphemeBreakTests.cpp @@ -119,6 +119,21 @@ TEST(GraphemeBreak, tailoring) { EXPECT_FALSE(IsBreak("U+0915 U+094D | U+0915")); // Devanagari ka+virama+ka EXPECT_FALSE(IsBreak("U+0E01 | U+0E3A U+0E01")); // thai phinthu = pure killer EXPECT_TRUE(IsBreak("U+0E01 U+0E3A | U+0E01")); // thai phinthu = pure killer + + // suppress grapheme breaks in zwj emoji sequences, see + // http://www.unicode.org/emoji/charts/emoji-zwj-sequences.html + EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+2764 U+FE0F U+200D U+1F48B U+200D U+1F468")); + EXPECT_FALSE(IsBreak("U+1F469 U+200D U+2764 U+FE0F U+200D | U+1F48B U+200D U+1F468")); + EXPECT_FALSE(IsBreak("U+1F469 U+200D U+2764 U+FE0F U+200D U+1F48B U+200D | U+1F468")); + EXPECT_FALSE(IsBreak("U+1F468 U+200D | U+1F469 U+200D U+1F466")); + EXPECT_FALSE(IsBreak("U+1F468 U+200D U+1F469 U+200D | U+1F466")); + EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+1F469 U+200D U+1F467 U+200D U+1F466")); + EXPECT_FALSE(IsBreak("U+1F469 U+200D U+1F469 U+200D | U+1F467 U+200D U+1F466")); + EXPECT_FALSE(IsBreak("U+1F469 U+200D U+1F469 U+200D U+1F467 U+200D | U+1F466")); + EXPECT_FALSE(IsBreak("U+1F441 U+200D | U+1F5E8")); + + // ARABIC LETTER BEH + ZWJ + heart, not a zwj emoji sequence, so we preserve the break + EXPECT_TRUE(IsBreak("U+0628 U+200D | U+2764")); } TEST(GraphemeBreak, offsets) { From c4e24421ecb8b4532bde4e759625107367cd60e3 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 29 Oct 2015 14:06:07 -0700 Subject: [PATCH 146/364] Tailor grapheme boundaries so sequence emoji are one grapheme - DO NOT MERGE Make it so it's not possible to position the cursor inside an emoji formed by a sequence including zero-width joiners. Bug: 25368653 Change-Id: I67ec0874cd1505f3c82ab91492ffc3d39a52fae6 --- .../flutter/libs/minikin/GraphemeBreak.cpp | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index f8f386c0de..56d5b238d3 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -22,6 +22,19 @@ namespace android { +// Returns true if the character appears before or after zwj in a zwj emoji sequence. See +// http://www.unicode.org/emoji/charts/emoji-zwj-sequences.html +bool isZwjEmoji(uint32_t c) { + return (c == 0x2764 // HEAVY BLACK HEART + || c == 0x1F468 // MAN + || c == 0x1F469 // WOMAN + || c == 0x1F48B // KISS MARK + || c == 0x1F466 // BOY + || c == 0x1F467 // GIRL + || c == 0x1F441 // EYE + || c == 0x1F5E8); // LEFT SPEECH BUBBLE +} + bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t count, size_t offset) { // This implementation closely follows Unicode Standard Annex #29 on @@ -93,6 +106,19 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co && u_getIntPropertyValue(c2, UCHAR_GENERAL_CATEGORY) == U_OTHER_LETTER) { return false; } + // Tailoring: make emoji sequences with ZWJ a single grapheme cluster + if (c1 == 0x200D && isZwjEmoji(c2) && offset_back > start) { + // look at character before ZWJ to see that both can participate in an emoji zwj sequence + uint32_t c0 = 0; + U16_PREV(buf, start, offset_back, c0); + if (c0 == 0xFE0F && offset_back > start) { + // skip over emoji variation selector + U16_PREV(buf, start, offset_back, c0); + } + if (isZwjEmoji(c0)) { + return false; + } + } // Rule GB10, Any / Any return true; } From 6cefe2eab1a796184891936062cff4835d0e17a7 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Fri, 11 Dec 2015 17:58:03 -0800 Subject: [PATCH 147/364] Introduce multiple language based font fallback. The motivation of this CL is enhance the font fallback score design to support multiple language font fallback. This CL contains following changes: - Break language based font score into two: script-based score and primary-language-based score. - The primary-language-based score is 0 if the script-based score is 0. If the script-based score is not 0 and the primary language is the as same as the requested one, the font gets an extra score of 1. - The language score gets a higher multiplier for languages higher in the locale list. Bug: 25122318 Bug: 26168983 Change-Id: Ib999997a88e6977e341f4c325e2a1b41a59db2d5 --- .../flutter/include/minikin/FontCollection.h | 10 + .../flutter/libs/minikin/FontCollection.cpp | 178 +++++-- .../src/flutter/libs/minikin/FontLanguage.cpp | 20 +- .../src/flutter/libs/minikin/FontLanguage.h | 12 +- .../libs/minikin/FontLanguageListCache.cpp | 17 +- .../tests/FontCollectionItemizeTest.cpp | 437 +++++++++++++++++- engine/src/flutter/tests/MinikinFontForTest.h | 5 + 7 files changed, 615 insertions(+), 64 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index cd14261640..294692fced 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -67,6 +67,16 @@ private: FontFamily* getFamilyForChar(uint32_t ch, uint32_t vs, uint32_t langListId, int variant) const; + uint32_t calcFamilyScore(uint32_t ch, uint32_t vs, int variant, uint32_t langListId, + FontFamily* fontFamily) const; + + uint32_t calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* fontFamily) const; + + static uint32_t calcLanguageMatchingScore(uint32_t userLangListId, + const FontFamily& fontFamily); + + static uint32_t calcVariantMatchingScore(int variant, const FontFamily& fontFamily); + // static for allocating unique id's static uint32_t sNextId; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 38687001fe..da58fa39c9 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -18,6 +18,7 @@ #define LOG_TAG "Minikin" #include +#include #include "unicode/unistr.h" #include "unicode/unorm2.h" @@ -103,29 +104,135 @@ FontCollection::~FontCollection() { } } +// Special scores for the font fallback. +const uint32_t kUnsupportedFontScore = 0; +const uint32_t kFirstFontScore = UINT32_MAX; + +// Calculates a font score. +// The score of the font family is based on three subscores. +// - Coverage Score: How well the font family covers the given character or variation sequence. +// - Language Score: How well the font family is appropriate for the language. +// - Variant Score: Whether the font family matches the variant. Note that this variant is not the +// one in BCP47. This is our own font variant (e.g., elegant, compact). +// +// Then, there is a priority for these three subscores as follow: +// Coverage Score > Language Score > Variant Score +// The returned score reflects this priority order. +// +// Note that there are two special scores. +// - kUnsupportedFontScore: When the font family doesn't support the variation sequence or even its +// base character. +// - kFirstFontScore: When the font is the first font family in the collection and it supports the +// given character or variation sequence. +uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, uint32_t langListId, + FontFamily* fontFamily) const { + + const uint32_t coverageScore = calcCoverageScore(ch, vs, fontFamily); + if (coverageScore == kFirstFontScore || coverageScore == kUnsupportedFontScore) { + // No need to calculate other scores. + return coverageScore; + } + + const uint32_t languageScore = calcLanguageMatchingScore(langListId, *fontFamily); + const uint32_t variantScore = calcVariantMatchingScore(variant, *fontFamily); + + // Subscores are encoded into 31 bits representation to meet the subscore priority. + // The highest 2 bits are for coverage score, then following 28 bits are for language score, + // then the last 1 bit is for variant score. + return coverageScore << 29 | languageScore << 1 | variantScore; +} + +// Calculates a font score based on variation sequence coverage. +// - Returns kUnsupportedFontScore if the font doesn't support the variation sequence or its base +// character. +// - Returns kFirstFontScore if the font family is the first font family in the collection and it +// supports the given character or variation sequence. +// - Returns 3 if the font family supports the variation sequence. +// - Returns 2 if the vs is a color variation selector (U+FE0F) and if the font is an emoji font. +// - Returns 2 if the vs is a text variation selector (U+FE0E) and if the font is not an emoji font. +// - Returns 1 if the variation selector is not specified or if the font family only supports the +// variation sequence's base character. +uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* fontFamily) const { + const bool hasVSGlyph = (vs != 0) && fontFamily->hasVariationSelector(ch, vs); + if (!hasVSGlyph && !fontFamily->getCoverage()->get(ch)) { + // The font doesn't support either variation sequence or even the base character. + return kUnsupportedFontScore; + } + + if ((vs == 0 || hasVSGlyph) && mFamilies[0] == fontFamily) { + // If the first font family supports the given character or variation sequence, always use + // it. + return kFirstFontScore; + } + + if (vs == 0) { + return 1; + } + + if (hasVSGlyph) { + return 3; + } + + if (vs == 0xFE0F || vs == 0xFE0E) { + // TODO use all language in the list. + const FontLanguage lang = FontLanguageListCache::getById(fontFamily->langId())[0]; + const bool hasEmojiFlag = lang.hasEmojiFlag(); + if (vs == 0xFE0F) { + return hasEmojiFlag ? 2 : 1; + } else { // vs == 0xFE0E + return hasEmojiFlag ? 1 : 2; + } + } + return 1; +} + +// Calculates font scores based on the script matching and primary langauge matching. +// +// If the font's script doesn't support the requested script, the font gets a score of 0. If the +// font's script supports the requested script and the font has the same primary language as the +// requested one, the font gets a score of 2. If the font's script supports the requested script +// but the primary language is different from the requested one, the font gets a score of 1. +// +// If two languages in the requested list have the same language score, the font matching with +// higher priority language gets a higher score. For example, in the case the user requested +// language list is "ja-Jpan,en-Latn". The score of for the font of "ja-Jpan" gets a higher score +// than the font of "en-Latn". +// +// To achieve the above two conditions, the language score is determined as follows: +// LanguageScore = s(0) * 3^(m - 1) + s(1) * 3^(m - 2) + ... + s(m - 2) * 3 + s(m - 1) +// Here, m is the maximum number of languages to be compared, and s(i) is the i-th language's +// matching score. The possible values of s(i) are 0, 1 and 2. +uint32_t FontCollection::calcLanguageMatchingScore( + uint32_t userLangListId, const FontFamily& fontFamily) { + const FontLanguages& langList = FontLanguageListCache::getById(userLangListId); + // TODO use all language in the list. + FontLanguage fontLanguage = FontLanguageListCache::getById(fontFamily.langId())[0]; + + const size_t maxCompareNum = std::min(langList.size(), FONT_LANGUAGES_LIMIT); + uint32_t score = fontLanguage.getScoreFor(langList[0]); // maxCompareNum can't be zero. + for (size_t i = 1; i < maxCompareNum; ++i) { + score = score * 3u + fontLanguage.getScoreFor(langList[i]); + } + return score; +} + +// Calculates a font score based on variant ("compact" or "elegant") matching. +// - Returns 1 if the font doesn't have variant or the variant matches with the text style. +// - No score if the font has a variant but it doesn't match with the text style. +uint32_t FontCollection::calcVariantMatchingScore(int variant, const FontFamily& fontFamily) { + return (fontFamily.variant() == 0 || fontFamily.variant() == variant) ? 1 : 0; +} + // Implement heuristic for choosing best-match font. Here are the rules: // 1. If first font in the collection has the character, it wins. -// 2. If a font matches language, it gets a score of 2. -// 3. Matching the "compact" or "elegant" variant adds one to the score. -// 4. If there is a variation selector and a font supports the complete variation sequence, we add -// 8 to the score. -// 5. If there is a color variation selector (U+FE0F), we add 4 to the score if the font is an emoji -// font. This additional score of 4 is only given if the base character is supported in the font, -// but not the whole variation sequence. -// 6. If there is a text variation selector (U+FE0E), we add 4 to the score if the font is not an -// emoji font. This additional score of 4 is only given if the base character is supported in the -// font, but not the whole variation sequence. -// 7. Highest score wins, with ties resolved to the first font. +// 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. FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, uint32_t langListId, int variant) const { if (ch >= mMaxChar) { return NULL; } - const FontLanguages& langList = FontLanguageListCache::getById(langListId); - // TODO: use all languages in langList. - const FontLanguage lang = (langList.size() == 0) ? FontLanguage() : langList[0]; - // Even if the font supports variation sequence, mRanges isn't aware of the base character of // the sequence. Search all FontFamilies if variation sequence is specified. // TODO: Always use mRanges for font search. @@ -141,40 +248,19 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, ALOGD("querying range %zd:%zd\n", range.start, range.end); #endif FontFamily* bestFamily = nullptr; - int bestScore = -1; + uint32_t bestScore = kUnsupportedFontScore; for (size_t i = range.start; i < range.end; i++) { FontFamily* family = familyVec[i]; - const bool hasVSGlyph = (vs != 0) && family->hasVariationSelector(ch, vs); - if (hasVSGlyph || family->getCoverage()->get(ch)) { - if ((vs == 0 || hasVSGlyph) && mFamilies[0] == family) { - // If the first font family in collection supports the given character or sequence, - // always use it. - return family; - } - - // TODO use all language in the list. - FontLanguage fontLang = FontLanguageListCache::getById(family->langId())[0]; - int score = lang.match(fontLang) * 2; - if (family->variant() == 0 || family->variant() == variant) { - score++; - } - if (hasVSGlyph) { - score += 8; - } else if (((vs == 0xFE0F) && fontLang.hasEmojiFlag()) || - ((vs == 0xFE0E) && !fontLang.hasEmojiFlag())) { - score += 4; - } - if (score > bestScore) { - bestScore = score; - bestFamily = family; - } + const uint32_t score = calcFamilyScore(ch, vs, variant, langListId, family); + if (score == kFirstFontScore) { + // If the first font family supports the given character or variation sequence, always + // use it. + return family; + } + if (score > bestScore) { + bestScore = score; + bestFamily = family; } - } - if (bestFamily == nullptr && vs != 0) { - // If no fonts support the codepoint and variation selector pair, - // fallback to select a font family that supports just the base - // character, ignoring the variation selector. - return getFamilyForChar(ch, 0, langListId, variant); } if (bestFamily == nullptr && !mFamilyVec.empty()) { UErrorCode errorCode = U_ZERO_ERROR; diff --git a/engine/src/flutter/libs/minikin/FontLanguage.cpp b/engine/src/flutter/libs/minikin/FontLanguage.cpp index b34040030f..8e5c9c481f 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguage.cpp @@ -115,21 +115,29 @@ std::string FontLanguage::getString() const { return std::string(buf, i); } -bool FontLanguage::isEqualScript(const FontLanguage other) const { +bool FontLanguage::isEqualScript(const FontLanguage& other) const { return other.mScript == mScript; } +bool FontLanguage::supportsScript(uint8_t requestedBits) const { + return requestedBits != 0 && (mSubScriptBits & requestedBits) == requestedBits; +} + bool FontLanguage::supportsHbScript(hb_script_t script) const { static_assert(SCRIPT_TAG('J', 'p', 'a', 'n') == HB_TAG('J', 'p', 'a', 'n'), "The Minikin script and HarfBuzz hb_script_t have different encodings."); if (script == mScript) return true; - uint8_t requestedBits = scriptToSubScriptBits(script); - return requestedBits != 0 && (mSubScriptBits & requestedBits) == requestedBits; + return supportsScript(scriptToSubScriptBits(script)); } -int FontLanguage::match(const FontLanguage other) const { - // TODO: Use script for matching. - return *this == other; +int FontLanguage::getScoreFor(const FontLanguage other) const { + if (isUnsupported() || other.isUnsupported()) { + return 0; + } else if (isEqualScript(other) || supportsScript(other.mSubScriptBits)) { + return mLanguage == other.mLanguage ? 2 : 1; + } else { + return 0; + } } #undef SCRIPT_TAG diff --git a/engine/src/flutter/libs/minikin/FontLanguage.h b/engine/src/flutter/libs/minikin/FontLanguage.h index abe7d13179..ee0b505bdd 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.h +++ b/engine/src/flutter/libs/minikin/FontLanguage.h @@ -36,7 +36,7 @@ public: FontLanguage(const char* buf, size_t length); bool operator==(const FontLanguage other) const { - return !isUnsupported() && isEqualScript(other) && isEqualLanguage(other); + return !isUnsupported() && isEqualScript(other) && mLanguage == other.mLanguage; } bool operator!=(const FontLanguage other) const { @@ -46,8 +46,7 @@ public: bool isUnsupported() const { return mLanguage == 0ul; } bool hasEmojiFlag() const { return mSubScriptBits & kEmojiFlag; } - bool isEqualLanguage(const FontLanguage other) const { return mLanguage == other.mLanguage; } - bool isEqualScript(const FontLanguage other) const; + bool isEqualScript(const FontLanguage& other) const; // Returns true if this script supports the given script. For example, ja-Jpan supports Hira, // ja-Hira doesn't support Jpan. @@ -55,8 +54,8 @@ public: std::string getString() const; - // 0 = no match, 1 = language matches - int match(const FontLanguage other) const; + // 0 = no match, 1 = script match, 2 = script and primary language match. + int getScoreFor(const FontLanguage other) const; uint64_t getIdentifier() const { return (uint64_t)mScript << 32 | (uint64_t)mLanguage; } @@ -80,8 +79,11 @@ private: uint8_t mSubScriptBits; static uint8_t scriptToSubScriptBits(uint32_t script); + bool supportsScript(uint8_t requestedBits) const; }; +// Due to the limit of font fallback cost calculation, we can't use anything more than 17 languages. +const size_t FONT_LANGUAGES_LIMIT = 17; typedef std::vector FontLanguages; } // namespace android diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp index 2d64998e7a..5d177b5827 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp @@ -92,15 +92,20 @@ static FontLanguages constructFontLanguages(const std::string& input) { uint64_t identifier = lang.getIdentifier(); if (!lang.isUnsupported() && seen.count(identifier) == 0) { result.push_back(lang); + if (result.size() == FONT_LANGUAGES_LIMIT) { + break; + } seen.insert(identifier); } } - locale.assign(input, currentIdx, input.size() - currentIdx); - size_t length = toLanguageTag(langTag, ULOC_FULLNAME_CAPACITY, locale); - FontLanguage lang(langTag, length); - uint64_t identifier = lang.getIdentifier(); - if (!lang.isUnsupported() && seen.count(identifier) == 0) { - result.push_back(lang); + if (result.size() < FONT_LANGUAGES_LIMIT) { + locale.assign(input, currentIdx, input.size() - currentIdx); + size_t length = toLanguageTag(langTag, ULOC_FULLNAME_CAPACITY, locale); + FontLanguage lang(langTag, length); + uint64_t identifier = lang.getIdentifier(); + if (!lang.isUnsupported() && seen.count(identifier) == 0) { + result.push_back(lang); + } } return result; } diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 57409a5e62..446efc6b56 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -16,18 +16,23 @@ #include +#include "FontLanguageListCache.h" #include "FontLanguage.h" #include "FontTestUtils.h" #include "ICUTestBase.h" #include "MinikinFontForTest.h" #include "MinikinInternal.h" #include "UnicodeUtils.h" +#include "minikin/FontFamily.h" using android::AutoMutex; using android::FontCollection; using android::FontFamily; using android::FontLanguage; +using android::FontLanguages; +using android::FontLanguageListCache; using android::FontStyle; +using android::MinikinFont; using android::gMinikinLock; const char kItemizeFontXml[] = kTestFontDir "itemize.xml"; @@ -68,6 +73,12 @@ const std::string& getFontPath(const FontCollection::Run& run) { return ((MinikinFontForTest*)run.fakedFont.font)->fontPath(); } +// Utility function to obtain FontLanguages from string. +const FontLanguages& registerAndGetFontLanguages(const std::string& lang_string) { + AutoMutex _l(gMinikinLock); + return FontLanguageListCache::getById(FontLanguageListCache::getId(lang_string)); +} + TEST_F(FontCollectionItemizeTest, itemize_latin) { std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); std::vector runs; @@ -451,7 +462,7 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { EXPECT_TRUE(runs[0].fakedFont.font == nullptr || kLatinFont == getFontPath(runs[0])); // First font family (Regular.ttf) supports U+203C but doesn't support U+203C U+FE0F. - // Emoji.ttf font supports supports U+203C U+FE0F. Emoji.ttf should be selected. + // Emoji.ttf font supports U+203C U+FE0F. Emoji.ttf should be selected. itemize(collection.get(), "U+203C U+FE0F", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); @@ -684,6 +695,430 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { family2->Unref(); } +TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { + struct TestCase { + std::string userPreferredLanguages; + std::string fontLanguages; + int selectedFontIndex; + } testCases[] = { + // Single user preferred language. + // Exact match case + { "en-Latn", "en-Latn,ja-Jpan", 0 }, + { "ja-Jpan", "en-Latn,ja-Jpan", 1 }, + { "en-Latn", "en-Latn,nl-Latn,es-Latn", 0 }, + { "nl-Latn", "en-Latn,nl-Latn,es-Latn", 1 }, + { "es-Latn", "en-Latn,nl-Latn,es-Latn", 2 }, + { "es-Latn", "en-Latn,en-Latn,nl-Latn", 0 }, + + // Exact script match case + { "en-Latn", "nl-Latn,be-Latn", 0 }, + { "en-Arab", "nl-Latn,ar-Arab", 1 }, + { "en-Latn", "be-Latn,ar-Arab,bd-Beng", 0 }, + { "en-Arab", "be-Latn,ar-Arab,bd-Beng", 1 }, + { "en-Beng", "be-Latn,ar-Arab,bd-Beng", 2 }, + { "en-Beng", "be-Latn,ar-Beng,bd-Beng", 1 }, + { "zh-Hant", "zh-Hant,zh-Hans", 0 }, + { "zh-Hans", "zh-Hant,zh-Hans", 1 }, + + // Subscript match case, e.g. Jpan supports Hira. + { "en-Hira", "ja-Jpan", 0 }, + { "zh-Hani", "zh-Hans,zh-Hant", 0 }, + { "zh-Hani", "zh-Hant,zh-Hans", 0 }, + { "en-Hira", "zh-Hant,ja-Jpan,ja-Jpan", 1 }, + + // Language match case + { "ja-Latn", "zh-Latn,ja-Latn", 1 }, + { "zh-Latn", "zh-Latn,ja-Latn", 0 }, + { "ja-Latn", "zh-Latn,ja-Latn", 1 }, + { "ja-Latn", "zh-Latn,ja-Latn,ja-Latn", 1 }, + + // Mixed case + // Script/subscript match is strongest. + { "ja-Jpan", "en-Latn,ja-Latn,en-Jpan", 2 }, + { "ja-Hira", "en-Latn,ja-Latn,en-Jpan", 2 }, + { "ja-Hira", "en-Latn,ja-Latn,en-Jpan,en-Jpan", 2 }, + + // Language match only happens if the script matches. + { "ja-Hira", "en-Latn,ja-Latn", 0 }, + { "ja-Hira", "en-Jpan,ja-Jpan", 1 }, + + // Multiple languages. + // Even if all fonts have the same score, use the 2nd language for better selection. + { "en-Latn,ja-Jpan", "zh-Hant,zh-Hans,ja-Jpan", 2 }, + { "en-Latn,nl-Latn", "es-Latn,be-Latn,nl-Latn", 2 }, + { "en-Latn,br-Latn,nl-Latn", "es-Latn,be-Latn,nl-Latn", 2 }, + { "en-Latn,br-Latn,nl-Latn", "es-Latn,be-Latn,nl-Latn,nl-Latn", 2 }, + + // Script score. + { "en-Latn,ja-Jpan", "en-Arab,en-Jpan", 1 }, + { "en-Latn,ja-Jpan", "en-Arab,en-Jpan,en-Jpan", 1 }, + + // Language match case + { "en-Latn,ja-Latn", "bd-Latn,ja-Latn", 1 }, + { "en-Latn,ja-Latn", "bd-Latn,ja-Latn,ja-Latn", 1 }, + + // Language match only happens if the script matches. + { "en-Latn,ar-Arab", "en-Beng,ar-Arab", 1 }, + }; + + for (auto testCase : testCases) { + SCOPED_TRACE("Test of user preferred languages: \"" + testCase.userPreferredLanguages + + "\" with font languages: " + testCase.fontLanguages); + + std::vector families; + + // Prepare first font which doesn't supports U+9AA8 + FontFamily* firstFamily = new FontFamily( + FontStyle::registerLanguageList("und"), 0 /* variant */); + MinikinFont* firstFamilyMinikinFont = new MinikinFontForTest(kNoGlyphFont); + firstFamily->addFont(firstFamilyMinikinFont); + families.push_back(firstFamily); + + // Prepare font families + // Each font family is associated with a specified language. All font families except for + // the first font support U+9AA8. + std::unordered_map fontLangIdxMap; + const FontLanguages& fontLanguages = registerAndGetFontLanguages(testCase.fontLanguages); + + for (size_t i = 0; i < fontLanguages.size(); ++i) { + const FontLanguage& fontLanguage = fontLanguages[i]; + FontFamily* family = new FontFamily( + FontStyle::registerLanguageList(fontLanguage.getString()), 0 /* variant */); + MinikinFont* minikin_font = new MinikinFontForTest(kJAFont); + family->addFont(minikin_font); + families.push_back(family); + fontLangIdxMap.insert(std::make_pair(minikin_font, i)); + } + FontCollection collection(families); + for (auto family : families) { + family->Unref(); + } + + // Do itemize + const FontStyle style = FontStyle( + FontStyle::registerLanguageList(testCase.userPreferredLanguages)); + std::vector runs; + itemize(&collection, "U+9AA8", style, &runs); + ASSERT_EQ(1U, runs.size()); + ASSERT_NE(nullptr, runs[0].fakedFont.font); + + // First family doesn't support U+9AA8 and others support it, so the first font should not + // be selected. + EXPECT_NE(firstFamilyMinikinFont, runs[0].fakedFont.font); + + // Lookup used font family by MinikinFont*. + const int usedLangIndex = fontLangIdxMap[runs[0].fakedFont.font]; + EXPECT_EQ(testCase.selectedFontIndex, usedLangIndex); + } +} + +TEST_F(FontCollectionItemizeTest, itemize_LanguageAndCoverage) { + struct TestCase { + std::string testString; + std::string requestedLanguages; + std::string expectedFont; + } testCases[] = { + // Following test cases verify that following rules in font fallback chain. + // - If the first font in the collection supports the given character or variation sequence, + // it should be selected. + // - If the font doesn't support the given character, variation sequence or its base + // character, it should not be selected. + // - If two or more fonts match the requested languages, the font matches with the highest + // priority language should be selected. + // - If two or more fonts get the same score, the font listed earlier in the XML file + // (here, kItemizeFontXml) should be selected. + + // Regardless of language, the first font is always selected if it covers the code point. + { "'a'", "", kLatinFont}, + { "'a'", "en-Latn", kLatinFont}, + { "'a'", "ja-Jpan", kLatinFont}, + { "'a'", "ja-Jpan,en-Latn", kLatinFont}, + { "'a'", "zh-Hans,zh-Hant,en-Latn,ja-Jpan,fr-Latn", kLatinFont}, + + // U+81ED is supported by both the ja font and zh-Hans font. + { "U+81ED", "", kZH_HansFont }, // zh-Hans font is listed before ja font. + { "U+81ED", "en-Latn", kZH_HansFont }, // zh-Hans font is listed before ja font. + { "U+81ED", "ja-Jpan", kJAFont }, + { "U+81ED", "zh-Hans", kZH_HansFont }, + + { "U+81ED", "ja-Jpan,en-Latn", kJAFont }, + { "U+81ED", "en-Latn,ja-Jpan", kJAFont }, + { "U+81ED", "en-Latn,zh-Hans", kZH_HansFont }, + { "U+81ED", "zh-Hans,en-Latn", kZH_HansFont }, + { "U+81ED", "ja-Jpan,zh-Hans", kJAFont }, + { "U+81ED", "zh-Hans,ja-Jpan", kZH_HansFont }, + + { "U+81ED", "en-Latn,zh-Hans,ja-Jpan", kZH_HansFont }, + { "U+81ED", "en-Latn,ja-Jpan,zh-Hans", kJAFont }, + { "U+81ED", "en-Latn,zh-Hans,ja-Jpan", kZH_HansFont }, + { "U+81ED", "ja-Jpan,en-Latn,zh-Hans", kJAFont }, + { "U+81ED", "ja-Jpan,zh-Hans,en-Latn", kJAFont }, + { "U+81ED", "zh-Hans,en-Latn,ja-Jpan", kZH_HansFont }, + { "U+81ED", "zh-Hans,ja-Jpan,en-Latn", kZH_HansFont }, + + // U+304A is only supported by ja font. + { "U+304A", "", kJAFont }, + { "U+304A", "ja-Jpan", kJAFont }, + { "U+304A", "zh-Hant", kJAFont }, + { "U+304A", "zh-Hans", kJAFont }, + + { "U+304A", "ja-Jpan,zh-Hant", kJAFont }, + { "U+304A", "zh-Hant,ja-Jpan", kJAFont }, + { "U+304A", "zh-Hans,zh-Hant", kJAFont }, + { "U+304A", "zh-Hant,zh-Hans", kJAFont }, + { "U+304A", "zh-Hans,ja-Jpan", kJAFont }, + { "U+304A", "ja-Jpan,zh-Hans", kJAFont }, + + { "U+304A", "zh-Hans,ja-Jpan,zh-Hant", kJAFont }, + { "U+304A", "zh-Hans,zh-Hant,ja-Jpan", kJAFont }, + { "U+304A", "ja-Jpan,zh-Hans,zh-Hant", kJAFont }, + { "U+304A", "ja-Jpan,zh-Hant,zh-Hans", kJAFont }, + { "U+304A", "zh-Hant,zh-Hans,ja-Jpan", kJAFont }, + { "U+304A", "zh-Hant,ja-Jpan,zh-Hans", kJAFont }, + + // U+242EE is supported by both ja font and zh-Hant fonts but not by zh-Hans font. + { "U+242EE", "", kJAFont }, // ja font is listed before zh-Hant font. + { "U+242EE", "ja-Jpan", kJAFont }, + { "U+242EE", "zh-Hans", kJAFont }, + { "U+242EE", "zh-Hant", kZH_HantFont }, + + { "U+242EE", "ja-Jpan,zh-Hant", kJAFont }, + { "U+242EE", "zh-Hant,ja-Jpan", kZH_HantFont }, + { "U+242EE", "zh-Hans,zh-Hant", kZH_HantFont }, + { "U+242EE", "zh-Hant,zh-Hans", kZH_HantFont }, + { "U+242EE", "zh-Hans,ja-Jpan", kJAFont }, + { "U+242EE", "ja-Jpan,zh-Hans", kJAFont }, + + { "U+242EE", "zh-Hans,ja-Jpan,zh-Hant", kJAFont }, + { "U+242EE", "zh-Hans,zh-Hant,ja-Jpan", kZH_HantFont }, + { "U+242EE", "ja-Jpan,zh-Hans,zh-Hant", kJAFont }, + { "U+242EE", "ja-Jpan,zh-Hant,zh-Hans", kJAFont }, + { "U+242EE", "zh-Hant,zh-Hans,ja-Jpan", kZH_HantFont }, + { "U+242EE", "zh-Hant,ja-Jpan,zh-Hans", kZH_HantFont }, + + // U+9AA8 is supported by all ja-Jpan, zh-Hans, zh-Hant fonts. + { "U+9AA8", "", kZH_HansFont }, // zh-Hans font is listed before ja and zh-Hant fonts. + { "U+9AA8", "ja-Jpan", kJAFont }, + { "U+9AA8", "zh-Hans", kZH_HansFont }, + { "U+9AA8", "zh-Hant", kZH_HantFont }, + + { "U+9AA8", "ja-Jpan,zh-Hant", kJAFont }, + { "U+9AA8", "zh-Hant,ja-Jpan", kZH_HantFont }, + { "U+9AA8", "zh-Hans,zh-Hant", kZH_HansFont }, + { "U+9AA8", "zh-Hant,zh-Hans", kZH_HantFont }, + { "U+9AA8", "zh-Hans,ja-Jpan", kZH_HansFont }, + { "U+9AA8", "ja-Jpan,zh-Hans", kJAFont }, + + { "U+9AA8", "zh-Hans,ja-Jpan,zh-Hant", kZH_HansFont }, + { "U+9AA8", "zh-Hans,zh-Hant,ja-Jpan", kZH_HansFont }, + { "U+9AA8", "ja-Jpan,zh-Hans,zh-Hant", kJAFont }, + { "U+9AA8", "ja-Jpan,zh-Hant,zh-Hans", kJAFont }, + { "U+9AA8", "zh-Hant,zh-Hans,ja-Jpan", kZH_HantFont }, + { "U+9AA8", "zh-Hant,ja-Jpan,zh-Hans", kZH_HantFont }, + + // U+242EE U+FE00 is supported by ja font but not by zh-Hans or zh-Hant fonts. + { "U+242EE U+FE00", "", kJAFont }, + { "U+242EE U+FE00", "ja-Jpan", kJAFont }, + { "U+242EE U+FE00", "zh-Hant", kJAFont }, + { "U+242EE U+FE00", "zh-Hans", kJAFont }, + + { "U+242EE U+FE00", "ja-Jpan,zh-Hant", kJAFont }, + { "U+242EE U+FE00", "zh-Hant,ja-Jpan", kJAFont }, + { "U+242EE U+FE00", "zh-Hans,zh-Hant", kJAFont }, + { "U+242EE U+FE00", "zh-Hant,zh-Hans", kJAFont }, + { "U+242EE U+FE00", "zh-Hans,ja-Jpan", kJAFont }, + { "U+242EE U+FE00", "ja-Jpan,zh-Hans", kJAFont }, + + { "U+242EE U+FE00", "zh-Hans,ja-Jpan,zh-Hant", kJAFont }, + { "U+242EE U+FE00", "zh-Hans,zh-Hant,ja-Jpan", kJAFont }, + { "U+242EE U+FE00", "ja-Jpan,zh-Hans,zh-Hant", kJAFont }, + { "U+242EE U+FE00", "ja-Jpan,zh-Hant,zh-Hans", kJAFont }, + { "U+242EE U+FE00", "zh-Hant,zh-Hans,ja-Jpan", kJAFont }, + { "U+242EE U+FE00", "zh-Hant,ja-Jpan,zh-Hans", kJAFont }, + + // U+3402 U+E0100 is supported by both zh-Hans and zh-Hant but not by ja font. + { "U+3402 U+E0100", "", kZH_HansFont }, // zh-Hans font is listed before zh-Hant font. + { "U+3402 U+E0100", "ja-Jpan", kZH_HansFont }, // zh-Hans font is listed before zh-Hant font. + { "U+3402 U+E0100", "zh-Hant", kZH_HantFont }, + { "U+3402 U+E0100", "zh-Hans", kZH_HansFont }, + + { "U+3402 U+E0100", "ja-Jpan,zh-Hant", kZH_HantFont }, + { "U+3402 U+E0100", "zh-Hant,ja-Jpan", kZH_HantFont }, + { "U+3402 U+E0100", "zh-Hans,zh-Hant", kZH_HansFont }, + { "U+3402 U+E0100", "zh-Hant,zh-Hans", kZH_HantFont }, + { "U+3402 U+E0100", "zh-Hans,ja-Jpan", kZH_HansFont }, + { "U+3402 U+E0100", "ja-Jpan,zh-Hans", kZH_HansFont }, + + { "U+3402 U+E0100", "zh-Hans,ja-Jpan,zh-Hant", kZH_HansFont }, + { "U+3402 U+E0100", "zh-Hans,zh-Hant,ja-Jpan", kZH_HansFont }, + { "U+3402 U+E0100", "ja-Jpan,zh-Hans,zh-Hant", kZH_HansFont }, + { "U+3402 U+E0100", "ja-Jpan,zh-Hant,zh-Hans", kZH_HantFont }, + { "U+3402 U+E0100", "zh-Hant,zh-Hans,ja-Jpan", kZH_HantFont }, + { "U+3402 U+E0100", "zh-Hant,ja-Jpan,zh-Hans", kZH_HantFont }, + + // No font supports U+4444 U+FE00 but only zh-Hans supports its base character U+4444. + { "U+4444 U+FE00", "", kZH_HansFont }, + { "U+4444 U+FE00", "ja-Jpan", kZH_HansFont }, + { "U+4444 U+FE00", "zh-Hant", kZH_HansFont }, + { "U+4444 U+FE00", "zh-Hans", kZH_HansFont }, + + { "U+4444 U+FE00", "ja-Jpan,zh-Hant", kZH_HansFont }, + { "U+4444 U+FE00", "zh-Hant,ja-Jpan", kZH_HansFont }, + { "U+4444 U+FE00", "zh-Hans,zh-Hant", kZH_HansFont }, + { "U+4444 U+FE00", "zh-Hant,zh-Hans", kZH_HansFont }, + { "U+4444 U+FE00", "zh-Hans,ja-Jpan", kZH_HansFont }, + { "U+4444 U+FE00", "ja-Jpan,zh-Hans", kZH_HansFont }, + + { "U+4444 U+FE00", "zh-Hans,ja-Jpan,zh-Hant", kZH_HansFont }, + { "U+4444 U+FE00", "zh-Hans,zh-Hant,ja-Jpan", kZH_HansFont }, + { "U+4444 U+FE00", "ja-Jpan,zh-Hans,zh-Hant", kZH_HansFont }, + { "U+4444 U+FE00", "ja-Jpan,zh-Hant,zh-Hans", kZH_HansFont }, + { "U+4444 U+FE00", "zh-Hant,zh-Hans,ja-Jpan", kZH_HansFont }, + { "U+4444 U+FE00", "zh-Hant,ja-Jpan,zh-Hans", kZH_HansFont }, + + // No font supports U+81ED U+E0100 but ja and zh-Hans support its base character U+81ED. + // zh-Hans font is listed before ja font. + { "U+81ED U+E0100", "", kZH_HansFont }, + { "U+81ED U+E0100", "ja-Jpan", kJAFont }, + { "U+81ED U+E0100", "zh-Hant", kZH_HansFont }, + { "U+81ED U+E0100", "zh-Hans", kZH_HansFont }, + + { "U+81ED U+E0100", "ja-Jpan,zh-Hant", kJAFont }, + { "U+81ED U+E0100", "zh-Hant,ja-Jpan", kJAFont }, + { "U+81ED U+E0100", "zh-Hans,zh-Hant", kZH_HansFont }, + { "U+81ED U+E0100", "zh-Hant,zh-Hans", kZH_HansFont }, + { "U+81ED U+E0100", "zh-Hans,ja-Jpan", kZH_HansFont }, + { "U+81ED U+E0100", "ja-Jpan,zh-Hans", kJAFont }, + + { "U+81ED U+E0100", "zh-Hans,ja-Jpan,zh-Hant", kZH_HansFont }, + { "U+81ED U+E0100", "zh-Hans,zh-Hant,ja-Jpan", kZH_HansFont }, + { "U+81ED U+E0100", "ja-Jpan,zh-Hans,zh-Hant", kJAFont }, + { "U+81ED U+E0100", "ja-Jpan,zh-Hant,zh-Hans", kJAFont }, + { "U+81ED U+E0100", "zh-Hant,zh-Hans,ja-Jpan", kZH_HansFont }, + { "U+81ED U+E0100", "zh-Hant,ja-Jpan,zh-Hans", kJAFont }, + + // No font supports U+9AA8 U+E0100 but all zh-Hans zh-hant ja fonts support its base + // character U+9AA8. + // zh-Hans font is listed before ja and zh-Hant fonts. + { "U+9AA8 U+E0100", "", kZH_HansFont }, + { "U+9AA8 U+E0100", "ja-Jpan", kJAFont }, + { "U+9AA8 U+E0100", "zh-Hans", kZH_HansFont }, + { "U+9AA8 U+E0100", "zh-Hant", kZH_HantFont }, + + { "U+9AA8 U+E0100", "ja-Jpan,zh-Hant", kJAFont }, + { "U+9AA8 U+E0100", "zh-Hant,ja-Jpan", kZH_HantFont }, + { "U+9AA8 U+E0100", "zh-Hans,zh-Hant", kZH_HansFont }, + { "U+9AA8 U+E0100", "zh-Hant,zh-Hans", kZH_HantFont }, + { "U+9AA8 U+E0100", "zh-Hans,ja-Jpan", kZH_HansFont }, + { "U+9AA8 U+E0100", "ja-Jpan,zh-Hans", kJAFont }, + + { "U+9AA8 U+E0100", "zh-Hans,ja-Jpan,zh-Hant", kZH_HansFont }, + { "U+9AA8 U+E0100", "zh-Hans,zh-Hant,ja-Jpan", kZH_HansFont }, + { "U+9AA8 U+E0100", "ja-Jpan,zh-Hans,zh-Hant", kJAFont }, + { "U+9AA8 U+E0100", "ja-Jpan,zh-Hant,zh-Hans", kJAFont }, + { "U+9AA8 U+E0100", "zh-Hant,zh-Hans,ja-Jpan", kZH_HantFont }, + { "U+9AA8 U+E0100", "zh-Hant,ja-Jpan,zh-Hans", kZH_HantFont }, + + // All zh-Hans,zh-Hant,ja fonts support U+35A8 U+E0100 and its base character U+35A8. + // zh-Hans font is listed before ja and zh-Hant fonts. + { "U+35A8", "", kZH_HansFont }, + { "U+35A8", "ja-Jpan", kJAFont }, + { "U+35A8", "zh-Hans", kZH_HansFont }, + { "U+35A8", "zh-Hant", kZH_HantFont }, + + { "U+35A8", "ja-Jpan,zh-Hant", kJAFont }, + { "U+35A8", "zh-Hant,ja-Jpan", kZH_HantFont }, + { "U+35A8", "zh-Hans,zh-Hant", kZH_HansFont }, + { "U+35A8", "zh-Hant,zh-Hans", kZH_HantFont }, + { "U+35A8", "zh-Hans,ja-Jpan", kZH_HansFont }, + { "U+35A8", "ja-Jpan,zh-Hans", kJAFont }, + + { "U+35A8", "zh-Hans,ja-Jpan,zh-Hant", kZH_HansFont }, + { "U+35A8", "zh-Hans,zh-Hant,ja-Jpan", kZH_HansFont }, + { "U+35A8", "ja-Jpan,zh-Hans,zh-Hant", kJAFont }, + { "U+35A8", "ja-Jpan,zh-Hant,zh-Hans", kJAFont }, + { "U+35A8", "zh-Hant,zh-Hans,ja-Jpan", kZH_HantFont }, + { "U+35A8", "zh-Hant,ja-Jpan,zh-Hans", kZH_HantFont }, + + // All zh-Hans,zh-Hant,ja fonts support U+35B6 U+E0100, but zh-Hant and ja fonts support its + // base character U+35B6. + // ja font is listed before zh-Hant font. + { "U+35B6", "", kJAFont }, + { "U+35B6", "ja-Jpan", kJAFont }, + { "U+35B6", "zh-Hant", kZH_HantFont }, + { "U+35B6", "zh-Hans", kJAFont }, + + { "U+35B6", "ja-Jpan,zh-Hant", kJAFont }, + { "U+35B6", "zh-Hant,ja-Jpan", kZH_HantFont }, + { "U+35B6", "zh-Hans,zh-Hant", kZH_HantFont }, + { "U+35B6", "zh-Hant,zh-Hans", kZH_HantFont }, + { "U+35B6", "zh-Hans,ja-Jpan", kJAFont }, + { "U+35B6", "ja-Jpan,zh-Hans", kJAFont }, + + { "U+35B6", "zh-Hans,ja-Jpan,zh-Hant", kJAFont }, + { "U+35B6", "zh-Hans,zh-Hant,ja-Jpan", kZH_HantFont }, + { "U+35B6", "ja-Jpan,zh-Hans,zh-Hant", kJAFont }, + { "U+35B6", "ja-Jpan,zh-Hant,zh-Hans", kJAFont }, + { "U+35B6", "zh-Hant,zh-Hans,ja-Jpan", kZH_HantFont }, + { "U+35B6", "zh-Hant,ja-Jpan,zh-Hans", kZH_HantFont }, + + // All zh-Hans,zh-Hant,ja fonts support U+35C5 U+E0100, but only ja font supports its base + // character U+35C5. + { "U+35C5", "", kJAFont }, + { "U+35C5", "ja-Jpan", kJAFont }, + { "U+35C5", "zh-Hant", kJAFont }, + { "U+35C5", "zh-Hans", kJAFont }, + + { "U+35C5", "ja-Jpan,zh-Hant", kJAFont }, + { "U+35C5", "zh-Hant,ja-Jpan", kJAFont }, + { "U+35C5", "zh-Hans,zh-Hant", kJAFont }, + { "U+35C5", "zh-Hant,zh-Hans", kJAFont }, + { "U+35C5", "zh-Hans,ja-Jpan", kJAFont }, + { "U+35C5", "ja-Jpan,zh-Hans", kJAFont }, + + { "U+35C5", "zh-Hans,ja-Jpan,zh-Hant", kJAFont }, + { "U+35C5", "zh-Hans,zh-Hant,ja-Jpan", kJAFont }, + { "U+35C5", "ja-Jpan,zh-Hans,zh-Hant", kJAFont }, + { "U+35C5", "ja-Jpan,zh-Hant,zh-Hans", kJAFont }, + { "U+35C5", "zh-Hant,zh-Hans,ja-Jpan", kJAFont }, + { "U+35C5", "zh-Hant,ja-Jpan,zh-Hans", kJAFont }, + + // None of ja-Jpan, zh-Hant, zh-Hans font supports U+1F469. Emoji font supports it. + { "U+1F469", "", kEmojiFont }, + { "U+1F469", "ja-Jpan", kEmojiFont }, + { "U+1F469", "zh-Hant", kEmojiFont }, + { "U+1F469", "zh-Hans", kEmojiFont }, + + { "U+1F469", "ja-Jpan,zh-Hant", kEmojiFont }, + { "U+1F469", "zh-Hant,ja-Jpan", kEmojiFont }, + { "U+1F469", "zh-Hans,zh-Hant", kEmojiFont }, + { "U+1F469", "zh-Hant,zh-Hans", kEmojiFont }, + { "U+1F469", "zh-Hans,ja-Jpan", kEmojiFont }, + { "U+1F469", "ja-Jpan,zh-Hans", kEmojiFont }, + + { "U+1F469", "zh-Hans,ja-Jpan,zh-Hant", kEmojiFont }, + { "U+1F469", "zh-Hans,zh-Hant,ja-Jpan", kEmojiFont }, + { "U+1F469", "ja-Jpan,zh-Hans,zh-Hant", kEmojiFont }, + { "U+1F469", "ja-Jpan,zh-Hant,zh-Hans", kEmojiFont }, + { "U+1F469", "zh-Hant,zh-Hans,ja-Jpan", kEmojiFont }, + { "U+1F469", "zh-Hant,ja-Jpan,zh-Hans", kEmojiFont }, + }; + + std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); + + for (auto testCase : testCases) { + SCOPED_TRACE("Test for \"" + testCase.testString + "\" with languages " + + testCase.requestedLanguages); + + std::vector runs; + const FontStyle style = + FontStyle(FontStyle::registerLanguageList(testCase.requestedLanguages)); + itemize(collection.get(), testCase.testString.c_str(), style, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(testCase.expectedFont, getFontPath(runs[0])); + } +} + TEST_F(FontCollectionItemizeTest, itemize_emojiSelection) { std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); std::vector runs; diff --git a/engine/src/flutter/tests/MinikinFontForTest.h b/engine/src/flutter/tests/MinikinFontForTest.h index 5738666f77..790348deae 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.h +++ b/engine/src/flutter/tests/MinikinFontForTest.h @@ -14,6 +14,9 @@ * limitations under the License. */ +#ifndef MINIKIN_TEST_MINIKIN_FONT_FOR_TEST_H +#define MINIKIN_TEST_MINIKIN_FONT_FOR_TEST_H + #include class SkTypeface; @@ -35,3 +38,5 @@ private: SkTypeface *mTypeface; const std::string mFontPath; }; + +#endif // MINIKIN_TEST_MINIKIN_FONT_FOR_TEST_H From 84b080abc57a299fc2ea0d0b0b09d895476ca2a9 Mon Sep 17 00:00:00 2001 From: Keisuke Kuroyanagi Date: Tue, 13 Oct 2015 19:20:09 +0900 Subject: [PATCH 148/364] Add light weight methods for text measurement. The intruduced method measureText can be used instead of doLayout for text measurement purpose. Bug: 24505153 Change-Id: Ic29bbb347daf18d1f6c13f86970dcdd11dd6a2bd --- engine/src/flutter/include/minikin/Layout.h | 16 +++-- engine/src/flutter/libs/minikin/Layout.cpp | 68 ++++++++++++++++----- 2 files changed, 65 insertions(+), 19 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index cb68db9c3d..d9bb01f1a7 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -93,6 +93,10 @@ public: void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint); + static float measureText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + int bidiFlags, const FontStyle &style, const MinikinPaint &paint, + const FontCollection* collection, float* advances); + void draw(minikin::Bitmap*, int x0, int y0, float size) const; // Deprecated. Nont needed. Remove when callers are removed. @@ -129,12 +133,16 @@ private: int findFace(FakedFont face, LayoutContext* ctx); // Lay out a single bidi run - void doLayoutRunCached(const uint16_t* buf, size_t runStart, size_t runLength, size_t bufSize, - bool isRtl, LayoutContext* ctx, size_t dstStart); + // When layout is not null, layout info will be stored in the object. + // When advances is not null, measurement results will be stored in the array. + static float doLayoutRunCached(const uint16_t* buf, size_t runStart, size_t runLength, + size_t bufSize, bool isRtl, LayoutContext* ctx, size_t dstStart, + const FontCollection* collection, Layout* layout, float* advances); // Lay out a single word - void doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, LayoutContext* ctx, size_t bufStart); + static float doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, LayoutContext* ctx, size_t bufStart, const FontCollection* collection, + Layout* layout, float* advances); // Lay out a single bidi run void doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 2e206a20fc..2839e5b71d 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -596,15 +596,37 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu for (const BidiText::Iter::RunInfo& runInfo : BidiText(buf, start, count, bufSize, bidiFlags)) { doLayoutRunCached(buf, runInfo.mRunStart, runInfo.mRunLength, bufSize, runInfo.mIsRtl, &ctx, - start); + start, mCollection, this, NULL); } ctx.clearHbFonts(); mCollection->purgeFontFamilyHbFontCache(); } -void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, LayoutContext* ctx, size_t dstStart) { +float Layout::measureText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + int bidiFlags, const FontStyle &style, const MinikinPaint &paint, + const FontCollection* collection, float* advances) { + AutoMutex _l(gMinikinLock); + + LayoutContext ctx; + ctx.style = style; + ctx.paint = paint; + + float advance = 0; + for (const BidiText::Iter::RunInfo& runInfo : BidiText(buf, start, count, bufSize, bidiFlags)) { + float* advancesForRun = advances ? advances + (runInfo.mRunStart - start) : advances; + advance += doLayoutRunCached(buf, runInfo.mRunStart, runInfo.mRunLength, bufSize, + runInfo.mIsRtl, &ctx, 0, collection, NULL, advancesForRun); + } + + ctx.clearHbFonts(); + return advance; +} + +float Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, LayoutContext* ctx, size_t dstStart, const FontCollection* collection, + Layout* layout, float* advances) { HyphenEdit hyphen = ctx->paint.hyphenEdit; + float advance = 0; if (!isRtl) { // left to right size_t wordstart = @@ -615,8 +637,9 @@ void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, // Only apply hyphen to the last word in the string. ctx->paint.hyphenEdit = wordend >= start + count ? hyphen : HyphenEdit(); size_t wordcount = std::min(start + count, wordend) - iter; - doLayoutWord(buf + wordstart, iter - wordstart, wordcount, wordend - wordstart, - isRtl, ctx, iter - dstStart); + advance += doLayoutWord(buf + wordstart, iter - wordstart, wordcount, + wordend - wordstart, isRtl, ctx, iter - dstStart, collection, layout, + advances ? advances + (iter - start) : advances); wordstart = wordend; } } else { @@ -629,25 +652,40 @@ void Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, // Only apply hyphen to the last (leftmost) word in the string. ctx->paint.hyphenEdit = iter == end ? hyphen : HyphenEdit(); size_t bufStart = std::max(start, wordstart); - doLayoutWord(buf + wordstart, bufStart - wordstart, iter - bufStart, - wordend - wordstart, isRtl, ctx, bufStart - dstStart); + advance += doLayoutWord(buf + wordstart, bufStart - wordstart, iter - bufStart, + wordend - wordstart, isRtl, ctx, bufStart - dstStart, collection, layout, + advances ? advances + (bufStart - start) : advances); wordend = wordstart; } } + return advance; } -void Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, LayoutContext* ctx, size_t bufStart) { +float Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, + bool isRtl, LayoutContext* ctx, size_t bufStart, const FontCollection* collection, + Layout* layout, float* advances) { LayoutCache& cache = LayoutEngine::getInstance().layoutCache; - LayoutCacheKey key(mCollection, ctx->paint, ctx->style, buf, start, count, bufSize, isRtl); + LayoutCacheKey key(collection, ctx->paint, ctx->style, buf, start, count, bufSize, isRtl); bool skipCache = ctx->paint.skipCache(); if (skipCache) { - Layout layout; - key.doLayout(&layout, ctx, mCollection); - appendLayout(&layout, bufStart); + Layout layoutForWord; + key.doLayout(&layoutForWord, ctx, collection); + if (layout) { + layout->appendLayout(&layoutForWord, bufStart); + } + if (advances) { + layoutForWord.getAdvances(advances); + } + return layoutForWord.getAdvance(); } else { - Layout* layout = cache.get(key, ctx, mCollection); - appendLayout(layout, bufStart); + Layout* layoutForWord = cache.get(key, ctx, collection); + if (layout) { + layout->appendLayout(layoutForWord, bufStart); + } + if (advances) { + layoutForWord->getAdvances(advances); + } + return layoutForWord->getAdvance(); } } From 900a7c36fb2953605bae61a70fb508d0f8fe515c Mon Sep 17 00:00:00 2001 From: Stephen Hines Date: Tue, 26 Jan 2016 00:44:02 -0800 Subject: [PATCH 149/364] Disable unsigned integer overflow sanitization until libc++ is fixed. Bug: http://b/26781196 Bug: http://b/25884483 Bug: http://b/26432628 Although this issue was first only manifesting on Fugu, it now affects N9 and N6p as well. This change disables unsigned overflow sanitization on all platforms. The real fix for libc++ (r257368) can't be committed until we have updated Clang at least one more time. Change-Id: I71e9c50d25ae4566d4c06f348183c4b22a4bb60a --- engine/src/flutter/libs/minikin/Android.mk | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index f91a4a80d3..48d06c0847 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -53,9 +53,7 @@ LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) LOCAL_CLANG := true LOCAL_SANITIZE := signed-integer-overflow # b/26432628. -ifeq ($(filter x86%,$(TARGET_ARCH)),) - LOCAL_SANITIZE += unsigned-integer-overflow -endif +#LOCAL_SANITIZE += unsigned-integer-overflow include $(BUILD_SHARED_LIBRARY) @@ -70,9 +68,7 @@ LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) LOCAL_CLANG := true LOCAL_SANITIZE := signed-integer-overflow # b/26432628. -ifeq ($(filter x86%,$(TARGET_ARCH)),) - LOCAL_SANITIZE += unsigned-integer-overflow -endif +#LOCAL_SANITIZE += unsigned-integer-overflow include $(BUILD_STATIC_LIBRARY) From 109b6675541d10cfccfb188f94eb9def9d1d3723 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Wed, 3 Feb 2016 19:41:00 +0900 Subject: [PATCH 150/364] Improve Paint.hasGlyph performance by caching hb_font_t It turned out that hb_font_t creation is not a lightweight operation. Especially, Paint.hasGlyph creates hb_font_t for all existing fonts every time. To improve the performance, cache hb_font_t instead of hb_face_t. Note that to calculate horizontal advance, MinikinPaint needs to be associated with hb_font_t by calling hb_font_set_funcs. With this patch, hb_font_set_funcs may be called multiple times for the same hb_font_t object. However this is not an issue since MinikinPaint is unique during layout. Bug: 26784699 Change-Id: I516498ae9f0127d700fc9829327e9789845a1416 --- .../flutter/include/minikin/FontCollection.h | 3 - .../src/flutter/include/minikin/FontFamily.h | 11 +- engine/src/flutter/libs/minikin/Android.mk | 2 +- .../flutter/libs/minikin/FontCollection.cpp | 7 -- .../src/flutter/libs/minikin/FontFamily.cpp | 22 +--- .../{HbFaceCache.cpp => HbFontCache.cpp} | 60 +++++---- .../minikin/{HbFaceCache.h => HbFontCache.h} | 12 +- engine/src/flutter/libs/minikin/Layout.cpp | 26 +--- engine/src/flutter/tests/Android.mk | 2 +- engine/src/flutter/tests/FontFamilyTest.cpp | 14 --- engine/src/flutter/tests/HbFaceCacheTest.cpp | 118 ------------------ engine/src/flutter/tests/HbFontCacheTest.cpp | 87 +++++++++++++ 12 files changed, 144 insertions(+), 220 deletions(-) rename engine/src/flutter/libs/minikin/{HbFaceCache.cpp => HbFontCache.cpp} (60%) rename engine/src/flutter/libs/minikin/{HbFaceCache.h => HbFontCache.h} (77%) delete mode 100644 engine/src/flutter/tests/HbFaceCacheTest.cpp create mode 100644 engine/src/flutter/tests/HbFontCacheTest.cpp diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 294692fced..3a63c07948 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -53,9 +53,6 @@ public: uint32_t getId() const; - // Calls each managed font family's FontFamily::purgeHbFontCache method. - // Caller should acquire a lock before calling the method. - void purgeFontFamilyHbFontCache() const; private: static const int kLogCharsPerPage = 8; static const int kPageMask = (1 << kLogCharsPerPage) - 1; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index aa2e0ac2e4..2b59160ffa 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -100,11 +100,11 @@ struct FakedFont { class FontFamily : public MinikinRefCounted { public: - FontFamily() : mHbFont(nullptr) { } + FontFamily() {} FontFamily(int variant); - FontFamily(uint32_t langId, int variant) : mLangId(langId), mVariant(variant), mHbFont(nullptr) { + FontFamily(uint32_t langId, int variant) : mLangId(langId), mVariant(variant) { } ~FontFamily(); @@ -131,11 +131,6 @@ public: // Caller should acquire a lock before calling the method. bool hasVariationSelector(uint32_t codepoint, uint32_t variationSelector); - // Purges cached mHbFont. - // hb_font_t keeps a reference to hb_face_t which is managed by HbFaceCache. Thus, - // it is good to purge hb_font_t once it is no longer necessary. - // Caller should acquire a lock before calling the method. - void purgeHbFontCache(); private: void addFontLocked(MinikinFont* typeface, FontStyle style); @@ -152,8 +147,6 @@ private: SparseBitSet mCoverage; bool mCoverageValid; - - hb_font_t* mHbFont; }; } // namespace android diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 769b5fcd81..1fd0e6e8a0 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -24,7 +24,7 @@ minikin_src_files := \ FontLanguage.cpp \ FontLanguageListCache.cpp \ GraphemeBreak.cpp \ - HbFaceCache.cpp \ + HbFontCache.cpp \ Hyphenator.cpp \ Layout.cpp \ LayoutUtils.cpp \ diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index da58fa39c9..26aefe4490 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -410,11 +410,4 @@ uint32_t FontCollection::getId() const { return mId; } -void FontCollection::purgeFontFamilyHbFontCache() const { - assertMinikinLocked(); - for (size_t i = 0; i < mFamilies.size(); ++i) { - mFamilies[i]->purgeHbFontCache(); - } -} - } // namespace android diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 1405789028..9eda3c2498 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -28,7 +28,7 @@ #include "FontLanguage.h" #include "FontLanguageListCache.h" -#include "HbFaceCache.h" +#include "HbFontCache.h" #include "MinikinInternal.h" #include #include @@ -189,23 +189,11 @@ const SparseBitSet* FontFamily::getCoverage() { bool FontFamily::hasVariationSelector(uint32_t codepoint, uint32_t variationSelector) { assertMinikinLocked(); - if (!mHbFont) { - const FontStyle defaultStyle; - MinikinFont* minikinFont = getClosestMatch(defaultStyle).font; - hb_face_t* face = getHbFaceLocked(minikinFont); - mHbFont = hb_font_create(face); - hb_ot_font_set_funcs(mHbFont); - } + const FontStyle defaultStyle; + MinikinFont* minikinFont = getClosestMatch(defaultStyle).font; + hb_font_t* font = getHbFontLocked(minikinFont); uint32_t unusedGlyph; - return hb_font_get_glyph(mHbFont, codepoint, variationSelector, &unusedGlyph); -} - -void FontFamily::purgeHbFontCache() { - assertMinikinLocked(); - if (mHbFont) { - hb_font_destroy(mHbFont); - mHbFont = nullptr; - } + return hb_font_get_glyph(font, codepoint, variationSelector, &unusedGlyph); } } // namespace android diff --git a/engine/src/flutter/libs/minikin/HbFaceCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp similarity index 60% rename from engine/src/flutter/libs/minikin/HbFaceCache.cpp rename to engine/src/flutter/libs/minikin/HbFontCache.cpp index 235f7f1b0c..73308efab7 100644 --- a/engine/src/flutter/libs/minikin/HbFaceCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -16,10 +16,11 @@ #define LOG_TAG "Minikin" -#include "HbFaceCache.h" +#include "HbFontCache.h" #include #include +#include #include #include @@ -51,23 +52,23 @@ static hb_blob_t* referenceTable(hb_face_t* /* face */, hb_tag_t tag, void* user HB_MEMORY_MODE_WRITABLE, buffer, free); } -class HbFaceCache : private OnEntryRemoved { +class HbFontCache : private OnEntryRemoved { public: - HbFaceCache() : mCache(kMaxEntries) { + HbFontCache() : mCache(kMaxEntries) { mCache.setOnEntryRemovedListener(this); } // callback for OnEntryRemoved - void operator()(int32_t& /* key */, hb_face_t*& value) { - hb_face_destroy(value); + void operator()(int32_t& /* key */, hb_font_t*& value) { + hb_font_destroy(value); } - hb_face_t* get(int32_t fontId) { + hb_font_t* get(int32_t fontId) { return mCache.get(fontId); } - void put(int32_t fontId, hb_face_t* face) { - mCache.put(fontId, face); + void put(int32_t fontId, hb_font_t* font) { + mCache.put(fontId, font); } void clear() { @@ -77,39 +78,52 @@ public: private: static const size_t kMaxEntries = 100; - LruCache mCache; + LruCache mCache; }; -HbFaceCache* getFaceCacheLocked() { +HbFontCache* getFontCacheLocked() { assertMinikinLocked(); - static HbFaceCache* cache = nullptr; + static HbFontCache* cache = nullptr; if (cache == nullptr) { - cache = new HbFaceCache(); + cache = new HbFontCache(); } return cache; } -void purgeHbFaceCacheLocked() { +void purgeHbFontCacheLocked() { assertMinikinLocked(); - getFaceCacheLocked()->clear(); + getFontCacheLocked()->clear(); } -hb_face_t* getHbFaceLocked(MinikinFont* minikinFont) { +hb_font_t* getHbFontLocked(MinikinFont* minikinFont) { assertMinikinLocked(); + static hb_font_t* nullFaceFont = nullptr; if (minikinFont == nullptr) { - return nullptr; + if (nullFaceFont == nullptr) { + nullFaceFont = hb_font_create(nullptr); + } + return nullFaceFont; } - HbFaceCache* faceCache = getFaceCacheLocked(); + HbFontCache* fontCache = getFontCacheLocked(); const int32_t fontId = minikinFont->GetUniqueId(); - hb_face_t* face = faceCache->get(fontId); - if (face != nullptr) { - return face; + hb_font_t* font = fontCache->get(fontId); + if (font != nullptr) { + return font; } - face = hb_face_create_for_tables(referenceTable, minikinFont, nullptr); - faceCache->put(fontId, face); - return face; + hb_face_t* face = hb_face_create_for_tables(referenceTable, minikinFont, nullptr); + hb_font_t* parent_font = hb_font_create(face); + hb_ot_font_set_funcs(parent_font); + + unsigned int upem = hb_face_get_upem(face); + hb_font_set_scale(parent_font, upem, upem); + + font = hb_font_create_sub_font(parent_font); + hb_font_destroy(parent_font); + hb_face_destroy(face); + fontCache->put(fontId, font); + return font; } } // namespace android diff --git a/engine/src/flutter/libs/minikin/HbFaceCache.h b/engine/src/flutter/libs/minikin/HbFontCache.h similarity index 77% rename from engine/src/flutter/libs/minikin/HbFaceCache.h rename to engine/src/flutter/libs/minikin/HbFontCache.h index 8ee38c3603..62564d35b9 100644 --- a/engine/src/flutter/libs/minikin/HbFaceCache.h +++ b/engine/src/flutter/libs/minikin/HbFontCache.h @@ -14,16 +14,16 @@ * limitations under the License. */ -#ifndef MINIKIN_HBFACE_CACHE_H -#define MINIKIN_HBFACE_CACHE_H +#ifndef MINIKIN_HBFONT_CACHE_H +#define MINIKIN_HBFONT_CACHE_H -struct hb_face_t; +struct hb_font_t; namespace android { class MinikinFont; -void purgeHbFaceCacheLocked(); -hb_face_t* getHbFaceLocked(MinikinFont* minikinFont); +void purgeHbFontCacheLocked(); +hb_font_t* getHbFontLocked(MinikinFont* minikinFont); } // namespace android -#endif // MINIKIN_HBFACE_CACHE_H +#endif // MINIKIN_HBFONT_CACHE_H diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 2839e5b71d..71e0d890b7 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -37,7 +37,7 @@ #include "FontLanguage.h" #include "FontLanguageListCache.h" #include "LayoutUtils.h" -#include "HbFaceCache.h" +#include "HbFontCache.h" #include "MinikinInternal.h" #include #include @@ -98,7 +98,7 @@ struct LayoutContext { void clearHbFonts() { for (size_t i = 0; i < hbFonts.size(); i++) { - hb_font_destroy(hbFonts[i]); + hb_font_set_funcs(hbFonts[i], nullptr, nullptr, nullptr); } hbFonts.clear(); } @@ -133,7 +133,6 @@ public: layout->setFontCollection(collection); layout->mAdvances.resize(mCount, 0); ctx->clearHbFonts(); - collection->purgeFontFamilyHbFontCache(); layout->doLayoutRun(mChars, mStart, mCount, mNchars, mIsRtl, ctx); } @@ -306,21 +305,6 @@ hb_font_funcs_t* getHbFontFuncs() { return hbFontFuncs; } -static hb_font_t* create_hb_font(MinikinFont* minikinFont, MinikinPaint* minikinPaint) { - hb_face_t* face = getHbFaceLocked(minikinFont); - hb_font_t* parent_font = hb_font_create(face); - hb_ot_font_set_funcs(parent_font); - - unsigned int upem = hb_face_get_upem(face); - hb_font_set_scale(parent_font, upem, upem); - - hb_font_t* font = hb_font_create_sub_font(parent_font); - hb_font_destroy(parent_font); - - hb_font_set_funcs(font, getHbFontFuncs(), minikinPaint, 0); - return font; -} - static float HBFixedToFloat(hb_position_t v) { return scalbnf (v, -8); @@ -349,7 +333,8 @@ int Layout::findFace(FakedFont face, LayoutContext* ctx) { // Note: ctx == NULL means we're copying from the cache, no need to create // corresponding hb_font object. if (ctx != NULL) { - hb_font_t* font = create_hb_font(face.font, &ctx->paint); + hb_font_t* font = getHbFontLocked(face.font); + hb_font_set_funcs(font, getHbFontFuncs(), &ctx->paint, 0); ctx->hbFonts.push_back(font); } return ix; @@ -599,7 +584,6 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu start, mCollection, this, NULL); } ctx.clearHbFonts(); - mCollection->purgeFontFamilyHbFontCache(); } float Layout::measureText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, @@ -976,7 +960,7 @@ void Layout::purgeCaches() { AutoMutex _l(gMinikinLock); LayoutCache& layoutCache = LayoutEngine::getInstance().layoutCache; layoutCache.clear(); - purgeHbFaceCacheLocked(); + purgeHbFontCacheLocked(); } } // namespace android diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index 2483b763c4..d2aa5fd107 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -75,9 +75,9 @@ LOCAL_SRC_FILES += \ FontFamilyTest.cpp \ FontLanguageListCacheTest.cpp \ FontTestUtils.cpp \ + HbFontCacheTest.cpp \ MinikinFontForTest.cpp \ GraphemeBreakTests.cpp \ - HbFaceCacheTest.cpp \ LayoutUtilsTest.cpp \ UnicodeUtils.cpp diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index 6b32689081..fef464f1d7 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -378,18 +378,4 @@ TEST_F(FontFamilyTest, hasVariationSelectorTest) { expectVSGlyphs(&family, kNotSupportedChar, std::set()); } -TEST_F(FontFamilyTest, hasVariationSelectorWorksAfterpurgeHbFontCache) { - MinikinFontForTest minikinFont(kVsTestFont); - FontFamily family; - family.addFont(&minikinFont); - - const uint32_t kVS1 = 0xFE00; - const uint32_t kSupportedChar1 = 0x82A6; - - AutoMutex _l(gMinikinLock); - EXPECT_TRUE(family.hasVariationSelector(kSupportedChar1, kVS1)); - - family.purgeHbFontCache(); - EXPECT_TRUE(family.hasVariationSelector(kSupportedChar1, kVS1)); -} } // namespace android diff --git a/engine/src/flutter/tests/HbFaceCacheTest.cpp b/engine/src/flutter/tests/HbFaceCacheTest.cpp deleted file mode 100644 index 76eec5b5a8..0000000000 --- a/engine/src/flutter/tests/HbFaceCacheTest.cpp +++ /dev/null @@ -1,118 +0,0 @@ -/* - * 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. - */ - -#include - -#include "HbFaceCache.h" - -#include -#include -#include - -#include "MinikinInternal.h" -#include - -namespace android { -namespace { - -// A mock implementation of MinikinFont. The passed integer value will be -// returned in GetUniqueId(). -class MockMinikinFont : public MinikinFont { -public: - MockMinikinFont(int32_t id) : mId(id) { - } - - virtual float GetHorizontalAdvance(uint32_t /* glyph_id */, - const MinikinPaint& /* paint */) const { - LOG_ALWAYS_FATAL("MockMinikinFont::GetHorizontalAdvance is not implemented."); - return 0.0f; - } - - virtual void GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph_id */, - const MinikinPaint& /* paint */) const { - LOG_ALWAYS_FATAL("MockMinikinFont::GetBounds is not implemented."); - } - - virtual bool GetTable(uint32_t /* tag */, uint8_t* /* buf */, size_t* /* size */) { - LOG_ALWAYS_FATAL("MockMinikinFont::GetTable is not implemented."); - return false; - } - - virtual int32_t GetUniqueId() const { - return mId; - } - -private: - int32_t mId; -}; - -class HbFaceCacheTest : public testing::Test { -public: - virtual void TearDown() { - AutoMutex _l(gMinikinLock); - purgeHbFaceCacheLocked(); - } -}; - -TEST_F(HbFaceCacheTest, getHbFaceLockedTest) { - AutoMutex _l(gMinikinLock); - - MockMinikinFont fontA(1); - MockMinikinFont fontB(2); - MockMinikinFont fontC(2); - - // Never return NULL. - EXPECT_TRUE(getHbFaceLocked(&fontA)); - EXPECT_TRUE(getHbFaceLocked(&fontB)); - EXPECT_TRUE(getHbFaceLocked(&fontC)); - - // Must return same object if same font object is passed. - EXPECT_EQ(getHbFaceLocked(&fontA), getHbFaceLocked(&fontA)); - EXPECT_EQ(getHbFaceLocked(&fontB), getHbFaceLocked(&fontB)); - EXPECT_EQ(getHbFaceLocked(&fontC), getHbFaceLocked(&fontC)); - - // Different object must be returned if the passed minikinFont has different ID. - EXPECT_NE(getHbFaceLocked(&fontA), getHbFaceLocked(&fontB)); - EXPECT_NE(getHbFaceLocked(&fontA), getHbFaceLocked(&fontC)); - - // Same object must be returned if the minikinFont has same Id. - EXPECT_EQ(getHbFaceLocked(&fontB), getHbFaceLocked(&fontC)); -} - -TEST_F(HbFaceCacheTest, purgeCacheTest) { - AutoMutex _l(gMinikinLock); - MockMinikinFont font(1); - - hb_face_t* face = getHbFaceLocked(&font); - EXPECT_TRUE(face); - - // Set user data to identify the face object. - hb_user_data_key_t key; - void* data = (void*)0xdeadbeef; - hb_face_set_user_data(face, &key, data, NULL, false); - EXPECT_EQ(data, hb_face_get_user_data(face, &key)); - - purgeHbFaceCacheLocked(); - - // By checking user data, confirm that the object after purge is different from previously - // created one. Do not compare the returned pointer here since memory allocator may assign - // same region for new object. - face = getHbFaceLocked(&font); - EXPECT_EQ(nullptr, hb_face_get_user_data(face, &key)); -} - -} // namespace -} // namespace android diff --git a/engine/src/flutter/tests/HbFontCacheTest.cpp b/engine/src/flutter/tests/HbFontCacheTest.cpp new file mode 100644 index 0000000000..2dee61aff0 --- /dev/null +++ b/engine/src/flutter/tests/HbFontCacheTest.cpp @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2016 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 + +#include "HbFontCache.h" + +#include +#include +#include + +#include "MinikinInternal.h" +#include "MinikinFontForTest.h" +#include + +namespace android { +namespace { + +class HbFontCacheTest : public testing::Test { +public: + virtual void TearDown() { + AutoMutex _l(gMinikinLock); + purgeHbFontCacheLocked(); + } +}; + +TEST_F(HbFontCacheTest, getHbFontLockedTest) { + AutoMutex _l(gMinikinLock); + + MinikinFontForTest fontA(kTestFontDir "Regular.ttf"); + MinikinFontForTest fontB(kTestFontDir "Bold.ttf"); + MinikinFontForTest fontC(kTestFontDir "BoldItalic.ttf"); + + // Never return NULL. + EXPECT_NE(nullptr, getHbFontLocked(&fontA)); + EXPECT_NE(nullptr, getHbFontLocked(&fontB)); + EXPECT_NE(nullptr, getHbFontLocked(&fontC)); + + EXPECT_NE(nullptr, getHbFontLocked(nullptr)); + + // Must return same object if same font object is passed. + EXPECT_EQ(getHbFontLocked(&fontA), getHbFontLocked(&fontA)); + EXPECT_EQ(getHbFontLocked(&fontB), getHbFontLocked(&fontB)); + EXPECT_EQ(getHbFontLocked(&fontC), getHbFontLocked(&fontC)); + + // Different object must be returned if the passed minikinFont has different ID. + EXPECT_NE(getHbFontLocked(&fontA), getHbFontLocked(&fontB)); + EXPECT_NE(getHbFontLocked(&fontA), getHbFontLocked(&fontC)); +} + +TEST_F(HbFontCacheTest, purgeCacheTest) { + AutoMutex _l(gMinikinLock); + MinikinFontForTest minikinFont(kTestFontDir "Regular.ttf"); + + hb_font_t* font = getHbFontLocked(&minikinFont); + ASSERT_NE(nullptr, font); + + // Set user data to identify the font object. + hb_user_data_key_t key; + void* data = (void*)0xdeadbeef; + hb_font_set_user_data(font, &key, data, NULL, false); + ASSERT_EQ(data, hb_font_get_user_data(font, &key)); + + purgeHbFontCacheLocked(); + + // By checking user data, confirm that the object after purge is different from previously + // created one. Do not compare the returned pointer here since memory allocator may assign + // same region for new object. + font = getHbFontLocked(&minikinFont); + EXPECT_EQ(nullptr, hb_font_get_user_data(font, &key)); +} + +} // namespace +} // namespace android From 380658778eb18b611b37a360b246d8045cbc4c47 Mon Sep 17 00:00:00 2001 From: Keisuke Kuroyanagi Date: Tue, 2 Feb 2016 19:48:04 +0900 Subject: [PATCH 151/364] Optimize: Precompute the hash value for LayoutCacheKey. Bug: 24505153 Change-Id: If61c063c175086dec88cda187eafd9ce923e4cb1 --- engine/src/flutter/libs/minikin/Layout.cpp | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 71e0d890b7..3a05acfd9d 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -114,10 +114,14 @@ public: mStart(start), mCount(count), mId(collection->getId()), mStyle(style), mSize(paint.size), mScaleX(paint.scaleX), mSkewX(paint.skewX), mLetterSpacing(paint.letterSpacing), - mPaintFlags(paint.paintFlags), mHyphenEdit(paint.hyphenEdit), mIsRtl(dir) { + mPaintFlags(paint.paintFlags), mHyphenEdit(paint.hyphenEdit), mIsRtl(dir), + mHash(computeHash()) { } bool operator==(const LayoutCacheKey &other) const; - hash_t hash() const; + + hash_t hash() const { + return mHash; + } void copyText() { uint16_t* charsCopy = new uint16_t[mNchars]; @@ -152,6 +156,9 @@ private: bool mIsRtl; // Note: any fields added to MinikinPaint must also be reflected here. // TODO: language matching (possibly integrate into style) + hash_t mHash; + + hash_t computeHash() const; }; class LayoutCache : private OnEntryRemoved { @@ -230,7 +237,7 @@ bool LayoutCacheKey::operator==(const LayoutCacheKey& other) const { && !memcmp(mChars, other.mChars, mNchars * sizeof(uint16_t)); } -hash_t LayoutCacheKey::hash() const { +hash_t LayoutCacheKey::computeHash() const { uint32_t hash = JenkinsHashMix(0, mId); hash = JenkinsHashMix(hash, mStart); hash = JenkinsHashMix(hash, mCount); From aa48a657667f30ffb878e3ccd29e7ae2c21b5b87 Mon Sep 17 00:00:00 2001 From: Aurimas Liutikas Date: Thu, 11 Feb 2016 14:27:07 -0800 Subject: [PATCH 152/364] Fix two "unused parameter" warnings in minikin sample. Removing variables in main function of sample/example.cpp as they are not used. Bug: 26936282 Change-Id: I64ae0a455b413df333ddd4810a9e090d52322041 --- engine/src/flutter/sample/example.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index 3fbfa7910e..f4c6a07a4a 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -99,6 +99,6 @@ int runMinikinTest() { return 0; } -int main(int argc, const char** argv) { +int main() { return runMinikinTest(); } From 09481597e453ab3ce4fd4a1b4533ff2a2c5dd23a Mon Sep 17 00:00:00 2001 From: Dan Albert Date: Thu, 11 Feb 2016 20:38:19 -0800 Subject: [PATCH 153/364] Fix warnings. Bug: http://b/26936282 Change-Id: I91b3bc246a4a8c45bde223cfc25df18ae9af8c5b --- engine/src/flutter/include/minikin/Layout.h | 2 +- engine/src/flutter/libs/minikin/Android.mk | 4 ++-- engine/src/flutter/libs/minikin/Layout.cpp | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index cdf4aac523..a1c7155cda 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -59,7 +59,7 @@ struct LayoutGlyph { }; // Internal state used during layout operation -class LayoutContext; +struct LayoutContext; enum { kBidi_LTR = 0, diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 48d06c0847..293ebde9c7 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -48,6 +48,7 @@ minikin_shared_libraries := \ LOCAL_MODULE := libminikin LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_SRC_FILES := $(minikin_src_files) +LOCAL_CFLAGS := -Wno-unused-parameter LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) LOCAL_CLANG := true @@ -60,8 +61,8 @@ include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := libminikin -LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include +LOCAL_CFLAGS := -Wno-unused-parameter LOCAL_SRC_FILES := $(minikin_src_files) LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) @@ -77,7 +78,6 @@ include $(CLEAR_VARS) # Reduced library (currently just hyphenation) for host LOCAL_MODULE := libminikin_host -LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_SHARED_LIBRARIES := liblog libicuuc-host diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index be29e3ca2a..e6942477b0 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -302,7 +302,7 @@ hb_blob_t* referenceTable(hb_face_t* face, hb_tag_t tag, void* userData) { return 0; } ok = font->GetTable(tag, reinterpret_cast(buffer), &length); - printf("referenceTable %c%c%c%c length=%d %d\n", + printf("referenceTable %c%c%c%c length=%zu %d\n", (tag >>24) & 0xff, (tag>>16)&0xff, (tag>>8)&0xff, tag&0xff, length, ok); if (!ok) { free(buffer); @@ -810,7 +810,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t if (info[i].cluster - start < count) { mAdvances[info[i].cluster - start] += xAdvance; } else { - ALOGE("cluster %d (start %d) out of bounds of count %d", + ALOGE("cluster %ul (start %zu) out of bounds of count %zu", info[i].cluster - start, start, count); } x += xAdvance; From 9e8fd1dff74e2c696d3fd7a2873d982bcb0b06cd Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 11 Feb 2016 11:17:44 -0800 Subject: [PATCH 154/364] Add error logging on invalid cmap This patch logs instances of fonts with invalid cmap tables. Bug: 25645298 Bug: 26413177 Change-Id: I183985e9784a97a2b4307a22e036382b1fc90e5e --- engine/src/flutter/libs/minikin/CmapCoverage.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index 9f3447e62a..a4503af208 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -67,6 +67,7 @@ static bool getCoverageFormat4(vector& coverage, const uint8_t* data, uint32_t start = readU16(data, kHeaderSize + 2 * (segCount + i)); if (end < start) { // invalid segment range: size must be positive + android_errorWriteLog(0x534e4554, "26413177"); return false; } uint32_t rangeOffset = readU16(data, kHeaderSize + 2 * (3 * segCount + i)); @@ -113,6 +114,7 @@ static bool getCoverageFormat12(vector& coverage, const uint8_t* data, } uint32_t nGroups = readU32(data, kNGroupsOffset); if (nGroups >= kMaxNGroups || kFirstGroupOffset + nGroups * kGroupSize > size) { + android_errorWriteLog(0x534e4554, "25645298"); return false; } for (uint32_t i = 0; i < nGroups; i++) { @@ -121,6 +123,7 @@ static bool getCoverageFormat12(vector& coverage, const uint8_t* data, uint32_t end = readU32(data, groupOffset + kEndCharCodeOffset); if (end < start) { // invalid group range: size must be positive + android_errorWriteLog(0x534e4554, "26413177"); return false; } addRange(coverage, start, end + 1); // file is inclusive, vector is exclusive From ac3b9bc4ea57584b6b98307dc505567beaeedab1 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 11 Feb 2016 11:17:44 -0800 Subject: [PATCH 155/364] Add error logging on invalid cmap - DO NOT MERGE This patch logs instances of fonts with invalid cmap tables. Bug: 25645298 Bug: 26413177 Change-Id: I183985e9784a97a2b4307a22e036382b1fc90e5e --- engine/src/flutter/libs/minikin/CmapCoverage.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index 4c9643a1d4..d77253b114 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -20,6 +20,9 @@ #include #endif +#define LOG_TAG "Minikin" +#include + #include using std::vector; @@ -68,6 +71,7 @@ static bool getCoverageFormat4(vector& coverage, const uint8_t* data, uint32_t start = readU16(data, kHeaderSize + 2 * (segCount + i)); if (end < start) { // invalid segment range: size must be positive + android_errorWriteLog(0x534e4554, "26413177"); return false; } uint32_t rangeOffset = readU16(data, kHeaderSize + 2 * (3 * segCount + i)); @@ -113,6 +117,7 @@ static bool getCoverageFormat12(vector& coverage, const uint8_t* data, } uint32_t nGroups = readU32(data, kNGroupsOffset); if (nGroups >= kMaxNGroups || kFirstGroupOffset + nGroups * kGroupSize > size) { + android_errorWriteLog(0x534e4554, "25645298"); return false; } for (uint32_t i = 0; i < nGroups; i++) { @@ -121,6 +126,7 @@ static bool getCoverageFormat12(vector& coverage, const uint8_t* data, uint32_t end = readU32(data, groupOffset + kEndCharCodeOffset); if (end < start) { // invalid group range: size must be positive + android_errorWriteLog(0x534e4554, "26413177"); return false; } addRange(coverage, start, end + 1); // file is inclusive, vector is exclusive From c3b16d88941b337c2b0b861daf610bf9ca80f908 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Fri, 4 Sep 2015 17:23:05 -0700 Subject: [PATCH 156/364] Refine hyphenation around punctuation Implement a WordBreaker that defines our concept of valid word boundaries, customizing the ICU behavior. Currently, we suppress line breaks at soft hyphens (these are handled specially). Also, the new WordBreaker class has methods that determine the start and end of the word (punctuation stripped) for the purpose of hyphenation. This patch, in its current form, doesn't handle email addresses and URLs specially, but the WordBreaker class is the correct place to do so. Also, special case handling of hyphens and dashes is still done in LineBreaker, but all of that should be moved to WordBreaker. Bug: 20126487 Bug: 20566159 Change-Id: I492cbad963f9b74a2915f010dad46bb91f97b2fe --- .../src/flutter/include/minikin/LineBreaker.h | 9 +- .../src/flutter/include/minikin/WordBreaker.h | 67 +++++++++++ engine/src/flutter/libs/minikin/Android.mk | 3 +- .../src/flutter/libs/minikin/LineBreaker.cpp | 107 ++++++++--------- .../src/flutter/libs/minikin/WordBreaker.cpp | 110 ++++++++++++++++++ engine/src/flutter/tests/Android.mk | 3 +- engine/src/flutter/tests/WordBreakerTests.cpp | 79 +++++++++++++ 7 files changed, 311 insertions(+), 67 deletions(-) create mode 100644 engine/src/flutter/include/minikin/WordBreaker.h create mode 100644 engine/src/flutter/libs/minikin/WordBreaker.cpp create mode 100644 engine/src/flutter/tests/WordBreakerTests.cpp diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index e031fb3182..e28f11da44 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -27,6 +27,7 @@ #include #include #include "minikin/Hyphenator.h" +#include "minikin/WordBreaker.h" namespace android { @@ -102,11 +103,6 @@ class LineBreaker { public: const static int kTab_Shift = 29; // keep synchronized with TAB_MASK in StaticLayout.java - ~LineBreaker() { - utext_close(&mUText); - delete mBreakIterator; - } - // Note: Locale persists across multiple invocations (it is not cleaned up by finish()), // explicitly to avoid the cost of creating ICU BreakIterator objects. It should always // be set on the first invocation, but callers are encouraged not to call again unless @@ -214,8 +210,7 @@ class LineBreaker { void finishBreaksOptimal(); - icu::BreakIterator* mBreakIterator = nullptr; - UText mUText = UTEXT_INITIALIZER; + WordBreaker mWordBreaker; std::vectormTextBuf; std::vectormCharWidths; diff --git a/engine/src/flutter/include/minikin/WordBreaker.h b/engine/src/flutter/include/minikin/WordBreaker.h new file mode 100644 index 0000000000..22275bde84 --- /dev/null +++ b/engine/src/flutter/include/minikin/WordBreaker.h @@ -0,0 +1,67 @@ +/* + * 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. + */ + +/** + * A wrapper around ICU's line break iterator, that gives customized line + * break opportunities, as well as identifying words for the purpose of + * hyphenation. + */ + +#ifndef MINIKIN_WORD_BREAKER_H +#define MINIKIN_WORD_BREAKER_H + +#include "unicode/brkiter.h" +#include + +namespace android { + +class WordBreaker { +public: + ~WordBreaker() { + finish(); + } + + void setLocale(const icu::Locale& locale); + + void setText(const uint16_t* data, size_t size); + + // Advance iterator to next word break. Return offset, or -1 if EOT + ssize_t next(); + + // Current offset of iterator, equal to 0 at BOT or last return from next() + ssize_t current() const; + + // After calling next(), wordStart() and wordEnd() are offsets defining the previous + // word. If wordEnd <= wordStart, it's not a word for the purpose of hyphenation. + ssize_t wordStart() const; + + ssize_t wordEnd() const; + + void finish(); + +private: + std::unique_ptr mBreakIterator; + UText mUText = UTEXT_INITIALIZER; + const uint16_t* mText = nullptr; + size_t mTextSize; + ssize_t mLast; + ssize_t mCurrent; + bool mIteratorWasReset; +}; + +} // namespace + +#endif // MINIKIN_WORD_BREAKER_H diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 1fd0e6e8a0..7cd6f6883c 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -33,7 +33,8 @@ minikin_src_files := \ MinikinInternal.cpp \ MinikinRefCounted.cpp \ MinikinFontFreeType.cpp \ - SparseBitSet.cpp + SparseBitSet.cpp \ + WordBreaker.cpp minikin_c_includes := \ external/harfbuzz_ng/src \ diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index a2507e0ba8..214f19599d 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -29,7 +29,6 @@ using std::vector; namespace android { const int CHAR_TAB = 0x0009; -const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; // Large scores in a hierarchy; we prefer desperate breaks to an overfull line. All these // constants are larger than any reasonable actual width score. @@ -55,23 +54,16 @@ const size_t LONGEST_HYPHENATED_WORD = 45; const size_t MAX_TEXT_BUF_RETAIN = 32678; void LineBreaker::setLocale(const icu::Locale& locale, Hyphenator* hyphenator) { - delete mBreakIterator; - UErrorCode status = U_ZERO_ERROR; - mBreakIterator = icu::BreakIterator::createLineInstance(locale, status); - // TODO: check status + mWordBreaker.setLocale(locale); - // TODO: load actual resource dependent on locale; letting Minikin do it is a hack mHyphenator = hyphenator; } void LineBreaker::setText() { - UErrorCode status = U_ZERO_ERROR; - utext_openUChars(&mUText, mTextBuf.data(), mTextBuf.size(), &status); - mBreakIterator->setText(&mUText, status); - mBreakIterator->first(); + mWordBreaker.setText(mTextBuf.data(), mTextBuf.size()); // handle initial break here because addStyleRun may never be called - mBreakIterator->next(); + mWordBreaker.next(); mCandidates.clear(); Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0, 0, 0}; mCandidates.push_back(cand); @@ -151,8 +143,8 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa mLinePenalty = std::max(mLinePenalty, hyphenPenalty * LINE_PENALTY_MULTIPLIER); } - size_t current = (size_t)mBreakIterator->current(); - size_t wordEnd = start; + size_t current = (size_t)mWordBreaker.current(); + size_t afterWord = start; size_t lastBreak = start; ParaWidth lastBreakWidth = mWidth; ParaWidth postBreak = mWidth; @@ -170,58 +162,56 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa mWidth += mCharWidths[i]; if (!isLineEndSpace(c)) { postBreak = mWidth; - wordEnd = i + 1; + afterWord = i + 1; } } if (i + 1 == current) { - // Override ICU's treatment of soft hyphen as a break opportunity, because we want it - // to be a hyphen break, with penalty and drawing behavior. - if (c != CHAR_SOFT_HYPHEN) { - // TODO: Add a new type of HyphenEdit for breaks whose hyphen already exists, so - // we can pass the whole word down to Hyphenator like the soft hyphen case. - bool wordEndsInHyphen = isLineBreakingHyphen(c); - if (paint != nullptr && mHyphenator != nullptr && - mHyphenationFrequency != kHyphenationFrequency_None && - !wordEndsInHyphen && !temporarilySkipHyphenation && - wordEnd > lastBreak && wordEnd - lastBreak <= LONGEST_HYPHENATED_WORD) { - mHyphenator->hyphenate(&mHyphBuf, &mTextBuf[lastBreak], wordEnd - lastBreak); - #if VERBOSE_DEBUG - std::string hyphenatedString; - for (size_t j = lastBreak; j < wordEnd; j++) { - if (mHyphBuf[j - lastBreak]) hyphenatedString.push_back('-'); - // Note: only works with ASCII, should do UTF-8 conversion here - hyphenatedString.push_back(buffer()[j]); - } - ALOGD("hyphenated string: %s", hyphenatedString.c_str()); - #endif + // TODO: Add a new type of HyphenEdit for breaks whose hyphen already exists, so + // we can pass the whole word down to Hyphenator like the soft hyphen case. + bool wordEndsInHyphen = isLineBreakingHyphen(c); + size_t wordStart = mWordBreaker.wordStart(); + size_t wordEnd = mWordBreaker.wordEnd(); + if (paint != nullptr && mHyphenator != nullptr && + mHyphenationFrequency != kHyphenationFrequency_None && + !wordEndsInHyphen && !temporarilySkipHyphenation && + wordEnd > wordStart && wordEnd - wordStart <= LONGEST_HYPHENATED_WORD) { + mHyphenator->hyphenate(&mHyphBuf, &mTextBuf[wordStart], wordEnd - wordStart); +#if VERBOSE_DEBUG + std::string hyphenatedString; + for (size_t j = wordStart; j < wordEnd; j++) { + if (mHyphBuf[j - wordStart]) hyphenatedString.push_back('-'); + // Note: only works with ASCII, should do UTF-8 conversion here + hyphenatedString.push_back(buffer()[j]); + } + ALOGD("hyphenated string: %s", hyphenatedString.c_str()); +#endif - // measure hyphenated substrings - for (size_t j = lastBreak; j < wordEnd; j++) { - uint8_t hyph = mHyphBuf[j - lastBreak]; - if (hyph) { - paint->hyphenEdit = hyph; - layout.doLayout(mTextBuf.data(), lastBreak, j - lastBreak, - mTextBuf.size(), bidiFlags, style, *paint); - ParaWidth hyphPostBreak = lastBreakWidth + layout.getAdvance(); - paint->hyphenEdit = 0; - layout.doLayout(mTextBuf.data(), j, wordEnd - j, - mTextBuf.size(), bidiFlags, style, *paint); - ParaWidth hyphPreBreak = postBreak - layout.getAdvance(); - addWordBreak(j, hyphPreBreak, hyphPostBreak, hyphenPenalty, hyph); - } + // measure hyphenated substrings + for (size_t j = wordStart; j < wordEnd; j++) { + uint8_t hyph = mHyphBuf[j - wordStart]; + if (hyph) { + paint->hyphenEdit = hyph; + layout.doLayout(mTextBuf.data(), lastBreak, j - lastBreak, + mTextBuf.size(), bidiFlags, style, *paint); + ParaWidth hyphPostBreak = lastBreakWidth + layout.getAdvance(); + paint->hyphenEdit = 0; + layout.doLayout(mTextBuf.data(), j, afterWord - j, + mTextBuf.size(), bidiFlags, style, *paint); + ParaWidth hyphPreBreak = postBreak - layout.getAdvance(); + addWordBreak(j, hyphPreBreak, hyphPostBreak, hyphenPenalty, hyph); } } - // Skip hyphenating the next word if and only if the present word ends in a hyphen - temporarilySkipHyphenation = wordEndsInHyphen; - - // Skip break for zero-width characters inside replacement span - if (paint != nullptr || current == end || mCharWidths[current] > 0) { - addWordBreak(current, mWidth, postBreak, 0.0, 0); - } - lastBreak = current; - lastBreakWidth = mWidth; } - current = (size_t)mBreakIterator->next(); + // Skip hyphenating the next word if and only if the present word ends in a hyphen + temporarilySkipHyphenation = wordEndsInHyphen; + + // Skip break for zero-width characters inside replacement span + if (paint != nullptr || current == end || mCharWidths[current] > 0) { + addWordBreak(current, mWidth, postBreak, 0.0, 0); + } + lastBreak = current; + lastBreakWidth = mWidth; + current = (size_t)mWordBreaker.next(); } } @@ -425,6 +415,7 @@ size_t LineBreaker::computeBreaks() { } void LineBreaker::finish() { + mWordBreaker.finish(); mWidth = 0; mCandidates.clear(); mBreaks.clear(); diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp new file mode 100644 index 0000000000..b422a62af8 --- /dev/null +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -0,0 +1,110 @@ +/* + * 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. + */ + +#define LOG_TAG "Minikin" +#include + +#include "minikin/WordBreaker.h" + +#include +#include + +namespace android { + +const uint32_t CHAR_SOFT_HYPHEN = 0x00AD; + +void WordBreaker::setLocale(const icu::Locale& locale) { + UErrorCode status = U_ZERO_ERROR; + mBreakIterator.reset(icu::BreakIterator::createLineInstance(locale, status)); + // TODO: handle failure status + if (mText != nullptr) { + mBreakIterator->setText(&mUText, status); + } + mIteratorWasReset = true; +} + +void WordBreaker::setText(const uint16_t* data, size_t size) { + mText = data; + mTextSize = size; + mIteratorWasReset = false; + mLast = 0; + mCurrent = 0; + UErrorCode status = U_ZERO_ERROR; + utext_openUChars(&mUText, data, size, &status); + mBreakIterator->setText(&mUText, status); + mBreakIterator->first(); +} + +ssize_t WordBreaker::current() const { + return mCurrent; +} + +ssize_t WordBreaker::next() { + int32_t result; + mLast = mCurrent; + do { + if (mIteratorWasReset) { + result = mBreakIterator->following(mCurrent); + mIteratorWasReset = false; + } else { + result = mBreakIterator->next(); + } + } while (result != icu::BreakIterator::DONE && (size_t)result != mTextSize + && mText[result - 1] == CHAR_SOFT_HYPHEN); + mCurrent = (ssize_t)result; + return mCurrent; +} + +ssize_t WordBreaker::wordStart() const { + ssize_t result = mLast; + while (result < mCurrent) { + UChar32 c; + ssize_t ix = result; + U16_NEXT(mText, ix, mCurrent, c); + int32_t lb = u_getIntPropertyValue(c, UCHAR_LINE_BREAK); + // strip leading punctuation, defined as OP and QU line breaking classes, + // see UAX #14 + if (!(lb == U_LB_OPEN_PUNCTUATION || lb == U_LB_QUOTATION)) { + break; + } + result = ix; + } + return result; +} + +ssize_t WordBreaker::wordEnd() const { + ssize_t result = mCurrent; + while (result > mLast) { + UChar32 c; + ssize_t ix = result; + U16_PREV(mText, mLast, ix, c); + int32_t gc_mask = U_GET_GC_MASK(c); + // strip trailing space and punctuation + if ((gc_mask & (U_GC_ZS_MASK | U_GC_P_MASK)) == 0) { + break; + } + result = ix; + } + return result; +} + +void WordBreaker::finish() { + mText = nullptr; + // Note: calling utext_close multiply is safe + utext_close(&mUText); +} + +} // namespace android diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index d2aa5fd107..e6586d7178 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -79,7 +79,8 @@ LOCAL_SRC_FILES += \ MinikinFontForTest.cpp \ GraphemeBreakTests.cpp \ LayoutUtilsTest.cpp \ - UnicodeUtils.cpp + UnicodeUtils.cpp \ + WordBreakerTests.cpp LOCAL_C_INCLUDES := \ $(LOCAL_PATH)/../libs/minikin/ \ diff --git a/engine/src/flutter/tests/WordBreakerTests.cpp b/engine/src/flutter/tests/WordBreakerTests.cpp new file mode 100644 index 0000000000..d389d58cd1 --- /dev/null +++ b/engine/src/flutter/tests/WordBreakerTests.cpp @@ -0,0 +1,79 @@ +/* + * 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. + */ + +#include +#include "ICUTestBase.h" +#include "UnicodeUtils.h" +#include +#include +#include +#include + +#define LOG_TAG "Minikin" +#include + +#ifndef NELEM +#define NELEM(x) ((sizeof(x) / sizeof((x)[0]))) +#endif + +using namespace android; + +typedef ICUTestBase WordBreakerTest; + +TEST_F(WordBreakerTest, basic) { + uint16_t buf[] = {'h', 'e', 'l', 'l' ,'o', ' ', 'w', 'o', 'r', 'l', 'd'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(6, breaker.next()); // after "hello " + EXPECT_EQ(0, breaker.wordStart()); // "hello" + EXPECT_EQ(5, breaker.wordEnd()); + EXPECT_EQ(6, breaker.current()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(6, breaker.wordStart()); // "world" + EXPECT_EQ(11, breaker.wordEnd()); + EXPECT_EQ(11, breaker.current()); +} + +TEST_F(WordBreakerTest, softHyphen) { + uint16_t buf[] = {'h', 'e', 'l', 0x00AD, 'l' ,'o', ' ', 'w', 'o', 'r', 'l', 'd'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(7, breaker.next()); // after "hel{SOFT HYPHEN}lo " + EXPECT_EQ(0, breaker.wordStart()); // "hel{SOFT HYPHEN}lo" + EXPECT_EQ(6, breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(7, breaker.wordStart()); // "world" + EXPECT_EQ(12, breaker.wordEnd()); +} + +TEST_F(WordBreakerTest, punct) { + uint16_t buf[] = {0x00A1, 0x00A1, 'h', 'e', 'l', 'l' ,'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', + '!', '!'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(9, breaker.next()); // after "¡¡hello, " + EXPECT_EQ(2, breaker.wordStart()); // "hello" + EXPECT_EQ(7, breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(9, breaker.wordStart()); // "world" + EXPECT_EQ(14, breaker.wordEnd()); +} From 650392314e87e94c252b5792bd51d55bb0db4303 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 2 Feb 2016 15:42:37 +0900 Subject: [PATCH 157/364] Improve Paint.measureText and Paint.hasGlyph for variation sequences. Before this patch, the font fallback chain iterated all installed font families if a variation selector was specified. This CL narrows down the range of iteration. To decide the font family for the variation sequence, we need to search for both the variation sequence and its base code point. The new range of the iteration is a union of them. With this change, the running time of Paint.hasGlyph for the variation sequence improves 50% and the running time of Paint.measureText for the variation sequence improves 40% for the large text case on Nexus 6 userdebug. Bug: 26784699 Bug: 11750374 Change-Id: Iced1349e3ca750821d8882c551551f65bb569794 --- .../flutter/include/minikin/CmapCoverage.h | 3 +- .../flutter/include/minikin/FontCollection.h | 3 ++ .../src/flutter/include/minikin/FontFamily.h | 10 ++++- .../src/flutter/libs/minikin/CmapCoverage.cpp | 13 +++++- .../flutter/libs/minikin/FontCollection.cpp | 41 ++++++++++++------- .../src/flutter/libs/minikin/FontFamily.cpp | 12 +++++- engine/src/flutter/tests/FontFamilyTest.cpp | 27 ++++++++++++ 7 files changed, 91 insertions(+), 18 deletions(-) diff --git a/engine/src/flutter/include/minikin/CmapCoverage.h b/engine/src/flutter/include/minikin/CmapCoverage.h index 7054e315fd..56abac7bec 100644 --- a/engine/src/flutter/include/minikin/CmapCoverage.h +++ b/engine/src/flutter/include/minikin/CmapCoverage.h @@ -23,7 +23,8 @@ namespace android { class CmapCoverage { public: - static bool getCoverage(SparseBitSet &coverage, const uint8_t* cmap_data, size_t cmap_size); + static bool getCoverage(SparseBitSet &coverage, const uint8_t* cmap_data, size_t cmap_size, + bool* has_cmap_format14_subtable); }; } // namespace android diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 3a63c07948..5b9424c958 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -89,6 +89,9 @@ private: // This vector contains pointers into mInstances std::vector mFamilyVec; + // This vector has pointers to the font family instance which has cmap 14 subtable. + std::vector mVSFamilyVec; + // These are offsets into mInstanceVec, one range per page std::vector mRanges; }; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 2b59160ffa..149dc7b798 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -104,7 +104,11 @@ public: FontFamily(int variant); - FontFamily(uint32_t langId, int variant) : mLangId(langId), mVariant(variant) { + FontFamily(uint32_t langId, int variant) + : mLangId(langId), + mVariant(variant), + mHasVSTable(false), + mCoverageValid(false) { } ~FontFamily(); @@ -131,6 +135,9 @@ public: // Caller should acquire a lock before calling the method. bool hasVariationSelector(uint32_t codepoint, uint32_t variationSelector); + // Returns true if this font family has a variaion sequence table (cmap format 14 subtable). + bool hasVSTable() const; + private: void addFontLocked(MinikinFont* typeface, FontStyle style); @@ -146,6 +153,7 @@ private: std::vector mFonts; SparseBitSet mCoverage; + bool mHasVSTable; bool mCoverageValid; }; diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index 9f3447e62a..7d8446a44b 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -128,7 +128,8 @@ static bool getCoverageFormat12(vector& coverage, const uint8_t* data, return true; } -bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, size_t cmap_size) { +bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, size_t cmap_size, + bool* has_cmap_format14_subtable) { vector coverageVec; const size_t kHeaderSize = 4; const size_t kNumTablesOffset = 2; @@ -136,8 +137,10 @@ bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, const size_t kPlatformIdOffset = 0; const size_t kEncodingIdOffset = 2; const size_t kOffsetOffset = 4; + const uint16_t kUnicodePlatformId = 0; const uint16_t kMicrosoftPlatformId = 3; const uint16_t kUnicodeBmpEncodingId = 1; + const uint16_t kVariationSequencesEncodingId = 5; const uint16_t kUnicodeUcs4EncodingId = 10; const uint32_t kNoTable = UINT32_MAX; if (kHeaderSize > cmap_size) { @@ -148,6 +151,7 @@ bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, return false; } uint32_t bestTable = kNoTable; + bool hasCmapFormat14Subtable = false; for (uint32_t i = 0; i < numTables; i++) { uint16_t platformId = readU16(cmap_data, kHeaderSize + i * kTableSize + kPlatformIdOffset); uint16_t encodingId = readU16(cmap_data, kHeaderSize + i * kTableSize + kEncodingIdOffset); @@ -156,8 +160,15 @@ bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, break; } else if (platformId == kMicrosoftPlatformId && encodingId == kUnicodeBmpEncodingId) { bestTable = i; + } else if (platformId == kUnicodePlatformId && + encodingId == kVariationSequencesEncodingId) { + uint32_t offset = readU32(cmap_data, kHeaderSize + i * kTableSize + kOffsetOffset); + if (offset <= cmap_size - 2 && readU16(cmap_data, offset) == 14) { + hasCmapFormat14Subtable = true; + } } } + *has_cmap_format14_subtable = hasCmapFormat14Subtable; #ifdef VERBOSE_DEBUG ALOGD("best table = %d\n", bestTable); #endif diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 26aefe4490..dd905a3442 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -62,6 +62,9 @@ FontCollection::FontCollection(const vector& typefaces) : continue; } mFamilies.push_back(family); // emplace_back would be better + if (family->hasVSTable()) { + mVSFamilyVec.push_back(family); + } mMaxChar = max(mMaxChar, coverage->length()); lastChar.push_back(coverage->nextSetBit(0)); } @@ -233,15 +236,22 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, return NULL; } - // Even if the font supports variation sequence, mRanges isn't aware of the base character of - // the sequence. Search all FontFamilies if variation sequence is specified. - // TODO: Always use mRanges for font search. - const std::vector& familyVec = (vs == 0) ? mFamilyVec : mFamilies; - Range range; - if (vs == 0) { - range = mRanges[ch >> kLogCharsPerPage]; - } else { - range = { 0, mFamilies.size() }; + const std::vector* familyVec = &mFamilyVec; + Range range = mRanges[ch >> kLogCharsPerPage]; + + std::vector familyVecForVS; + if (vs != 0) { + // If variation selector is specified, need to search for both the variation sequence and + // its base codepoint. Compute the union vector of them. + familyVecForVS = mVSFamilyVec; + familyVecForVS.insert(familyVecForVS.end(), + mFamilyVec.begin() + range.start, mFamilyVec.begin() + range.end); + std::sort(familyVecForVS.begin(), familyVecForVS.end()); + auto last = std::unique(familyVecForVS.begin(), familyVecForVS.end()); + familyVecForVS.erase(last, familyVecForVS.end()); + + familyVec = &familyVecForVS; + range = { 0, familyVecForVS.size() }; } #ifdef VERBOSE_DEBUG @@ -250,7 +260,7 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, FontFamily* bestFamily = nullptr; uint32_t bestScore = kUnsupportedFontScore; for (size_t i = range.start; i < range.end; i++) { - FontFamily* family = familyVec[i]; + FontFamily* family = (*familyVec)[i]; const uint32_t score = calcFamilyScore(ch, vs, variant, langListId, family); if (score == kFirstFontScore) { // If the first font family supports the given character or variation sequence, always @@ -310,12 +320,15 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, if (baseCodepoint >= mMaxChar) { return false; } + if (variationSelector == 0) { + return false; + } + // Currently mRanges can not be used here since it isn't aware of the variation sequence. - // TODO: Use mRanges for narrowing down the search range. - for (size_t i = 0; i < mFamilies.size(); i++) { + for (size_t i = 0; i < mVSFamilyVec.size(); i++) { AutoMutex _l(gMinikinLock); - if (mFamilies[i]->hasVariationSelector(baseCodepoint, variationSelector)) { - return true; + if (mVSFamilyVec[i]->hasVariationSelector(baseCodepoint, variationSelector)) { + return true; } } return false; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 9eda3c2498..88448a10fd 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -177,7 +177,8 @@ const SparseBitSet* FontFamily::getCoverage() { ALOGE("Unexpected failure to read cmap table!\n"); return nullptr; } - CmapCoverage::getCoverage(mCoverage, cmapData.get(), cmapSize); // TODO: Error check? + // TODO: Error check? + CmapCoverage::getCoverage(mCoverage, cmapData.get(), cmapSize, &mHasVSTable); #ifdef VERBOSE_DEBUG ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), mCoverage.nextSetBit(0)); @@ -189,6 +190,10 @@ const SparseBitSet* FontFamily::getCoverage() { bool FontFamily::hasVariationSelector(uint32_t codepoint, uint32_t variationSelector) { assertMinikinLocked(); + if (!mHasVSTable) { + return false; + } + const FontStyle defaultStyle; MinikinFont* minikinFont = getClosestMatch(defaultStyle).font; hb_font_t* font = getHbFontLocked(minikinFont); @@ -196,4 +201,9 @@ bool FontFamily::hasVariationSelector(uint32_t codepoint, uint32_t variationSele return hb_font_get_glyph(font, codepoint, variationSelector, &unusedGlyph); } +bool FontFamily::hasVSTable() const { + LOG_ALWAYS_FATAL_IF(!mCoverageValid, "Do not call this method before getCoverage() call"); + return mHasVSTable; +} + } // namespace android diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index fef464f1d7..11407a3722 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -378,4 +378,31 @@ TEST_F(FontFamilyTest, hasVariationSelectorTest) { expectVSGlyphs(&family, kNotSupportedChar, std::set()); } +TEST_F(FontFamilyTest, hasVSTableTest) { + struct TestCase { + const std::string fontPath; + bool hasVSTable; + } testCases[] = { + { kTestFontDir "Ja.ttf", true }, + { kTestFontDir "ZhHant.ttf", true }, + { kTestFontDir "ZhHans.ttf", true }, + { kTestFontDir "Italic.ttf", false }, + { kTestFontDir "Bold.ttf", false }, + { kTestFontDir "BoldItalic.ttf", false }, + }; + + for (auto testCase : testCases) { + SCOPED_TRACE(testCase.hasVSTable ? + "Font " + testCase.fontPath + " should have a variation sequence table." : + "Font " + testCase.fontPath + " shouldn't have a variation sequence table."); + + MinikinFontForTest minikinFont(testCase.fontPath); + FontFamily family; + family.addFont(&minikinFont); + family.getCoverage(); + + EXPECT_EQ(testCase.hasVSTable, family.hasVSTable()); + } +} + } // namespace android From 76022a08e3f01db804d97c10277ee2704ef68f45 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Tue, 8 Sep 2015 17:12:10 -0700 Subject: [PATCH 158/364] Special-case URLs and email addresses for line breaking Detect URLs and email addresses, and suppress both line breaking and hyphenation within them. Bug: 20126487 Bug: 20566159 Change-Id: I43629347a063dcf579e355e5b678d7195f453ad9 --- .../src/flutter/include/minikin/WordBreaker.h | 4 ++ .../src/flutter/libs/minikin/WordBreaker.cpp | 61 +++++++++++++++- engine/src/flutter/tests/WordBreakerTests.cpp | 70 +++++++++++++++++++ 3 files changed, 134 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/include/minikin/WordBreaker.h b/engine/src/flutter/include/minikin/WordBreaker.h index 22275bde84..8c0050236e 100644 --- a/engine/src/flutter/include/minikin/WordBreaker.h +++ b/engine/src/flutter/include/minikin/WordBreaker.h @@ -60,6 +60,10 @@ private: ssize_t mLast; ssize_t mCurrent; bool mIteratorWasReset; + + // state for the email address / url detector + ssize_t mScanOffset; + bool mSuppressHyphen; }; } // namespace diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index b422a62af8..f438cd5546 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -42,6 +42,8 @@ void WordBreaker::setText(const uint16_t* data, size_t size) { mIteratorWasReset = false; mLast = 0; mCurrent = 0; + mScanOffset = 0; + mSuppressHyphen = false; UErrorCode status = U_ZERO_ERROR; utext_openUChars(&mUText, data, size, &status); mBreakIterator->setText(&mUText, status); @@ -52,9 +54,60 @@ ssize_t WordBreaker::current() const { return mCurrent; } +enum ScanState { + START, + SAW_AT, + SAW_COLON, + SAW_COLON_SLASH, + SAW_COLON_SLASH_SLASH, +}; + ssize_t WordBreaker::next() { - int32_t result; mLast = mCurrent; + + // scan forward from current ICU position for email address or URL + if (mLast >= mScanOffset) { + ScanState state = START; + size_t i; + for (i = mLast; i < mTextSize; i++) { + uint16_t c = mText[i]; + // scan only ASCII characters, stop at space + if (!(' ' < c && c <= 0x007E)) { + break; + } + if (state == START && c == '@') { + state = SAW_AT; + } else if (state == START && c == ':') { + state = SAW_COLON; + } else if (state == SAW_COLON || state == SAW_COLON_SLASH) { + if (c == '/') { + state = static_cast((int)state + 1); // next state adds a slash + } else { + state = START; + } + } + } + if (state == SAW_AT || state == SAW_COLON_SLASH_SLASH) { + // no line breaks in entire email address or url + // TODO: refine this according to Chicago Manual of Style rules + while (i < mTextSize && mText[i] == ' ') { + i++; + } + mCurrent = i; + mSuppressHyphen = true; + // Setting mIteratorWasReset will cause next break to be computed following + // mCurrent, rather than following the current ICU iterator location. + mIteratorWasReset = true; + if (mBreakIterator->isBoundary(mCurrent)) { + return mCurrent; + } + } else { + mScanOffset = i; + mSuppressHyphen = false; + } + } + + int32_t result; do { if (mIteratorWasReset) { result = mBreakIterator->following(mCurrent); @@ -69,6 +122,9 @@ ssize_t WordBreaker::next() { } ssize_t WordBreaker::wordStart() const { + if (mSuppressHyphen) { + return mLast; + } ssize_t result = mLast; while (result < mCurrent) { UChar32 c; @@ -86,6 +142,9 @@ ssize_t WordBreaker::wordStart() const { } ssize_t WordBreaker::wordEnd() const { + if (mSuppressHyphen) { + return mLast; + } ssize_t result = mCurrent; while (result > mLast) { UChar32 c; diff --git a/engine/src/flutter/tests/WordBreakerTests.cpp b/engine/src/flutter/tests/WordBreakerTests.cpp index d389d58cd1..4111a1b1f4 100644 --- a/engine/src/flutter/tests/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/WordBreakerTests.cpp @@ -77,3 +77,73 @@ TEST_F(WordBreakerTest, punct) { EXPECT_EQ(9, breaker.wordStart()); // "world" EXPECT_EQ(14, breaker.wordEnd()); } + +TEST_F(WordBreakerTest, email) { + uint16_t buf[] = {'f', 'o', 'o', '@', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', + ' ', 'x'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(16, breaker.next()); // after "foo@example.com " + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(16, breaker.wordStart()); // "x" + EXPECT_EQ(17, breaker.wordEnd()); +} + +TEST_F(WordBreakerTest, mailto) { + uint16_t buf[] = {'m', 'a', 'i', 'l', 't', 'o', ':', 'f', 'o', 'o', '@', + 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', ' ', 'x'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(23, breaker.next()); // after "mailto:foo@example.com " + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(23, breaker.wordStart()); // "x" + EXPECT_EQ(24, breaker.wordEnd()); +} + +TEST_F(WordBreakerTest, emailNonAscii) { + uint16_t buf[] = {'f', 'o', 'o', '@', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', + 0x4E00}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(15, breaker.next()); // after "foo@example.com" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(15, breaker.wordStart()); // "一" + EXPECT_EQ(16, breaker.wordEnd()); +} + +TEST_F(WordBreakerTest, emailCombining) { + uint16_t buf[] = {'f', 'o', 'o', '@', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', + 0x0303, ' ', 'x'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(17, breaker.next()); // after "foo@example.com̃" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(17, breaker.wordStart()); // "x" + EXPECT_EQ(18, breaker.wordEnd()); +} + +TEST_F(WordBreakerTest, url) { + uint16_t buf[] = {'h', 't', 't', 'p', ':', '/', '/', 'e', 'x', 'a', 'm', 'p', 'l', 'e', + '.', 'c', 'o', 'm', ' ', 'x'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(19, breaker.next()); // after "http://example.com " + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(19, breaker.wordStart()); // "x" + EXPECT_EQ(20, breaker.wordEnd()); +} From 5102c20dd50fde7ab9cdcdce173f53a6cacbd9e0 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Tue, 8 Sep 2015 18:19:53 -0700 Subject: [PATCH 159/364] Add line breaks to email addresses and URLs This change adds accceptable line breaks according to sections 7.42 (Dividing URLs and e-mail addresses) and 14.12 (URLs or DOIs and line breaks) of the Chicago Manual of Style (16th ed.). In general, these place breaks before punctuation symbols, and suppresses them after hyphens. Bug: 20126487 Bug: 20566159 Change-Id: I2d07d516b920a506a2f718c38fb435c5eb1ee1f8 --- .../src/flutter/include/minikin/WordBreaker.h | 2 +- .../src/flutter/libs/minikin/WordBreaker.cpp | 65 ++++++--- engine/src/flutter/tests/WordBreakerTests.cpp | 130 +++++++++++++++++- 3 files changed, 175 insertions(+), 22 deletions(-) diff --git a/engine/src/flutter/include/minikin/WordBreaker.h b/engine/src/flutter/include/minikin/WordBreaker.h index 8c0050236e..c4aa1514a0 100644 --- a/engine/src/flutter/include/minikin/WordBreaker.h +++ b/engine/src/flutter/include/minikin/WordBreaker.h @@ -63,7 +63,7 @@ private: // state for the email address / url detector ssize_t mScanOffset; - bool mSuppressHyphen; + bool mInEmailOrUrl; }; } // namespace diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index f438cd5546..edac993d44 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -43,7 +43,7 @@ void WordBreaker::setText(const uint16_t* data, size_t size) { mLast = 0; mCurrent = 0; mScanOffset = 0; - mSuppressHyphen = false; + mInEmailOrUrl = false; UErrorCode status = U_ZERO_ERROR; utext_openUChars(&mUText, data, size, &status); mBreakIterator->setText(&mUText, status); @@ -62,6 +62,17 @@ enum ScanState { SAW_COLON_SLASH_SLASH, }; +// Chicago Manual of Style recommends breaking after these characters in URLs and email addresses +static bool breakAfter(uint16_t c) { + return c == ':' || c == '=' || c == '&'; +} + +// Chicago Manual of Style recommends breaking before these characters in URLs and email addresses +static bool breakBefore(uint16_t c) { + return c == '~' || c == '.' || c == ',' || c == '-' || c == '_' || c == '?' || c == '#' + || c == '%' || c == '=' || c == '&'; +} + ssize_t WordBreaker::next() { mLast = mCurrent; @@ -88,23 +99,45 @@ ssize_t WordBreaker::next() { } } if (state == SAW_AT || state == SAW_COLON_SLASH_SLASH) { - // no line breaks in entire email address or url - // TODO: refine this according to Chicago Manual of Style rules - while (i < mTextSize && mText[i] == ' ') { - i++; + if (!mBreakIterator->isBoundary(i)) { + i = mBreakIterator->following(i); } - mCurrent = i; - mSuppressHyphen = true; - // Setting mIteratorWasReset will cause next break to be computed following - // mCurrent, rather than following the current ICU iterator location. + mInEmailOrUrl = true; mIteratorWasReset = true; - if (mBreakIterator->isBoundary(mCurrent)) { - return mCurrent; - } } else { - mScanOffset = i; - mSuppressHyphen = false; + mInEmailOrUrl = false; } + mScanOffset = i; + } + + if (mInEmailOrUrl) { + // special rules for email addresses and URL's as per Chicago Manual of Style (16th ed.) + uint16_t lastChar = mText[mLast]; + ssize_t i; + for (i = mLast + 1; i < mScanOffset; i++) { + if (breakAfter(lastChar)) { + break; + } + // break after double slash + if (lastChar == '/' && i >= mLast + 2 && mText[i - 2] == '/') { + break; + } + uint16_t thisChar = mText[i]; + // never break after hyphen + if (lastChar != '-') { + if (breakBefore(thisChar)) { + break; + } + // break before single slash + if (thisChar == '/' && lastChar != '/' && + !(i + 1 < mScanOffset && mText[i + 1] == '/')) { + break; + } + } + lastChar = thisChar; + } + mCurrent = i; + return mCurrent; } int32_t result; @@ -122,7 +155,7 @@ ssize_t WordBreaker::next() { } ssize_t WordBreaker::wordStart() const { - if (mSuppressHyphen) { + if (mInEmailOrUrl) { return mLast; } ssize_t result = mLast; @@ -142,7 +175,7 @@ ssize_t WordBreaker::wordStart() const { } ssize_t WordBreaker::wordEnd() const { - if (mSuppressHyphen) { + if (mInEmailOrUrl) { return mLast; } ssize_t result = mCurrent; diff --git a/engine/src/flutter/tests/WordBreakerTests.cpp b/engine/src/flutter/tests/WordBreakerTests.cpp index 4111a1b1f4..284b02cb28 100644 --- a/engine/src/flutter/tests/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/WordBreakerTests.cpp @@ -85,7 +85,9 @@ TEST_F(WordBreakerTest, email) { breaker.setLocale(icu::Locale::getEnglish()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); - EXPECT_EQ(16, breaker.next()); // after "foo@example.com " + EXPECT_EQ(11, breaker.next()); // after "foo@example" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(16, breaker.next()); // after ".com " EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(16, breaker.wordStart()); // "x" @@ -99,13 +101,19 @@ TEST_F(WordBreakerTest, mailto) { breaker.setLocale(icu::Locale::getEnglish()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); - EXPECT_EQ(23, breaker.next()); // after "mailto:foo@example.com " + EXPECT_EQ(7, breaker.next()); // after "mailto:" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(18, breaker.next()); // after "foo@example" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(23, breaker.next()); // after ".com " EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(23, breaker.wordStart()); // "x" EXPECT_EQ(24, breaker.wordEnd()); } +// The current logic always places a line break after a detected email address or URL +// and an immediately following non-ASCII character. TEST_F(WordBreakerTest, emailNonAscii) { uint16_t buf[] = {'f', 'o', 'o', '@', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', 0x4E00}; @@ -113,7 +121,9 @@ TEST_F(WordBreakerTest, emailNonAscii) { breaker.setLocale(icu::Locale::getEnglish()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); - EXPECT_EQ(15, breaker.next()); // after "foo@example.com" + EXPECT_EQ(11, breaker.next()); // after "foo@example" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(15, breaker.next()); // after ".com" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(15, breaker.wordStart()); // "一" @@ -127,13 +137,31 @@ TEST_F(WordBreakerTest, emailCombining) { breaker.setLocale(icu::Locale::getEnglish()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); - EXPECT_EQ(17, breaker.next()); // after "foo@example.com̃" + EXPECT_EQ(11, breaker.next()); // after "foo@example" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(17, breaker.next()); // after ".com̃ " EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(17, breaker.wordStart()); // "x" EXPECT_EQ(18, breaker.wordEnd()); } +TEST_F(WordBreakerTest, lonelyAt) { + uint16_t buf[] = {'a', ' ', '@', ' ', 'b'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(2, breaker.next()); // after "a " + EXPECT_EQ(0, breaker.wordStart()); // "a" + EXPECT_EQ(1, breaker.wordEnd()); + EXPECT_EQ(4, breaker.next()); // after "@ " + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(4, breaker.wordStart()); // "b" + EXPECT_EQ(5, breaker.wordEnd()); +} + TEST_F(WordBreakerTest, url) { uint16_t buf[] = {'h', 't', 't', 'p', ':', '/', '/', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', ' ', 'x'}; @@ -141,9 +169,101 @@ TEST_F(WordBreakerTest, url) { breaker.setLocale(icu::Locale::getEnglish()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); - EXPECT_EQ(19, breaker.next()); // after "http://example.com " + EXPECT_EQ(5, breaker.next()); // after "http:" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(7, breaker.next()); // after "//" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(14, breaker.next()); // after "example" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(19, breaker.next()); // after ".com " EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(19, breaker.wordStart()); // "x" EXPECT_EQ(20, breaker.wordEnd()); } + +// Breaks according to section 14.12 of Chicago Manual of Style, *URLs or DOIs and line breaks* +TEST_F(WordBreakerTest, urlBreakChars) { + uint16_t buf[] = {'h', 't', 't', 'p', ':', '/', '/', 'a', '.', 'b', '/', '~', 'c', ',', 'd', + '-', 'e', '?', 'f', '=', 'g', '&', 'h', '#', 'i', '%', 'j', '_', 'k', '/', 'l'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(5, breaker.next()); // after "http:" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(7, breaker.next()); // after "//" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(8, breaker.next()); // after "a" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(10, breaker.next()); // after ".b" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(11, breaker.next()); // after "/" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(13, breaker.next()); // after "~c" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(15, breaker.next()); // after ",d" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(17, breaker.next()); // after "-e" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(19, breaker.next()); // after "?f" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(20, breaker.next()); // after "=" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(21, breaker.next()); // after "g" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(22, breaker.next()); // after "&" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(23, breaker.next()); // after "h" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(25, breaker.next()); // after "#i" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(27, breaker.next()); // after "%j" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(29, breaker.next()); // after "_k" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); +} + +TEST_F(WordBreakerTest, urlNoHyphenBreak) { + uint16_t buf[] = {'h', 't', 't', 'p', ':', '/', '/', 'a', '-', '/', 'b'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(5, breaker.next()); // after "http:" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(7, breaker.next()); // after "//" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(8, breaker.next()); // after "a" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); +} + +TEST_F(WordBreakerTest, urlEndsWithSlash) { + uint16_t buf[] = {'h', 't', 't', 'p', ':', '/', '/', 'a', '/'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(5, breaker.next()); // after "http:" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(7, breaker.next()); // after "//" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(8, breaker.next()); // after "a" + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); +} + +TEST_F(WordBreakerTest, emailStartsWithSlash) { + uint16_t buf[] = {'/', 'a', '@', 'b'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); +} From 76772e8ad4a88cbe87edc873dd66af7d0baf6a25 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Tue, 8 Sep 2015 20:52:56 -0700 Subject: [PATCH 160/364] Add penalty for breaks in URLs and email addresses Recent changes have added special cases for line breaks within URLs and email addresses. Such breaks are undesirable when they can be avoided, but at other times are needed to avoid huge gaps, or indeed to make the line fit at all. This patch assigns a penalty for such breaks, equal to the hyphenation penalty. The mechanism is currently very simple, but would be easy to fine-tune based on more detailed information about break quality. Bug: 20126487 Bug: 20566159 Change-Id: I0d3323897737a2850f1e734fa17b96b065eabd9c --- .../src/flutter/include/minikin/WordBreaker.h | 2 + .../src/flutter/libs/minikin/LineBreaker.cpp | 3 +- .../src/flutter/libs/minikin/WordBreaker.cpp | 4 ++ engine/src/flutter/tests/WordBreakerTests.cpp | 44 +++++++++++++++++++ 4 files changed, 52 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/include/minikin/WordBreaker.h b/engine/src/flutter/include/minikin/WordBreaker.h index c4aa1514a0..4eff9d1755 100644 --- a/engine/src/flutter/include/minikin/WordBreaker.h +++ b/engine/src/flutter/include/minikin/WordBreaker.h @@ -50,6 +50,8 @@ public: ssize_t wordEnd() const; + int breakBadness() const; + void finish(); private: diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 214f19599d..9cf07d5d9e 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -207,7 +207,8 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa // Skip break for zero-width characters inside replacement span if (paint != nullptr || current == end || mCharWidths[current] > 0) { - addWordBreak(current, mWidth, postBreak, 0.0, 0); + float penalty = hyphenPenalty * mWordBreaker.breakBadness(); + addWordBreak(current, mWidth, postBreak, penalty, 0); } lastBreak = current; lastBreakWidth = mWidth; diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index edac993d44..ca69a50307 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -193,6 +193,10 @@ ssize_t WordBreaker::wordEnd() const { return result; } +int WordBreaker::breakBadness() const { + return (mInEmailOrUrl && mCurrent < mScanOffset) ? 1 : 0; +} + void WordBreaker::finish() { mText = nullptr; // Note: calling utext_close multiply is safe diff --git a/engine/src/flutter/tests/WordBreakerTests.cpp b/engine/src/flutter/tests/WordBreakerTests.cpp index 284b02cb28..9662b2f7a4 100644 --- a/engine/src/flutter/tests/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/WordBreakerTests.cpp @@ -42,10 +42,12 @@ TEST_F(WordBreakerTest, basic) { EXPECT_EQ(6, breaker.next()); // after "hello " EXPECT_EQ(0, breaker.wordStart()); // "hello" EXPECT_EQ(5, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); EXPECT_EQ(6, breaker.current()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(6, breaker.wordStart()); // "world" EXPECT_EQ(11, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); EXPECT_EQ(11, breaker.current()); } @@ -58,9 +60,11 @@ TEST_F(WordBreakerTest, softHyphen) { EXPECT_EQ(7, breaker.next()); // after "hel{SOFT HYPHEN}lo " EXPECT_EQ(0, breaker.wordStart()); // "hel{SOFT HYPHEN}lo" EXPECT_EQ(6, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(7, breaker.wordStart()); // "world" EXPECT_EQ(12, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); } TEST_F(WordBreakerTest, punct) { @@ -73,9 +77,11 @@ TEST_F(WordBreakerTest, punct) { EXPECT_EQ(9, breaker.next()); // after "¡¡hello, " EXPECT_EQ(2, breaker.wordStart()); // "hello" EXPECT_EQ(7, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(9, breaker.wordStart()); // "world" EXPECT_EQ(14, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); } TEST_F(WordBreakerTest, email) { @@ -87,11 +93,14 @@ TEST_F(WordBreakerTest, email) { EXPECT_EQ(0, breaker.current()); EXPECT_EQ(11, breaker.next()); // after "foo@example" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(16, breaker.next()); // after ".com " EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(16, breaker.wordStart()); // "x" EXPECT_EQ(17, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); } TEST_F(WordBreakerTest, mailto) { @@ -103,13 +112,17 @@ TEST_F(WordBreakerTest, mailto) { EXPECT_EQ(0, breaker.current()); EXPECT_EQ(7, breaker.next()); // after "mailto:" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(18, breaker.next()); // after "foo@example" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(23, breaker.next()); // after ".com " EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(23, breaker.wordStart()); // "x" EXPECT_EQ(24, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); } // The current logic always places a line break after a detected email address or URL @@ -123,11 +136,14 @@ TEST_F(WordBreakerTest, emailNonAscii) { EXPECT_EQ(0, breaker.current()); EXPECT_EQ(11, breaker.next()); // after "foo@example" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(15, breaker.next()); // after ".com" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(15, breaker.wordStart()); // "一" EXPECT_EQ(16, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); } TEST_F(WordBreakerTest, emailCombining) { @@ -139,11 +155,14 @@ TEST_F(WordBreakerTest, emailCombining) { EXPECT_EQ(0, breaker.current()); EXPECT_EQ(11, breaker.next()); // after "foo@example" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(17, breaker.next()); // after ".com̃ " EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(17, breaker.wordStart()); // "x" EXPECT_EQ(18, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); } TEST_F(WordBreakerTest, lonelyAt) { @@ -155,11 +174,14 @@ TEST_F(WordBreakerTest, lonelyAt) { EXPECT_EQ(2, breaker.next()); // after "a " EXPECT_EQ(0, breaker.wordStart()); // "a" EXPECT_EQ(1, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); EXPECT_EQ(4, breaker.next()); // after "@ " EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(4, breaker.wordStart()); // "b" EXPECT_EQ(5, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); } TEST_F(WordBreakerTest, url) { @@ -171,15 +193,20 @@ TEST_F(WordBreakerTest, url) { EXPECT_EQ(0, breaker.current()); EXPECT_EQ(5, breaker.next()); // after "http:" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(7, breaker.next()); // after "//" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(14, breaker.next()); // after "example" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(19, breaker.next()); // after ".com " EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_EQ(19, breaker.wordStart()); // "x" EXPECT_EQ(20, breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); } // Breaks according to section 14.12 of Chicago Manual of Style, *URLs or DOIs and line breaks* @@ -192,38 +219,55 @@ TEST_F(WordBreakerTest, urlBreakChars) { EXPECT_EQ(0, breaker.current()); EXPECT_EQ(5, breaker.next()); // after "http:" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(7, breaker.next()); // after "//" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(8, breaker.next()); // after "a" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(10, breaker.next()); // after ".b" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(11, breaker.next()); // after "/" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(13, breaker.next()); // after "~c" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(15, breaker.next()); // after ",d" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(17, breaker.next()); // after "-e" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(19, breaker.next()); // after "?f" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(20, breaker.next()); // after "=" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(21, breaker.next()); // after "g" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(22, breaker.next()); // after "&" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(23, breaker.next()); // after "h" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(25, breaker.next()); // after "#i" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(27, breaker.next()); // after "%j" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ(29, breaker.next()); // after "_k" EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(1, breaker.breakBadness()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); } TEST_F(WordBreakerTest, urlNoHyphenBreak) { From 77c3f8eb24dce937de1406c4832f34fbd7f788ec Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Fri, 22 Jan 2016 18:35:52 +0900 Subject: [PATCH 161/364] Support Hanb script. Hanb is a union of Han and Bopomofo. Bug: 26687969 Change-Id: Ic696bcbbc9607f3842fd0115668b8e7bd917e62b --- .../src/flutter/libs/minikin/FontLanguage.cpp | 7 +++++++ engine/src/flutter/libs/minikin/FontLanguage.h | 17 +++++++++-------- engine/src/flutter/tests/FontFamilyTest.cpp | 12 ++++++++++++ 3 files changed, 28 insertions(+), 8 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontLanguage.cpp b/engine/src/flutter/libs/minikin/FontLanguage.cpp index 8e5c9c481f..db630592b8 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguage.cpp @@ -61,9 +61,16 @@ FontLanguage::FontLanguage(const char* buf, size_t length) : FontLanguage() { uint8_t FontLanguage::scriptToSubScriptBits(uint32_t script) { uint8_t subScriptBits = 0u; switch (script) { + case SCRIPT_TAG('B', 'o', 'p', 'o'): + subScriptBits = kBopomofoFlag; + break; case SCRIPT_TAG('H', 'a', 'n', 'g'): subScriptBits = kHangulFlag; break; + case SCRIPT_TAG('H', 'a', 'n', 'b'): + // Bopomofo is almost exclusively used in Taiwan. + subScriptBits = kHanFlag | kBopomofoFlag; + break; case SCRIPT_TAG('H', 'a', 'n', 'i'): subScriptBits = kHanFlag; break; diff --git a/engine/src/flutter/libs/minikin/FontLanguage.h b/engine/src/flutter/libs/minikin/FontLanguage.h index ee0b505bdd..1a20480fb5 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.h +++ b/engine/src/flutter/libs/minikin/FontLanguage.h @@ -68,14 +68,15 @@ private: // mLanguage = 0 means the FontLanguage is unsupported. uint32_t mLanguage; - // For faster comparing, use 7 bits for specific scripts. - static const uint8_t kEmojiFlag = 1u; - static const uint8_t kHanFlag = 1u << 1; - static const uint8_t kHangulFlag = 1u << 2; - static const uint8_t kHiraganaFlag = 1u << 3; - static const uint8_t kKatakanaFlag = 1u << 4; - static const uint8_t kSimplifiedChineseFlag = 1u << 5; - static const uint8_t kTraditionalChineseFlag = 1u << 6; + // For faster comparing, use 8 bits for specific scripts. + static const uint8_t kBopomofoFlag = 1u; + static const uint8_t kEmojiFlag = 1u << 1; + static const uint8_t kHanFlag = 1u << 2; + static const uint8_t kHangulFlag = 1u << 3; + static const uint8_t kHiraganaFlag = 1u << 4; + static const uint8_t kKatakanaFlag = 1u << 5; + static const uint8_t kSimplifiedChineseFlag = 1u << 6; + static const uint8_t kTraditionalChineseFlag = 1u << 7; uint8_t mSubScriptBits; static uint8_t scriptToSubScriptBits(uint32_t script); diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index fef464f1d7..beaa05488f 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -131,6 +131,7 @@ TEST_F(FontLanguageTest, ScriptMatchTest) { { "zh-Hani", "Hani", SUPPORTED }, { "ko-Kore", "Kore", SUPPORTED }, { "ko-Hang", "Hang", SUPPORTED }, + { "zh-Hanb", "Hanb", SUPPORTED }, // Japanese supports Hiragana, Katakanara, etc. { "ja-Jpan", "Hira", SUPPORTED }, @@ -142,6 +143,10 @@ TEST_F(FontLanguageTest, ScriptMatchTest) { // Chinese supports Han. { "zh-Hans", "Hani", SUPPORTED }, { "zh-Hant", "Hani", SUPPORTED }, + { "zh-Hanb", "Hani", SUPPORTED }, + + // Hanb supports Bopomofo. + { "zh-Hanb", "Bopo", SUPPORTED }, // Korean supports Hangul. { "ko-Kore", "Hang", SUPPORTED }, @@ -176,12 +181,19 @@ TEST_F(FontLanguageTest, ScriptMatchTest) { // Kanji doesn't support Chinese, etc. { "zh-Hani", "Hant", NOT_SUPPORTED }, { "zh-Hani", "Hans", NOT_SUPPORTED }, + { "zh-Hani", "Hanb", NOT_SUPPORTED }, // Hangul doesn't support Korean, etc. { "ko-Hang", "Kore", NOT_SUPPORTED }, { "ko-Hani", "Kore", NOT_SUPPORTED }, { "ko-Hani", "Hang", NOT_SUPPORTED }, { "ko-Hang", "Hani", NOT_SUPPORTED }, + + // Han with botomofo doesn't support simplified Chinese, etc. + { "zh-Hanb", "Hant", NOT_SUPPORTED }, + { "zh-Hanb", "Hans", NOT_SUPPORTED }, + { "zh-Hanb", "Jpan", NOT_SUPPORTED }, + { "zh-Hanb", "Kore", NOT_SUPPORTED }, }; for (auto testCase : testCases) { From 72ab39455f2fe587116066d5ec66d75cd89f0114 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 18 Feb 2016 10:27:38 -0800 Subject: [PATCH 162/364] Disable hyphenation when word overlaps style boundary In cases when a word (as defined by the ICU break iterator) overlaps a style boundary, the returned wordStart can be extend before the range currently being measured for layout. When we try to hyphenate the resulting substrings, we get a negative range, which crashes. This patch disables hyphenation in this case. Bug: 27237112 Change-Id: I76d04b39dd3b4d6d267aaaf4bebc9ab361891646 --- engine/src/flutter/libs/minikin/LineBreaker.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 9cf07d5d9e..22c39547ae 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -174,7 +174,8 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa if (paint != nullptr && mHyphenator != nullptr && mHyphenationFrequency != kHyphenationFrequency_None && !wordEndsInHyphen && !temporarilySkipHyphenation && - wordEnd > wordStart && wordEnd - wordStart <= LONGEST_HYPHENATED_WORD) { + wordStart >= start && wordEnd > wordStart && + wordEnd - wordStart <= LONGEST_HYPHENATED_WORD) { mHyphenator->hyphenate(&mHyphBuf, &mTextBuf[wordStart], wordEnd - wordStart); #if VERBOSE_DEBUG std::string hyphenatedString; From 761218bce9059c4c73e5089ce5924913cbd5fb6f Mon Sep 17 00:00:00 2001 From: Keisuke Kuroyanagi Date: Thu, 18 Feb 2016 11:35:42 -0800 Subject: [PATCH 163/364] Optimize: Use measureText instead of doLayout. With this CL, measureText is used for getRunAdvance, getOffsetForAdvance and line breaking. Bug: 24505153 Change-Id: Ib699f6b1391b46537736fc274cdb41686586b550 --- .../src/flutter/include/minikin/Measurement.h | 5 ++-- .../src/flutter/libs/minikin/LineBreaker.cpp | 24 +++++++++---------- .../src/flutter/libs/minikin/Measurement.cpp | 20 ++++++++-------- 3 files changed, 25 insertions(+), 24 deletions(-) diff --git a/engine/src/flutter/include/minikin/Measurement.h b/engine/src/flutter/include/minikin/Measurement.h index fc47fa3162..7bcab669de 100644 --- a/engine/src/flutter/include/minikin/Measurement.h +++ b/engine/src/flutter/include/minikin/Measurement.h @@ -21,9 +21,10 @@ namespace android { -float getRunAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t count, size_t offset); +float getRunAdvance(const float* advances, const uint16_t* buf, size_t start, size_t count, + size_t offset); -size_t getOffsetForAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t count, +size_t getOffsetForAdvance(const float* advances, const uint16_t* buf, size_t start, size_t count, float advance); } diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 22c39547ae..9c4ff6f3be 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -122,17 +122,13 @@ static bool isLineBreakingHyphen(uint16_t c) { // to addCandidate. float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typeface, FontStyle style, size_t start, size_t end, bool isRtl) { - Layout layout; // performance TODO: move layout to self object to reduce allocation cost? float width = 0.0f; int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; float hyphenPenalty = 0.0; if (paint != nullptr) { - layout.setFontCollection(typeface); - layout.doLayout(mTextBuf.data(), start, end - start, mTextBuf.size(), bidiFlags, style, - *paint); - layout.getAdvances(mCharWidths.data() + start); - width = layout.getAdvance(); + width = Layout::measureText(mTextBuf.data(), start, end - start, mTextBuf.size(), bidiFlags, + style, *paint, typeface, mCharWidths.data() + start); // a heuristic that seems to perform well hyphenPenalty = 0.5 * paint->size * paint->scaleX * mLineWidths.getLineWidth(0); @@ -192,13 +188,17 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa uint8_t hyph = mHyphBuf[j - wordStart]; if (hyph) { paint->hyphenEdit = hyph; - layout.doLayout(mTextBuf.data(), lastBreak, j - lastBreak, - mTextBuf.size(), bidiFlags, style, *paint); - ParaWidth hyphPostBreak = lastBreakWidth + layout.getAdvance(); + + const float firstPartWidth = Layout::measureText(mTextBuf.data(), + lastBreak, j - lastBreak, mTextBuf.size(), bidiFlags, style, + *paint, typeface, nullptr); + ParaWidth hyphPostBreak = lastBreakWidth + firstPartWidth; paint->hyphenEdit = 0; - layout.doLayout(mTextBuf.data(), j, afterWord - j, - mTextBuf.size(), bidiFlags, style, *paint); - ParaWidth hyphPreBreak = postBreak - layout.getAdvance(); + + const float secondPartWith = Layout::measureText(mTextBuf.data(), j, + afterWord - j, mTextBuf.size(), bidiFlags, style, *paint, + typeface, nullptr); + ParaWidth hyphPreBreak = postBreak - secondPartWith; addWordBreak(j, hyphPreBreak, hyphPostBreak, hyphenPenalty, hyph); } } diff --git a/engine/src/flutter/libs/minikin/Measurement.cpp b/engine/src/flutter/libs/minikin/Measurement.cpp index 0b68ac5f64..1ba6678373 100644 --- a/engine/src/flutter/libs/minikin/Measurement.cpp +++ b/engine/src/flutter/libs/minikin/Measurement.cpp @@ -28,26 +28,26 @@ namespace android { // These could be considered helper methods of layout, but need only be loosely coupled, so // are separate. -static float getRunAdvance(Layout& layout, const uint16_t* buf, size_t layoutStart, size_t start, - size_t count, size_t offset) { +static float getRunAdvance(const float* advances, const uint16_t* buf, size_t layoutStart, + size_t start, size_t count, size_t offset) { float advance = 0.0f; size_t lastCluster = start; float clusterWidth = 0.0f; for (size_t i = start; i < offset; i++) { - float charAdvance = layout.getCharAdvance(i - layoutStart); + float charAdvance = advances[i - layoutStart]; if (charAdvance != 0.0f) { advance += charAdvance; lastCluster = i; clusterWidth = charAdvance; } } - if (offset < start + count && layout.getCharAdvance(offset - layoutStart) == 0.0f) { + if (offset < start + count && advances[offset - layoutStart] == 0.0f) { // In the middle of a cluster, distribute width of cluster so that each grapheme cluster // gets an equal share. // TODO: get caret information out of font when that's available size_t nextCluster; for (nextCluster = offset + 1; nextCluster < start + count; nextCluster++) { - if (layout.getCharAdvance(nextCluster - layoutStart) != 0.0f) break; + if (advances[nextCluster - layoutStart] != 0.0f) break; } int numGraphemeClusters = 0; int numGraphemeClustersAfter = 0; @@ -67,9 +67,9 @@ static float getRunAdvance(Layout& layout, const uint16_t* buf, size_t layoutSta return advance; } -float getRunAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t count, +float getRunAdvance(const float* advances, const uint16_t* buf, size_t start, size_t count, size_t offset) { - return getRunAdvance(layout, buf, start, start, count, offset); + return getRunAdvance(advances, buf, start, start, count, offset); } /** @@ -80,7 +80,7 @@ float getRunAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t co * The actual implementation fast-forwards through clusters to get "close", then does a finer-grain * search within the cluster and grapheme breaks. */ -size_t getOffsetForAdvance(Layout& layout, const uint16_t* buf, size_t start, size_t count, +size_t getOffsetForAdvance(const float* advances, const uint16_t* buf, size_t start, size_t count, float advance) { float x = 0.0f, xLastClusterStart = 0.0f, xSearchStart = 0.0f; size_t lastClusterStart = start, searchStart = start; @@ -89,7 +89,7 @@ size_t getOffsetForAdvance(Layout& layout, const uint16_t* buf, size_t start, si searchStart = lastClusterStart; xSearchStart = xLastClusterStart; } - float width = layout.getCharAdvance(i - start); + float width = advances[i - start]; if (width != 0.0f) { lastClusterStart = i; xLastClusterStart = x; @@ -104,7 +104,7 @@ size_t getOffsetForAdvance(Layout& layout, const uint16_t* buf, size_t start, si for (size_t i = searchStart; i <= start + count; i++) { if (GraphemeBreak::isGraphemeBreak(buf, start, count, i)) { // "getRunAdvance(layout, buf, start, count, i) - advance" but more efficient - float delta = getRunAdvance(layout, buf, start, searchStart, count - searchStart, i) + float delta = getRunAdvance(advances, buf, start, searchStart, count - searchStart, i) + xSearchStart - advance; if (std::abs(delta) < bestDist) { From a14712eaf83ce4e1108f8b9f12e9ab0ec16acbf8 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 18 Feb 2016 15:00:24 -0800 Subject: [PATCH 164/364] Suppress linebreaks in emoji ZWJ sequences Due to the way emoji ZWJ sequences are defined, the ICU line breaking algorithm determines that there are valid line breaks inside the sequence. This patch suppresses these line breaks. This is an adaptation of I225ebebc0f4186e4b8f48fee399c4a62b3f0218a into the nyc-dev branch. Bug: 25433289 Change-Id: I84b50b1e6ef13d436965eab389659d02a30d100f --- .../src/flutter/libs/minikin/WordBreaker.cpp | 29 ++++++++++++++++++- engine/src/flutter/tests/WordBreakerTests.cpp | 24 +++++++++++++++ 2 files changed, 52 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index ca69a50307..ec84c39f9a 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -25,6 +25,7 @@ namespace android { const uint32_t CHAR_SOFT_HYPHEN = 0x00AD; +const uint16_t CHAR_ZWJ = 0x200D; void WordBreaker::setLocale(const icu::Locale& locale) { UErrorCode status = U_ZERO_ERROR; @@ -62,6 +63,32 @@ enum ScanState { SAW_COLON_SLASH_SLASH, }; +/** + * Determine whether a line break at position i within the buffer buf is valid. This + * represents customization beyond the ICU behavior, because plain ICU provides some + * line break opportunities that we don't want. + **/ +static bool isBreakValid(uint16_t codeUnit, const uint16_t* buf, size_t bufEnd, size_t i) { + if (codeUnit == CHAR_SOFT_HYPHEN) { + return false; + } + if (codeUnit == CHAR_ZWJ) { + // Possible emoji ZWJ sequence + uint32_t next_codepoint; + U16_NEXT(buf, i, bufEnd, next_codepoint); + if (next_codepoint == 0x2764 || // HEAVY BLACK HEART + next_codepoint == 0x1F466 || // BOY + next_codepoint == 0x1F467 || // GIRL + next_codepoint == 0x1F468 || // MAN + next_codepoint == 0x1F469 || // WOMAN + next_codepoint == 0x1F48B || // KISS MARK + next_codepoint == 0x1F5E8) { // LEFT SPEECH BUBBLE + return false; + } + } + return true; +} + // Chicago Manual of Style recommends breaking after these characters in URLs and email addresses static bool breakAfter(uint16_t c) { return c == ':' || c == '=' || c == '&'; @@ -149,7 +176,7 @@ ssize_t WordBreaker::next() { result = mBreakIterator->next(); } } while (result != icu::BreakIterator::DONE && (size_t)result != mTextSize - && mText[result - 1] == CHAR_SOFT_HYPHEN); + && !isBreakValid(mText[result - 1], mText, mTextSize, result)); mCurrent = (ssize_t)result; return mCurrent; } diff --git a/engine/src/flutter/tests/WordBreakerTests.cpp b/engine/src/flutter/tests/WordBreakerTests.cpp index 9662b2f7a4..6c5e4795c8 100644 --- a/engine/src/flutter/tests/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/WordBreakerTests.cpp @@ -67,6 +67,30 @@ TEST_F(WordBreakerTest, softHyphen) { EXPECT_EQ(0, breaker.breakBadness()); } +TEST_F(WordBreakerTest, zwjEmojiSequences) { + uint16_t buf[] = { + // man + zwj + heart + zwj + man + 0xD83D, 0xDC68, 0x200D, 0x2764, 0x200D, 0xD83D, 0xDC68, + // woman + zwj + heart + zwj + woman + 0xD83D, 0xDC69, 0x200D, 0x2764, 0x200D, 0xD83D, 0xDC8B, 0x200D, 0xD83D, 0xDC69, + // eye + zwj + left speech bubble + 0xD83D, 0xDC41, 0x200D, 0xD83D, 0xDDE8, + }; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(7, breaker.next()); // after man + zwj + heart + zwj + man + EXPECT_EQ(0, breaker.wordStart()); + EXPECT_EQ(7, breaker.wordEnd()); + EXPECT_EQ(17, breaker.next()); // after woman + zwj + heart + zwj + woman + EXPECT_EQ(7, breaker.wordStart()); + EXPECT_EQ(17, breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(17, breaker.wordStart()); + EXPECT_EQ(22, breaker.wordEnd()); +} + TEST_F(WordBreakerTest, punct) { uint16_t buf[] = {0x00A1, 0x00A1, 'h', 'e', 'l', 'l' ,'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', '!'}; From 675933f27148de3495761ed8348728b3337ddd9a Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Mon, 22 Feb 2016 13:28:44 -0800 Subject: [PATCH 165/364] Suppress grapheme cluster breaks in emoji with modifiers An emoji with a modifier should be treated as a single grapheme, i.e. it should not be possible to place the cursor between the base and modifier. This patch implements the proposed Rule GB9c from Mark Davis's proposal entitled "Fixing breaking properties for emoji", L2/16-011R3. The patch also skips over variation sequences attached the to the preceding character, for computing grapheme cluster boundaries. Bug: 26829153 Change-Id: Iff5bc2bb8e5246223a017c7cf33acfbf63817f16 --- .../flutter/libs/minikin/GraphemeBreak.cpp | 53 +++++++++++++++++++ .../src/flutter/tests/GraphemeBreakTests.cpp | 24 +++++++++ 2 files changed, 77 insertions(+) diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index 7865d1d045..41410917d4 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -77,6 +77,48 @@ bool isZwjEmoji(uint32_t c) { || c == 0x1F5E8); // LEFT SPEECH BUBBLE } +// Based on Modifiers from http://www.unicode.org/L2/L2016/16011-data-file.txt +bool isEmojiModifier(uint32_t c) { + return (0x1F3FB <= c && c <= 0x1F3FF); +} + +// Based on Emoji_Modifier_Base from +// http://www.unicode.org/Public/emoji/3.0/emoji-data.txt +bool isEmojiBase(uint32_t c) { + if (0x261D <= c && c <= 0x270D) { + return (c == 0x261D || c == 0x26F9 || (0x270A <= c && c <= 0x270D)); + } else if (0x1F385 <= c && c <= 0x1F93E) { + return (c == 0x1F385 + || (0x1F3C3 <= c || c <= 0x1F3C4) + || (0x1F3CA <= c || c <= 0x1F3CB) + || (0x1F442 <= c || c <= 0x1F443) + || (0x1F446 <= c || c <= 0x1F450) + || (0x1F466 <= c || c <= 0x1F469) + || c == 0x1F46E + || (0x1F470 <= c || c <= 0x1F478) + || c == 0x1F47C + || (0x1F481 <= c || c <= 0x1F483) + || (0x1F485 <= c || c <= 0x1F487) + || c == 0x1F4AA + || c == 0x1F575 + || c == 0x1F57A + || c == 0x1F590 + || (0x1F595 <= c || c <= 0x1F596) + || (0x1F645 <= c || c <= 0x1F647) + || (0x1F64B <= c || c <= 0x1F64F) + || c == 0x1F6A3 + || (0x1F6B4 <= c || c <= 0x1F6B6) + || c == 0x1F6C0 + || (0x1F918 <= c || c <= 0x1F91E) + || c == 0x1F926 + || c == 0x1F930 + || (0x1F933 <= c || c <= 0x1F939) + || (0x1F93B <= c || c <= 0x1F93E)); + } else { + return false; + } +} + bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t count, size_t offset) { // This implementation closely follows Unicode Standard Annex #29 on @@ -165,6 +207,17 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co return false; } } + // Proposed Rule GB9c from http://www.unicode.org/L2/L2016/16011r3-break-prop-emoji.pdf + // E_Base x E_Modifier + if (isEmojiModifier(c2)) { + if (c1 == 0xFE0F && offset_back > start) { + // skip over emoji variation selector + U16_PREV(buf, start, offset_back, c1); + } + if (isEmojiBase(c1)) { + return false; + } + } // Rule GB10, Any ÷ Any return true; } diff --git a/engine/src/flutter/tests/GraphemeBreakTests.cpp b/engine/src/flutter/tests/GraphemeBreakTests.cpp index d6746bc2b0..dbd73be2b1 100644 --- a/engine/src/flutter/tests/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/GraphemeBreakTests.cpp @@ -136,6 +136,30 @@ TEST(GraphemeBreak, tailoring) { EXPECT_TRUE(IsBreak("U+0628 U+200D | U+2764")); } +TEST(GraphemeBreak, emojiModifiers) { + EXPECT_FALSE(IsBreak("U+261D | U+1F3FB")); // white up pointing index + modifier + EXPECT_FALSE(IsBreak("U+270C | U+1F3FB")); // victory hand + modifier + EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FB")); // boy + modifier + EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FC")); // boy + modifier + EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FD")); // boy + modifier + EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FE")); // boy + modifier + EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FF")); // boy + modifier + EXPECT_FALSE(IsBreak("U+1F918 | U+1F3FF")); // sign of the horns + modifier + EXPECT_FALSE(IsBreak("U+1F933 | U+1F3FF")); // selfie (Unicode 9) + modifier + + // adding emoji style variation selector doesn't affect grapheme cluster + EXPECT_TRUE(IsBreak("U+270C U+FE0E | U+1F3FB")); // victory hand + text style + modifier + EXPECT_FALSE(IsBreak("U+270C U+FE0F | U+1F3FB")); // heart + emoji style + modifier + + // heart is not an emoji base + EXPECT_TRUE(IsBreak("U+2764 | U+1F3FB")); // heart + modifier + EXPECT_TRUE(IsBreak("U+2764 U+FE0E | U+1F3FB")); // heart + emoji style + modifier + EXPECT_TRUE(IsBreak("U+2764 U+FE0F | U+1F3FB")); // heart + emoji style + modifier + + // rat is not an emoji modifer + EXPECT_TRUE(IsBreak("U+1F466 | U+1F400")); // boy + rat +} + TEST(GraphemeBreak, offsets) { uint16_t string[] = { 0x0041, 0x06DD, 0x0045, 0x0301, 0x0049, 0x0301 }; EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(string, 2, 3, 2)); From b7d66e3db0473ace4ddfd3b553c4e9796e49c410 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 25 Feb 2016 17:07:42 +0900 Subject: [PATCH 166/364] Use color font if skin tone is specified. If skin tone is specified, the base emoji should be emoji style even if it is text presentation default emoji. This patch also removes wrong test case which expects default emoji presentation but it is controlled by family order in /etc/fonts.xml and there is no special logic for default presentation in minikin. Thus the default presentation unit test should not be in minikin. Bug: 27342346 Change-Id: I74a2b2feab4d559535049e368cfd833063cce81c --- .../flutter/libs/minikin/FontCollection.cpp | 10 +- .../flutter/libs/minikin/GraphemeBreak.cpp | 43 +------ .../flutter/libs/minikin/MinikinInternal.cpp | 42 +++++++ .../flutter/libs/minikin/MinikinInternal.h | 6 + .../tests/FontCollectionItemizeTest.cpp | 110 ++++++------------ 5 files changed, 93 insertions(+), 118 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index dd905a3442..4541af8475 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -379,11 +379,13 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty langListId, variant); if (utf16Pos == 0 || family != lastFamily) { size_t start = utf16Pos; - // Workaround for Emoji keycap until we implement per-cluster font - // selection: if keycap is found in a different font that also - // supports previous char, attach previous char to the new run. + // Workaround for Emoji keycap and emoji modifier until we implement per-cluster + // font selection: if a keycap or an emoji modifier is found in a different font + // that also supports previous char, attach previous char to the new run. // Bug 7557244. - if (ch == KEYCAP && utf16Pos != 0 && family && family->getCoverage()->get(prevCh)) { + if (utf16Pos != 0 && + (ch == KEYCAP || (isEmojiModifier(ch) && isEmojiBase(prevCh))) && + family && family->getCoverage()->get(prevCh)) { const size_t prevChLength = U16_LENGTH(prevCh); run->end -= prevChLength; if (run->start == run->end) { diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index 41410917d4..ef323d5d48 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -19,6 +19,7 @@ #include #include +#include "MinikinInternal.h" namespace android { @@ -77,48 +78,6 @@ bool isZwjEmoji(uint32_t c) { || c == 0x1F5E8); // LEFT SPEECH BUBBLE } -// Based on Modifiers from http://www.unicode.org/L2/L2016/16011-data-file.txt -bool isEmojiModifier(uint32_t c) { - return (0x1F3FB <= c && c <= 0x1F3FF); -} - -// Based on Emoji_Modifier_Base from -// http://www.unicode.org/Public/emoji/3.0/emoji-data.txt -bool isEmojiBase(uint32_t c) { - if (0x261D <= c && c <= 0x270D) { - return (c == 0x261D || c == 0x26F9 || (0x270A <= c && c <= 0x270D)); - } else if (0x1F385 <= c && c <= 0x1F93E) { - return (c == 0x1F385 - || (0x1F3C3 <= c || c <= 0x1F3C4) - || (0x1F3CA <= c || c <= 0x1F3CB) - || (0x1F442 <= c || c <= 0x1F443) - || (0x1F446 <= c || c <= 0x1F450) - || (0x1F466 <= c || c <= 0x1F469) - || c == 0x1F46E - || (0x1F470 <= c || c <= 0x1F478) - || c == 0x1F47C - || (0x1F481 <= c || c <= 0x1F483) - || (0x1F485 <= c || c <= 0x1F487) - || c == 0x1F4AA - || c == 0x1F575 - || c == 0x1F57A - || c == 0x1F590 - || (0x1F595 <= c || c <= 0x1F596) - || (0x1F645 <= c || c <= 0x1F647) - || (0x1F64B <= c || c <= 0x1F64F) - || c == 0x1F6A3 - || (0x1F6B4 <= c || c <= 0x1F6B6) - || c == 0x1F6C0 - || (0x1F918 <= c || c <= 0x1F91E) - || c == 0x1F926 - || c == 0x1F930 - || (0x1F933 <= c || c <= 0x1F939) - || (0x1F93B <= c || c <= 0x1F93E)); - } else { - return false; - } -} - bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t count, size_t offset) { // This implementation closely follows Unicode Standard Annex #29 on diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index c2aa01ac19..7fa7ce9d4d 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -30,4 +30,46 @@ void assertMinikinLocked() { #endif } +// Based on Modifiers from http://www.unicode.org/L2/L2016/16011-data-file.txt +bool isEmojiModifier(uint32_t c) { + return (0x1F3FB <= c && c <= 0x1F3FF); +} + +// Based on Emoji_Modifier_Base from +// http://www.unicode.org/Public/emoji/3.0/emoji-data.txt +bool isEmojiBase(uint32_t c) { + if (0x261D <= c && c <= 0x270D) { + return (c == 0x261D || c == 0x26F9 || (0x270A <= c && c <= 0x270D)); + } else if (0x1F385 <= c && c <= 0x1F93E) { + return (c == 0x1F385 + || (0x1F3C3 <= c || c <= 0x1F3C4) + || (0x1F3CA <= c || c <= 0x1F3CB) + || (0x1F442 <= c || c <= 0x1F443) + || (0x1F446 <= c || c <= 0x1F450) + || (0x1F466 <= c || c <= 0x1F469) + || c == 0x1F46E + || (0x1F470 <= c || c <= 0x1F478) + || c == 0x1F47C + || (0x1F481 <= c || c <= 0x1F483) + || (0x1F485 <= c || c <= 0x1F487) + || c == 0x1F4AA + || c == 0x1F575 + || c == 0x1F57A + || c == 0x1F590 + || (0x1F595 <= c || c <= 0x1F596) + || (0x1F645 <= c || c <= 0x1F647) + || (0x1F64B <= c || c <= 0x1F64F) + || c == 0x1F6A3 + || (0x1F6B4 <= c || c <= 0x1F6B6) + || c == 0x1F6C0 + || (0x1F918 <= c || c <= 0x1F91E) + || c == 0x1F926 + || c == 0x1F930 + || (0x1F933 <= c || c <= 0x1F939) + || (0x1F93B <= c || c <= 0x1F93E)); + } else { + return false; + } +} + } diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index 34a95bb3d1..3d68691b35 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -32,6 +32,12 @@ extern Mutex gMinikinLock; // Aborts if gMinikinLock is not acquired. Do nothing on the release build. void assertMinikinLocked(); +// Returns true if c is emoji modifier base. +bool isEmojiBase(uint32_t c); + +// Returns true if c is emoji modifier. +bool isEmojiModifier(uint32_t c); + } #endif // MINIKIN_INTERNAL_H diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 446efc6b56..031f3f98f3 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -1119,78 +1119,6 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageAndCoverage) { } } -TEST_F(FontCollectionItemizeTest, itemize_emojiSelection) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); - std::vector runs; - - const FontStyle kDefaultFontStyle; - - // U+00A9 is a text default emoji which is only available in TextEmojiFont.ttf. - // TextEmojiFont.ttf should be selected. - itemize(collection.get(), "U+00A9", kDefaultFontStyle, &runs); - ASSERT_EQ(1U, runs.size()); - EXPECT_EQ(0, runs[0].start); - EXPECT_EQ(1, runs[0].end); - EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); - - // U+00AE is a text default emoji which is only available in ColorEmojiFont.ttf. - // ColorEmojiFont.ttf should be selected. - itemize(collection.get(), "U+00AE", kDefaultFontStyle, &runs); - ASSERT_EQ(1U, runs.size()); - EXPECT_EQ(0, runs[0].start); - EXPECT_EQ(1, runs[0].end); - EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); - - // U+203C is a text default emoji which is available in both TextEmojiFont.ttf and - // ColorEmojiFont.ttf. TextEmojiFont.ttf should be selected. - itemize(collection.get(), "U+203C", kDefaultFontStyle, &runs); - ASSERT_EQ(1U, runs.size()); - EXPECT_EQ(0, runs[0].start); - EXPECT_EQ(1, runs[0].end); - // TODO: use text font for text default emoji. - // EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); - - // U+2049 is a text default emoji which is not available in either TextEmojiFont.ttf or - // ColorEmojiFont.ttf. No font should be selected. - itemize(collection.get(), "U+2049", kDefaultFontStyle, &runs); - ASSERT_EQ(1U, runs.size()); - EXPECT_EQ(0, runs[0].start); - EXPECT_EQ(1, runs[0].end); - EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); - - // U+231A is a emoji default emoji which is available only in TextEmojiFont.ttf. - // TextEmojiFont.ttf should be selected. - itemize(collection.get(), "U+231A", kDefaultFontStyle, &runs); - ASSERT_EQ(1U, runs.size()); - EXPECT_EQ(0, runs[0].start); - EXPECT_EQ(1, runs[0].end); - EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); - - // U+231B is a emoji default emoji which is available only in ColorEmojiFont.ttf. - // ColorEmojiFont.ttf should be selected. - itemize(collection.get(), "U+231B", kDefaultFontStyle, &runs); - ASSERT_EQ(1U, runs.size()); - EXPECT_EQ(0, runs[0].start); - EXPECT_EQ(1, runs[0].end); - EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); - - // U+23E9 is a emoji default emoji which is available in both TextEmojiFont.ttf and - // ColorEmojiFont.ttf. ColorEmojiFont should be selected. - itemize(collection.get(), "U+23E9", kDefaultFontStyle, &runs); - ASSERT_EQ(1U, runs.size()); - EXPECT_EQ(0, runs[0].start); - EXPECT_EQ(1, runs[0].end); - EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); - - // U+23EA is a emoji default emoji which is not avaialble in either TextEmojiFont.ttf and - // ColorEmojiFont.ttf. No font should b e selected. - itemize(collection.get(), "U+23EA", kDefaultFontStyle, &runs); - ASSERT_EQ(1U, runs.size()); - EXPECT_EQ(0, runs[0].start); - EXPECT_EQ(1, runs[0].end); - EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); -} - TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); std::vector runs; @@ -1355,3 +1283,41 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { EXPECT_EQ(kMixedEmojiFont, getFontPath(runs[0])); } +TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_with_skinTone) { + std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); + std::vector runs; + + const FontStyle kDefaultFontStyle; + + // TextEmoji font is selected since it is listed before ColorEmoji font. + itemize(collection.get(), "U+261D", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(1, runs[0].end); + EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); + + // If skin tone is specified, it should be colored. + itemize(collection.get(), "U+261D U+1F3FD", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(3, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + // Still color font is selected if an emoji variation selector is specified. + itemize(collection.get(), "U+261D U+FE0F U+1F3FD", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(4, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + // Text font should be selected if a text variation selector is specified and skin tone is + // rendered by itself. + itemize(collection.get(), "U+261D U+FE0E U+1F3FD", kDefaultFontStyle, &runs); + ASSERT_EQ(2U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); + EXPECT_EQ(2, runs[1].start); + EXPECT_EQ(4, runs[1].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[1])); +} From 7f9de429d43556e288e512313421c2a54513c8c4 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 25 Feb 2016 13:50:33 -0800 Subject: [PATCH 167/364] Suppress line breaks in emoji + modifier An emoji base with an emoji modifier renders as a single glyph and thus should not be a line break. Current (Unicode 8) logic does indicate a line break, so we override the results of the ICU line break iterator. The code references a proposal to improve Unicode behavior; when that is adopted and we upgrade ICU accordingly, the special-case code should be deleted, but the tests can remain. Bug: 27343378 Change-Id: I5de9c53e9a34c503816f9131e3d894e6f7a57d13 --- .../src/flutter/libs/minikin/WordBreaker.cpp | 32 ++++++++++++++----- engine/src/flutter/tests/WordBreakerTests.cpp | 27 +++++++++++++--- 2 files changed, 47 insertions(+), 12 deletions(-) diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index ec84c39f9a..721c5bf0eb 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -17,7 +17,8 @@ #define LOG_TAG "Minikin" #include -#include "minikin/WordBreaker.h" +#include +#include "MinikinInternal.h" #include #include @@ -25,7 +26,7 @@ namespace android { const uint32_t CHAR_SOFT_HYPHEN = 0x00AD; -const uint16_t CHAR_ZWJ = 0x200D; +const uint32_t CHAR_ZWJ = 0x200D; void WordBreaker::setLocale(const icu::Locale& locale) { UErrorCode status = U_ZERO_ERROR; @@ -68,14 +69,18 @@ enum ScanState { * represents customization beyond the ICU behavior, because plain ICU provides some * line break opportunities that we don't want. **/ -static bool isBreakValid(uint16_t codeUnit, const uint16_t* buf, size_t bufEnd, size_t i) { - if (codeUnit == CHAR_SOFT_HYPHEN) { +static bool isBreakValid(const uint16_t* buf, size_t bufEnd, size_t i) { + uint32_t codePoint; + size_t prev_offset = i; + U16_PREV(buf, 0, prev_offset, codePoint); + if (codePoint == CHAR_SOFT_HYPHEN) { return false; } - if (codeUnit == CHAR_ZWJ) { + uint32_t next_codepoint; + size_t next_offset = i; + U16_NEXT(buf, next_offset, bufEnd, next_codepoint); + if (codePoint == CHAR_ZWJ) { // Possible emoji ZWJ sequence - uint32_t next_codepoint; - U16_NEXT(buf, i, bufEnd, next_codepoint); if (next_codepoint == 0x2764 || // HEAVY BLACK HEART next_codepoint == 0x1F466 || // BOY next_codepoint == 0x1F467 || // GIRL @@ -86,6 +91,17 @@ static bool isBreakValid(uint16_t codeUnit, const uint16_t* buf, size_t bufEnd, return false; } } + // Proposed Rule LB30b from http://www.unicode.org/L2/L2016/16011r3-break-prop-emoji.pdf + // EB x EM + if (isEmojiModifier(next_codepoint)) { + if (codePoint == 0xFE0F && prev_offset > 0) { + // skip over emoji variation selector + U16_PREV(buf, 0, prev_offset, codePoint); + } + if (isEmojiBase(codePoint)) { + return false; + } + } return true; } @@ -176,7 +192,7 @@ ssize_t WordBreaker::next() { result = mBreakIterator->next(); } } while (result != icu::BreakIterator::DONE && (size_t)result != mTextSize - && !isBreakValid(mText[result - 1], mText, mTextSize, result)); + && !isBreakValid(mText, mTextSize, result)); mCurrent = (ssize_t)result; return mCurrent; } diff --git a/engine/src/flutter/tests/WordBreakerTests.cpp b/engine/src/flutter/tests/WordBreakerTests.cpp index 6c5e4795c8..cb12722562 100644 --- a/engine/src/flutter/tests/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/WordBreakerTests.cpp @@ -29,6 +29,8 @@ #define NELEM(x) ((sizeof(x) / sizeof((x)[0]))) #endif +#define UTF16(codepoint) U16_LEAD(codepoint), U16_TRAIL(codepoint) + using namespace android; typedef ICUTestBase WordBreakerTest; @@ -70,11 +72,11 @@ TEST_F(WordBreakerTest, softHyphen) { TEST_F(WordBreakerTest, zwjEmojiSequences) { uint16_t buf[] = { // man + zwj + heart + zwj + man - 0xD83D, 0xDC68, 0x200D, 0x2764, 0x200D, 0xD83D, 0xDC68, - // woman + zwj + heart + zwj + woman - 0xD83D, 0xDC69, 0x200D, 0x2764, 0x200D, 0xD83D, 0xDC8B, 0x200D, 0xD83D, 0xDC69, + UTF16(0x1F468), 0x200D, 0x2764, 0x200D, UTF16(0x1F468), + // woman + zwj + heart + zwj + kiss mark + zwj + woman + UTF16(0x1F469), 0x200D, 0x2764, 0x200D, UTF16(0x1F48B), 0x200D, UTF16(0x1F469), // eye + zwj + left speech bubble - 0xD83D, 0xDC41, 0x200D, 0xD83D, 0xDDE8, + UTF16(0x1F441), 0x200D, UTF16(0x1F5E8), }; WordBreaker breaker; breaker.setLocale(icu::Locale::getEnglish()); @@ -91,6 +93,23 @@ TEST_F(WordBreakerTest, zwjEmojiSequences) { EXPECT_EQ(22, breaker.wordEnd()); } +TEST_F(WordBreakerTest, emojiWithModifier) { + uint16_t buf[] = { + UTF16(0x1F466), UTF16(0x1F3FB), // boy + type 1-2 fitzpatrick modifier + 0x270C, 0xFE0F, UTF16(0x1F3FF) // victory hand + emoji style + type 6 fitzpatrick modifier + }; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(4, breaker.next()); // after man + type 6 fitzpatrick modifier + EXPECT_EQ(0, breaker.wordStart()); + EXPECT_EQ(4, breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(4, breaker.wordStart()); + EXPECT_EQ(8, breaker.wordEnd()); +} + TEST_F(WordBreakerTest, punct) { uint16_t buf[] = {0x00A1, 0x00A1, 'h', 'e', 'l', 'l' ,'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', '!'}; From a58530bccc426e86dd6ae3f6be6703599b7d52a4 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Sat, 27 Feb 2016 07:43:56 -0800 Subject: [PATCH 168/364] Fix wrong conditions in isEmojiBase I computed ranges using low <= c || c <= high, should be &&. Bug: 26829153 Change-Id: Ic1002d90b6a408a0b415f2d117d0e57adcbc2fa9 --- .../flutter/libs/minikin/MinikinInternal.cpp | 30 +++++++++---------- .../src/flutter/tests/GraphemeBreakTests.cpp | 1 + 2 files changed, 16 insertions(+), 15 deletions(-) diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 7fa7ce9d4d..175ced8c77 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -42,31 +42,31 @@ bool isEmojiBase(uint32_t c) { return (c == 0x261D || c == 0x26F9 || (0x270A <= c && c <= 0x270D)); } else if (0x1F385 <= c && c <= 0x1F93E) { return (c == 0x1F385 - || (0x1F3C3 <= c || c <= 0x1F3C4) - || (0x1F3CA <= c || c <= 0x1F3CB) - || (0x1F442 <= c || c <= 0x1F443) - || (0x1F446 <= c || c <= 0x1F450) - || (0x1F466 <= c || c <= 0x1F469) + || (0x1F3C3 <= c && c <= 0x1F3C4) + || (0x1F3CA <= c && c <= 0x1F3CB) + || (0x1F442 <= c && c <= 0x1F443) + || (0x1F446 <= c && c <= 0x1F450) + || (0x1F466 <= c && c <= 0x1F469) || c == 0x1F46E - || (0x1F470 <= c || c <= 0x1F478) + || (0x1F470 <= c && c <= 0x1F478) || c == 0x1F47C - || (0x1F481 <= c || c <= 0x1F483) - || (0x1F485 <= c || c <= 0x1F487) + || (0x1F481 <= c && c <= 0x1F483) + || (0x1F485 <= c && c <= 0x1F487) || c == 0x1F4AA || c == 0x1F575 || c == 0x1F57A || c == 0x1F590 - || (0x1F595 <= c || c <= 0x1F596) - || (0x1F645 <= c || c <= 0x1F647) - || (0x1F64B <= c || c <= 0x1F64F) + || (0x1F595 <= c && c <= 0x1F596) + || (0x1F645 <= c && c <= 0x1F647) + || (0x1F64B <= c && c <= 0x1F64F) || c == 0x1F6A3 - || (0x1F6B4 <= c || c <= 0x1F6B6) + || (0x1F6B4 <= c && c <= 0x1F6B6) || c == 0x1F6C0 - || (0x1F918 <= c || c <= 0x1F91E) + || (0x1F918 <= c && c <= 0x1F91E) || c == 0x1F926 || c == 0x1F930 - || (0x1F933 <= c || c <= 0x1F939) - || (0x1F93B <= c || c <= 0x1F93E)); + || (0x1F933 <= c && c <= 0x1F939) + || (0x1F93B <= c && c <= 0x1F93E)); } else { return false; } diff --git a/engine/src/flutter/tests/GraphemeBreakTests.cpp b/engine/src/flutter/tests/GraphemeBreakTests.cpp index dbd73be2b1..7e1720384c 100644 --- a/engine/src/flutter/tests/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/GraphemeBreakTests.cpp @@ -155,6 +155,7 @@ TEST(GraphemeBreak, emojiModifiers) { EXPECT_TRUE(IsBreak("U+2764 | U+1F3FB")); // heart + modifier EXPECT_TRUE(IsBreak("U+2764 U+FE0E | U+1F3FB")); // heart + emoji style + modifier EXPECT_TRUE(IsBreak("U+2764 U+FE0F | U+1F3FB")); // heart + emoji style + modifier + EXPECT_TRUE(IsBreak("U+1F3FB | U+1F3FB")); // modifier + modifier // rat is not an emoji modifer EXPECT_TRUE(IsBreak("U+1F466 | U+1F400")); // boy + rat From f4c679ca680ed79d2a9dee20d375c87f187149b6 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Wed, 2 Mar 2016 13:53:54 -0800 Subject: [PATCH 169/364] Break regional indicators at even numbered code points. Bug: 23288449 Change-Id: If1419ff9e44e8e640616979bae88311f414b42a1 --- .../flutter/libs/minikin/GraphemeBreak.cpp | 27 ++++++++++++------- .../src/flutter/tests/GraphemeBreakTests.cpp | 16 +++++++++++ 2 files changed, 34 insertions(+), 9 deletions(-) diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index ef323d5d48..1f361ba1a7 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -15,6 +15,7 @@ */ #include +#include #include #include @@ -124,17 +125,25 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co if ((p1 == U_GCB_LVT || p1 == U_GCB_T) && p2 == U_GCB_T) { return false; } - // Rule GB8a, Regional_Indicator x Regional_Indicator + // Rule GB8a that looks at even-off cases. // - // Known limitation: This is overly conservative, and returns no grapheme breaks between two - // flags, such as in the character sequence "U+1F1FA U+1F1F8 [potential break] U+1F1FA U+1F1F8". - // Also, it assumes that all combinations of Regional Indicators produce a flag, where they - // don't. - // - // There is no easy solution for doing this correctly, except for querying the font and doing - // some lookback. + // sot (RI RI)* RI x RI + // [^RI] (RI RI)* RI x RI + // RI ÷ RI if (p1 == U_GCB_REGIONAL_INDICATOR && p2 == U_GCB_REGIONAL_INDICATOR) { - return false; + // Look at up to 1000 code units. + start = std::max((ssize_t)start, (ssize_t)offset_back - 1000); + while (offset_back > start) { + U16_PREV(buf, start, offset_back, c1); + if (tailoredGraphemeClusterBreak(c1) != U_GCB_REGIONAL_INDICATOR) { + offset_back += U16_LENGTH(c1); + break; + } + } + + // Note that the offset has moved forwared 2 code units by U16_NEXT. + // The number 4 comes from the number of code units in a whole flag. + return (offset - 2 - offset_back) % 4 == 0; } // Rule GB9, x Extend; Rule GB9a, x SpacingMark; Rule GB9b, Prepend x if (p2 == U_GCB_EXTEND || p2 == U_GCB_SPACING_MARK || p1 == U_GCB_PREPEND) { diff --git a/engine/src/flutter/tests/GraphemeBreakTests.cpp b/engine/src/flutter/tests/GraphemeBreakTests.cpp index 7e1720384c..3bfa5ecd8b 100644 --- a/engine/src/flutter/tests/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/GraphemeBreakTests.cpp @@ -84,6 +84,22 @@ TEST(GraphemeBreak, rules) { // Rule GB8a, Regional_Indicator x Regional_Indicator EXPECT_FALSE(IsBreak("U+1F1FA | U+1F1F8")); + EXPECT_TRUE(IsBreak("U+1F1FA U+1F1F8 | U+1F1FA U+1F1F8")); // Regional indicator pair (flag) + EXPECT_FALSE(IsBreak("U+1F1FA | U+1F1F8 U+1F1FA U+1F1F8")); // Regional indicator pair (flag) + EXPECT_FALSE(IsBreak("U+1F1FA U+1F1F8 U+1F1FA | U+1F1F8")); // Regional indicator pair (flag) + + EXPECT_TRUE(IsBreak("U+1F1FA U+1F1F8 | U+1F1FA")); // Regional indicator pair (flag) + EXPECT_FALSE(IsBreak("U+1F1FA | U+1F1F8 U+1F1FA")); // Regional indicator pair (flag) + + EXPECT_TRUE(IsBreak("'a' U+1F1FA U+1F1F8 | U+1F1FA")); // Regional indicator pair (flag) + EXPECT_FALSE(IsBreak("'a' U+1F1FA | U+1F1F8 U+1F1FA")); // Regional indicator pair (flag) + + EXPECT_TRUE( + IsBreak("'a' U+1F1FA U+1F1F8 | U+1F1FA U+1F1F8")); // Regional indicator pair (flag) + EXPECT_FALSE( + IsBreak("'a' U+1F1FA | U+1F1F8 U+1F1FA U+1F1F8")); // Regional indicator pair (flag) + EXPECT_FALSE( + IsBreak("'a' U+1F1FA U+1F1F8 U+1F1FA | U+1F1F8")); // Regional indicator pair (flag) // Rule GB9, x Extend EXPECT_FALSE(IsBreak("'a' | U+0301")); // combining accent From 5ccdf654f5695be1b582a3bd89482bc6915cc22a Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 3 Mar 2016 15:33:33 -0800 Subject: [PATCH 170/364] Suppress log span due to returning null for itemize result. Bug: 26808815 Change-Id: I2a5a52f2c441d27c7ef270342b4ef93c3de9e56e --- .../flutter/include/minikin/FontCollection.h | 2 ++ .../flutter/libs/minikin/FontCollection.cpp | 14 +++------- .../tests/FontCollectionItemizeTest.cpp | 28 ++++++++++++++++--- 3 files changed, 30 insertions(+), 14 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 5b9424c958..c3c183db3b 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -84,9 +84,11 @@ private: uint32_t mMaxChar; // This vector has ownership of the bitsets and typeface objects. + // This vector can't be empty. std::vector mFamilies; // This vector contains pointers into mInstances + // This vector can't be empty. std::vector mFamilyVec; // This vector has pointers to the font family instance which has cmap 14 subtable. diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 4541af8475..e2582508ef 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -230,10 +230,11 @@ uint32_t FontCollection::calcVariantMatchingScore(int variant, const FontFamily& // 1. If first font in the collection has the character, it wins. // 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. FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, uint32_t langListId, int variant) const { if (ch >= mMaxChar) { - return NULL; + return mFamilies[0]; } const std::vector* familyVec = &mFamilyVec; @@ -272,7 +273,7 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, bestFamily = family; } } - if (bestFamily == nullptr && !mFamilyVec.empty()) { + if (bestFamily == nullptr) { UErrorCode errorCode = U_ZERO_ERROR; const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode); if (U_SUCCESS(errorCode)) { @@ -396,11 +397,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty Run dummy; result->push_back(dummy); run = &result->back(); - if (family == NULL) { - run->fakedFont.font = NULL; - } else { - run->fakedFont = family->getClosestMatch(style); - } + run->fakedFont = family->getClosestMatch(style); lastFamily = family; run->start = start; } @@ -415,9 +412,6 @@ MinikinFont* FontCollection::baseFont(FontStyle style) { } FakedFont FontCollection::baseFontFaked(FontStyle style) { - if (mFamilies.empty()) { - return FakedFont(); - } return mFamilies[0]->getClosestMatch(style); } diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 031f3f98f3..22971c8523 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -1156,7 +1156,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); - EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); + EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); // U+231A is a emoji default emoji which is available only in TextEmojifFont. // TextEmojiFont.ttf sohuld be selected. @@ -1190,7 +1190,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); - EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); + EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); // U+26FA U+FE0E is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. @@ -1239,7 +1239,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); - EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); + EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); // U+231A is a emoji default emoji which is available only in TextEmojiFont.ttf. // TextEmojiFont.ttf should be selected. @@ -1272,7 +1272,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); - EXPECT_TRUE(runs[0].fakedFont.font == NULL || kNoGlyphFont == getFontPath(runs[0])); + EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); // U+26F9 U+FE0F is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. @@ -1321,3 +1321,23 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_with_skinTone) { EXPECT_EQ(4, runs[1].end); EXPECT_EQ(kColorEmojiFont, getFontPath(runs[1])); } + +TEST_F(FontCollectionItemizeTest, itemize_PrivateUseArea) { + std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); + std::vector runs; + + const FontStyle kDefaultFontStyle; + + // Should not set nullptr to the result run. (Issue 26808815) + itemize(collection.get(), "U+FEE10", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(2, runs[0].end); + EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+FEE40 U+FE4C5", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(4, runs[0].end); + EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); +} From 0eaf80b016b6780250227b8273692d2b8978816f Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Wed, 16 Mar 2016 15:23:20 -0700 Subject: [PATCH 171/364] Do not allow line breaks before currency symbols Implement the change proposed in UTC document L2/16-043R (http://www.unicode.org/L2/L2016/16043r-line-break-pr-po.txt) to make sure we do not break between letters and currency symbols. Bug: 24959657 Change-Id: Ia29d0e5625f84870bd910d0c6e19036d17206704 --- engine/src/flutter/libs/minikin/WordBreaker.cpp | 13 +++++++++++++ engine/src/flutter/tests/WordBreakerTests.cpp | 16 ++++++++++++++++ 2 files changed, 29 insertions(+) diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index 721c5bf0eb..d420a6a0a8 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -79,6 +79,18 @@ static bool isBreakValid(const uint16_t* buf, size_t bufEnd, size_t i) { uint32_t next_codepoint; size_t next_offset = i; U16_NEXT(buf, next_offset, bufEnd, next_codepoint); + + // Proposed change to LB24 from http://www.unicode.org/L2/L2016/16043r-line-break-pr-po.txt + //(AL | HL) × (PR | PO) + int32_t lineBreak = u_getIntPropertyValue(codePoint, UCHAR_LINE_BREAK); + if (lineBreak == U_LB_ALPHABETIC || lineBreak == U_LB_HEBREW_LETTER) { + lineBreak = u_getIntPropertyValue(next_codepoint, UCHAR_LINE_BREAK); + if (lineBreak == U_LB_PREFIX_NUMERIC || lineBreak == U_LB_POSTFIX_NUMERIC) { + return false; + } + } + + // Known emoji ZWJ sequences if (codePoint == CHAR_ZWJ) { // Possible emoji ZWJ sequence if (next_codepoint == 0x2764 || // HEAVY BLACK HEART @@ -91,6 +103,7 @@ static bool isBreakValid(const uint16_t* buf, size_t bufEnd, size_t i) { return false; } } + // Proposed Rule LB30b from http://www.unicode.org/L2/L2016/16011r3-break-prop-emoji.pdf // EB x EM if (isEmojiModifier(next_codepoint)) { diff --git a/engine/src/flutter/tests/WordBreakerTests.cpp b/engine/src/flutter/tests/WordBreakerTests.cpp index cb12722562..480c57da96 100644 --- a/engine/src/flutter/tests/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/WordBreakerTests.cpp @@ -69,6 +69,22 @@ TEST_F(WordBreakerTest, softHyphen) { EXPECT_EQ(0, breaker.breakBadness()); } +TEST_F(WordBreakerTest, postfixAndPrefix) { + uint16_t buf[] = {'U', 'S', 0x00A2, ' ', 'J', 'P', 0x00A5}; // US¢ JP¥ + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + + EXPECT_EQ(4, breaker.next()); // after CENT SIGN + EXPECT_EQ(0, breaker.wordStart()); // "US¢" + EXPECT_EQ(3, breaker.wordEnd()); + + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end of string + EXPECT_EQ(4, breaker.wordStart()); // "JP¥" + EXPECT_EQ((ssize_t)NELEM(buf), breaker.wordEnd()); +} + TEST_F(WordBreakerTest, zwjEmojiSequences) { uint16_t buf[] = { // man + zwj + heart + zwj + man From c9c0359b1d0711c0dceeef7c853c6377c6a2af08 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Wed, 30 Mar 2016 17:48:34 -0700 Subject: [PATCH 172/364] Try putting combining marks in the same font run MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Indic combining marks, when combined with a common character such as a hyphen or a dotted circle, used to get rendered in a different font due to the greedy algorithm used in determining runs, which resulted in the base character and the combining mark getting rendered in separate font runs, resulting in a dotted circle appearing in phrases such as "100-ാം" (0031 0030 0030 002D 0D3E 0D02). This change makes combining marks change the font run of the base character if the base character is supported in the same font as the combining mark, similar to the support for emoji modifiers and the combining keycap. Bug: 25036888 Bug: 24535344 Change-Id: I8e2798e8ecb8efaf723a0fd02c05c6fbdef8b365 --- .../src/flutter/libs/minikin/FontCollection.cpp | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index e2582508ef..5f669a176a 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -293,14 +293,13 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, const uint32_t NBSP = 0xa0; const uint32_t ZWJ = 0x200c; const uint32_t ZWNJ = 0x200d; -const uint32_t KEYCAP = 0x20e3; const uint32_t HYPHEN = 0x2010; const uint32_t NB_HYPHEN = 0x2011; // Characters where we want to continue using existing font run instead of // recomputing the best match in the fallback list. static const uint32_t stickyWhitelist[] = { '!', ',', '-', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, - KEYCAP, HYPHEN, NB_HYPHEN }; + HYPHEN, NB_HYPHEN }; static bool isStickyWhitelisted(uint32_t c) { for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) { @@ -380,12 +379,14 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty langListId, variant); if (utf16Pos == 0 || family != lastFamily) { size_t start = utf16Pos; - // Workaround for Emoji keycap and emoji modifier until we implement per-cluster - // font selection: if a keycap or an emoji modifier is found in a different font - // that also supports previous char, attach previous char to the new run. - // Bug 7557244. + // 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 + // a different font that also supports the previous character, attach previous + // 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 && - (ch == KEYCAP || (isEmojiModifier(ch) && isEmojiBase(prevCh))) && + ((U_GET_GC_MASK(ch) & U_GC_M_MASK) != 0 || + (isEmojiModifier(ch) && isEmojiBase(prevCh))) && family && family->getCoverage()->get(prevCh)) { const size_t prevChLength = U16_LENGTH(prevCh); run->end -= prevChLength; From dbcbe1f426b17242f2c548fb3df5e2b6a659ac50 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Mon, 25 Jan 2016 15:25:16 +0900 Subject: [PATCH 173/364] Support multiple locales for font language settings. Some fonts support multiple scripts, for example, some fonts for Korean supports not only "Kore" but also "Jamo". To select fonts based on their multiple languages, this CL introduces the following changes: - Compares all languages of the font family and use the maximum score for font selection. - Even if each language of the font family doesn't support the requested language, the font get score of 2 if the requested font is covered by all of the languages of the font family. For example, the font for "ko-Hang,ko-Hani" gets score of 2 for the requested language "ko-Kore". Bug: 26687969 Change-Id: I7f13b51464c9b01982bb573251d77052b9ddbd70 --- .../flutter/libs/minikin/FontCollection.cpp | 21 ++-- .../src/flutter/libs/minikin/FontLanguage.cpp | 55 +++++++-- .../src/flutter/libs/minikin/FontLanguage.h | 44 ++++++- .../libs/minikin/FontLanguageListCache.cpp | 10 +- .../tests/FontCollectionItemizeTest.cpp | 114 +++++++++++------- engine/src/flutter/tests/FontFamilyTest.cpp | 35 +++--- .../tests/FontLanguageListCacheTest.cpp | 16 +-- 7 files changed, 197 insertions(+), 98 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 5f669a176a..75cbd76893 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -177,9 +177,15 @@ uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* } if (vs == 0xFE0F || vs == 0xFE0E) { - // TODO use all language in the list. - const FontLanguage lang = FontLanguageListCache::getById(fontFamily->langId())[0]; - const bool hasEmojiFlag = lang.hasEmojiFlag(); + const FontLanguages& langs = FontLanguageListCache::getById(fontFamily->langId()); + bool hasEmojiFlag = false; + for (size_t i = 0; i < langs.size(); ++i) { + if (langs[i].hasEmojiFlag()) { + hasEmojiFlag = true; + break; + } + } + if (vs == 0xFE0F) { return hasEmojiFlag ? 2 : 1; } else { // vs == 0xFE0E @@ -208,13 +214,12 @@ uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* uint32_t FontCollection::calcLanguageMatchingScore( uint32_t userLangListId, const FontFamily& fontFamily) { const FontLanguages& langList = FontLanguageListCache::getById(userLangListId); - // TODO use all language in the list. - FontLanguage fontLanguage = FontLanguageListCache::getById(fontFamily.langId())[0]; + const FontLanguages& fontLanguages = FontLanguageListCache::getById(fontFamily.langId()); const size_t maxCompareNum = std::min(langList.size(), FONT_LANGUAGES_LIMIT); - uint32_t score = fontLanguage.getScoreFor(langList[0]); // maxCompareNum can't be zero. - for (size_t i = 1; i < maxCompareNum; ++i) { - score = score * 3u + fontLanguage.getScoreFor(langList[i]); + uint32_t score = 0; + for (size_t i = 0; i < maxCompareNum; ++i) { + score = score * 3u + langList[i].calcScoreFor(fontLanguages); } return score; } diff --git a/engine/src/flutter/libs/minikin/FontLanguage.cpp b/engine/src/flutter/libs/minikin/FontLanguage.cpp index db630592b8..bccb4bf9e8 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguage.cpp @@ -126,24 +126,59 @@ bool FontLanguage::isEqualScript(const FontLanguage& other) const { return other.mScript == mScript; } -bool FontLanguage::supportsScript(uint8_t requestedBits) const { - return requestedBits != 0 && (mSubScriptBits & requestedBits) == requestedBits; +// static +bool FontLanguage::supportsScript(uint8_t providedBits, uint8_t requestedBits) { + return requestedBits != 0 && (providedBits & requestedBits) == requestedBits; } bool FontLanguage::supportsHbScript(hb_script_t script) const { static_assert(SCRIPT_TAG('J', 'p', 'a', 'n') == HB_TAG('J', 'p', 'a', 'n'), "The Minikin script and HarfBuzz hb_script_t have different encodings."); if (script == mScript) return true; - return supportsScript(scriptToSubScriptBits(script)); + return supportsScript(mSubScriptBits, scriptToSubScriptBits(script)); } -int FontLanguage::getScoreFor(const FontLanguage other) const { - if (isUnsupported() || other.isUnsupported()) { - return 0; - } else if (isEqualScript(other) || supportsScript(other.mSubScriptBits)) { - return mLanguage == other.mLanguage ? 2 : 1; - } else { - return 0; +int FontLanguage::calcScoreFor(const FontLanguages& supported) const { + int score = 0; + for (size_t i = 0; i < supported.size(); ++i) { + if (isEqualScript(supported[i]) || + supportsScript(supported[i].mSubScriptBits, mSubScriptBits)) { + if (mLanguage == supported[i].mLanguage) { + return 2; + } else { + score = 1; + } + } + } + + if (score == 1) { + return score; + } + + if (supportsScript(supported.getUnionOfSubScriptBits(), mSubScriptBits)) { + // Gives score of 2 only if the language matches all of the font languages except for the + // exact match case handled above. + return (mLanguage == supported[0].mLanguage && supported.isAllTheSameLanguage()) ? 2 : 1; + } + + return 0; +} + +FontLanguages::FontLanguages(std::vector&& languages) + : mLanguages(std::move(languages)) { + if (mLanguages.empty()) { + return; + } + + const FontLanguage& lang = mLanguages[0]; + + mIsAllTheSameLanguage = true; + mUnionOfSubScriptBits = lang.mSubScriptBits; + for (size_t i = 1; i < mLanguages.size(); ++i) { + mUnionOfSubScriptBits |= mLanguages[i].mSubScriptBits; + if (mIsAllTheSameLanguage && lang.mLanguage != mLanguages[i].mLanguage) { + mIsAllTheSameLanguage = false; + } } } diff --git a/engine/src/flutter/libs/minikin/FontLanguage.h b/engine/src/flutter/libs/minikin/FontLanguage.h index 1a20480fb5..f944174a86 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.h +++ b/engine/src/flutter/libs/minikin/FontLanguage.h @@ -24,6 +24,11 @@ namespace android { +// Due to the limits in font fallback score calculation, we can't use anything more than 17 +// languages. +const size_t FONT_LANGUAGES_LIMIT = 17; +class FontLanguages; + // FontLanguage is a compact representation of a BCP 47 language tag. It // does not capture all possible information, only what directly affects // font rendering. @@ -54,12 +59,16 @@ public: std::string getString() const; + // Calculates a matching score. This score represents how well the input languages cover this + // language. The maximum score in the language list is returned. // 0 = no match, 1 = script match, 2 = script and primary language match. - int getScoreFor(const FontLanguage other) const; + int calcScoreFor(const FontLanguages& supported) const; uint64_t getIdentifier() const { return (uint64_t)mScript << 32 | (uint64_t)mLanguage; } private: + friend class FontLanguages; // for FontLanguages constructor + // ISO 15924 compliant script code. The 4 chars script code are packed into a 32 bit integer. uint32_t mScript; @@ -80,12 +89,37 @@ private: uint8_t mSubScriptBits; static uint8_t scriptToSubScriptBits(uint32_t script); - bool supportsScript(uint8_t requestedBits) const; + + // Returns true if the provide subscript bits has the requested subscript bits. + // Note that this function returns false if the requested subscript bits are empty. + static bool supportsScript(uint8_t providedBits, uint8_t requestedBits); }; -// Due to the limit of font fallback cost calculation, we can't use anything more than 17 languages. -const size_t FONT_LANGUAGES_LIMIT = 17; -typedef std::vector FontLanguages; +// An immutable list of languages. +class FontLanguages { +public: + FontLanguages(std::vector&& languages); + FontLanguages() : mUnionOfSubScriptBits(0), mIsAllTheSameLanguage(false) {} + FontLanguages(FontLanguages&&) = default; + + size_t size() const { return mLanguages.size(); } + bool empty() const { return mLanguages.empty(); } + const FontLanguage& operator[] (size_t n) const { return mLanguages[n]; } + +private: + friend struct FontLanguage; // for calcScoreFor + + std::vector mLanguages; + uint8_t mUnionOfSubScriptBits; + bool mIsAllTheSameLanguage; + + uint8_t getUnionOfSubScriptBits() const { return mUnionOfSubScriptBits; } + bool isAllTheSameLanguage() const { return mIsAllTheSameLanguage; } + + // Do not copy and assign. + FontLanguages(const FontLanguages&) = delete; + void operator=(const FontLanguages&) = delete; +}; } // namespace android diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp index 5d177b5827..6b661f0384 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp @@ -76,8 +76,8 @@ static size_t toLanguageTag(char* output, size_t outSize, const std::string& loc return outLength; } -static FontLanguages constructFontLanguages(const std::string& input) { - FontLanguages result; +static std::vector parseLanguageList(const std::string& input) { + std::vector result; size_t currentIdx = 0; size_t commaLoc = 0; char langTag[ULOC_FULLNAME_CAPACITY]; @@ -121,11 +121,11 @@ uint32_t FontLanguageListCache::getId(const std::string& languages) { // Given language list is not in cache. Insert it and return newly assigned ID. const uint32_t nextId = inst->mLanguageLists.size(); - FontLanguages fontLanguages = constructFontLanguages(languages); + FontLanguages fontLanguages(parseLanguageList(languages)); if (fontLanguages.empty()) { return kEmptyListId; } - inst->mLanguageLists.push_back(fontLanguages); + inst->mLanguageLists.push_back(std::move(fontLanguages)); inst->mLanguageListLookupTable.insert(std::make_pair(languages, nextId)); return nextId; } @@ -146,7 +146,7 @@ FontLanguageListCache* FontLanguageListCache::getInstance() { // Insert an empty language list for mapping default language list to kEmptyListId. // The default language list has only one FontLanguage and it is the unsupported language. - instance->mLanguageLists.push_back(FontLanguages({FontLanguage()})); + instance->mLanguageLists.push_back(FontLanguages()); instance->mLanguageListLookupTable.insert(std::make_pair("", kEmptyListId)); } return instance; diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 22971c8523..45587e9d89 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -698,72 +698,104 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { struct TestCase { std::string userPreferredLanguages; - std::string fontLanguages; + std::vector fontLanguages; int selectedFontIndex; } testCases[] = { + // Font can specify empty language. + { "und", { "", "" }, 0 }, + { "und", { "", "en-Latn" }, 0 }, + { "en-Latn", { "", "" }, 0 }, + { "en-Latn", { "", "en-Latn" }, 1 }, + // Single user preferred language. // Exact match case - { "en-Latn", "en-Latn,ja-Jpan", 0 }, - { "ja-Jpan", "en-Latn,ja-Jpan", 1 }, - { "en-Latn", "en-Latn,nl-Latn,es-Latn", 0 }, - { "nl-Latn", "en-Latn,nl-Latn,es-Latn", 1 }, - { "es-Latn", "en-Latn,nl-Latn,es-Latn", 2 }, - { "es-Latn", "en-Latn,en-Latn,nl-Latn", 0 }, + { "en-Latn", { "en-Latn", "ja-Jpan" }, 0 }, + { "ja-Jpan", { "en-Latn", "ja-Jpan" }, 1 }, + { "en-Latn", { "en-Latn", "nl-Latn", "es-Latn" }, 0 }, + { "nl-Latn", { "en-Latn", "nl-Latn", "es-Latn" }, 1 }, + { "es-Latn", { "en-Latn", "nl-Latn", "es-Latn" }, 2 }, + { "es-Latn", { "en-Latn", "en-Latn", "nl-Latn" }, 0 }, // Exact script match case - { "en-Latn", "nl-Latn,be-Latn", 0 }, - { "en-Arab", "nl-Latn,ar-Arab", 1 }, - { "en-Latn", "be-Latn,ar-Arab,bd-Beng", 0 }, - { "en-Arab", "be-Latn,ar-Arab,bd-Beng", 1 }, - { "en-Beng", "be-Latn,ar-Arab,bd-Beng", 2 }, - { "en-Beng", "be-Latn,ar-Beng,bd-Beng", 1 }, - { "zh-Hant", "zh-Hant,zh-Hans", 0 }, - { "zh-Hans", "zh-Hant,zh-Hans", 1 }, + { "en-Latn", { "nl-Latn", "e-Latn" }, 0 }, + { "en-Arab", { "nl-Latn", "ar-Arab" }, 1 }, + { "en-Latn", { "be-Latn", "ar-Arab", "d-Beng" }, 0 }, + { "en-Arab", { "be-Latn", "ar-Arab", "d-Beng" }, 1 }, + { "en-Beng", { "be-Latn", "ar-Arab", "d-Beng" }, 2 }, + { "en-Beng", { "be-Latn", "ar-Beng", "d-Beng" }, 1 }, + { "zh-Hant", { "zh-Hant", "zh-Hans" }, 0 }, + { "zh-Hans", { "zh-Hant", "zh-Hans" }, 1 }, // Subscript match case, e.g. Jpan supports Hira. - { "en-Hira", "ja-Jpan", 0 }, - { "zh-Hani", "zh-Hans,zh-Hant", 0 }, - { "zh-Hani", "zh-Hant,zh-Hans", 0 }, - { "en-Hira", "zh-Hant,ja-Jpan,ja-Jpan", 1 }, + { "en-Hira", { "ja-Jpan" }, 0 }, + { "zh-Hani", { "zh-Hans", "zh-Hant" }, 0 }, + { "zh-Hani", { "zh-Hant", "zh-Hans" }, 0 }, + { "en-Hira", { "zh-Hant", "ja-Jpan", "ja-Jpan" }, 1 }, // Language match case - { "ja-Latn", "zh-Latn,ja-Latn", 1 }, - { "zh-Latn", "zh-Latn,ja-Latn", 0 }, - { "ja-Latn", "zh-Latn,ja-Latn", 1 }, - { "ja-Latn", "zh-Latn,ja-Latn,ja-Latn", 1 }, + { "ja-Latn", { "zh-Latn", "ja-Latn" }, 1 }, + { "zh-Latn", { "zh-Latn", "ja-Latn" }, 0 }, + { "ja-Latn", { "zh-Latn", "ja-Latn" }, 1 }, + { "ja-Latn", { "zh-Latn", "ja-Latn", "ja-Latn" }, 1 }, // Mixed case // Script/subscript match is strongest. - { "ja-Jpan", "en-Latn,ja-Latn,en-Jpan", 2 }, - { "ja-Hira", "en-Latn,ja-Latn,en-Jpan", 2 }, - { "ja-Hira", "en-Latn,ja-Latn,en-Jpan,en-Jpan", 2 }, + { "ja-Jpan", { "en-Latn", "ja-Latn", "en-Jpan" }, 2 }, + { "ja-Hira", { "en-Latn", "ja-Latn", "en-Jpan" }, 2 }, + { "ja-Hira", { "en-Latn", "ja-Latn", "en-Jpan", "en-Jpan" }, 2 }, // Language match only happens if the script matches. - { "ja-Hira", "en-Latn,ja-Latn", 0 }, - { "ja-Hira", "en-Jpan,ja-Jpan", 1 }, + { "ja-Hira", { "en-Latn", "ja-Latn" }, 0 }, + { "ja-Hira", { "en-Jpan", "ja-Jpan" }, 1 }, // Multiple languages. // Even if all fonts have the same score, use the 2nd language for better selection. - { "en-Latn,ja-Jpan", "zh-Hant,zh-Hans,ja-Jpan", 2 }, - { "en-Latn,nl-Latn", "es-Latn,be-Latn,nl-Latn", 2 }, - { "en-Latn,br-Latn,nl-Latn", "es-Latn,be-Latn,nl-Latn", 2 }, - { "en-Latn,br-Latn,nl-Latn", "es-Latn,be-Latn,nl-Latn,nl-Latn", 2 }, + { "en-Latn,ja-Jpan", { "zh-Hant", "zh-Hans", "ja-Jpan" }, 2 }, + { "en-Latn,nl-Latn", { "es-Latn", "be-Latn", "nl-Latn" }, 2 }, + { "en-Latn,br-Latn,nl-Latn", { "es-Latn", "be-Latn", "nl-Latn" }, 2 }, + { "en-Latn,br-Latn,nl-Latn", { "es-Latn", "be-Latn", "nl-Latn", "nl-Latn" }, 2 }, // Script score. - { "en-Latn,ja-Jpan", "en-Arab,en-Jpan", 1 }, - { "en-Latn,ja-Jpan", "en-Arab,en-Jpan,en-Jpan", 1 }, + { "en-Latn,ja-Jpan", { "en-Arab", "en-Jpan" }, 1 }, + { "en-Latn,ja-Jpan", { "en-Arab", "en-Jpan", "en-Jpan" }, 1 }, // Language match case - { "en-Latn,ja-Latn", "bd-Latn,ja-Latn", 1 }, - { "en-Latn,ja-Latn", "bd-Latn,ja-Latn,ja-Latn", 1 }, + { "en-Latn,ja-Latn", { "bd-Latn", "ja-Latn" }, 1 }, + { "en-Latn,ja-Latn", { "bd-Latn", "ja-Latn", "ja-Latn" }, 1 }, // Language match only happens if the script matches. - { "en-Latn,ar-Arab", "en-Beng,ar-Arab", 1 }, + { "en-Latn,ar-Arab", { "en-Beng", "ar-Arab" }, 1 }, + + // Multiple languages in the font settings. + { "ko-Jamo", { "ja-Jpan", "ko-Kore", "ko-Kore,ko-Jamo"}, 2 }, + { "en-Latn", { "ja-Jpan", "en-Latn,ja-Jpan"}, 1 }, + { "en-Latn", { "ja-Jpan", "ja-Jpan,en-Latn"}, 1 }, + { "en-Latn", { "ja-Jpan,zh-Hant", "en-Latn,ja-Jpan", "en-Latn"}, 1 }, + { "en-Latn", { "zh-Hant,ja-Jpan", "ja-Jpan,en-Latn", "en-Latn"}, 1 }, + + // Kore = Hang + Hani, etc. + { "ko-Kore", { "ko-Hang", "ko-Jamo,ko-Hani", "ko-Hang,ko-Hani"}, 2 }, + { "ja-Hrkt", { "ja-Hira", "ja-Kana", "ja-Hira,ja-Kana"}, 2 }, + { "ja-Jpan", { "ja-Hira", "ja-Kana", "ja-Hani", "ja-Hira,ja-Kana,ja-Hani"}, 3 }, + { "zh-Hanb", { "zh-Hant", "zh-Bopo", "zh-Hant,zh-Bopo"}, 2 }, + { "zh-Hanb", { "ja-Hanb", "zh-Hant,zh-Bopo"}, 1 }, + + // Language match with unified subscript bits. + { "zh-Hanb", { "zh-Hant", "zh-Bopo", "ja-Hant,ja-Bopo", "zh-Hant,zh-Bopo"}, 3 }, + { "zh-Hanb", { "zh-Hant", "zh-Bopo", "ja-Hant,zh-Bopo", "zh-Hant,zh-Bopo"}, 3 }, }; for (auto testCase : testCases) { + std::string fontLanguagesStr = "{"; + for (size_t i = 0; i < testCase.fontLanguages.size(); ++i) { + if (i != 0) { + fontLanguagesStr += ", "; + } + fontLanguagesStr += "\"" + testCase.fontLanguages[i] + "\""; + } + fontLanguagesStr += "}"; SCOPED_TRACE("Test of user preferred languages: \"" + testCase.userPreferredLanguages + - "\" with font languages: " + testCase.fontLanguages); + "\" with font languages: " + fontLanguagesStr); std::vector families; @@ -778,12 +810,10 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { // Each font family is associated with a specified language. All font families except for // the first font support U+9AA8. std::unordered_map fontLangIdxMap; - const FontLanguages& fontLanguages = registerAndGetFontLanguages(testCase.fontLanguages); - for (size_t i = 0; i < fontLanguages.size(); ++i) { - const FontLanguage& fontLanguage = fontLanguages[i]; + for (size_t i = 0; i < testCase.fontLanguages.size(); ++i) { FontFamily* family = new FontFamily( - FontStyle::registerLanguageList(fontLanguage.getString()), 0 /* variant */); + FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */); MinikinFont* minikin_font = new MinikinFontForTest(kJAFont); family->addFont(minikin_font); families.push_back(family); diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index 34a92964dc..907f3950bf 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -30,7 +30,7 @@ namespace android { typedef ICUTestBase FontLanguagesTest; typedef ICUTestBase FontLanguageTest; -static FontLanguages createFontLanguages(const std::string& input) { +static const FontLanguages& createFontLanguages(const std::string& input) { AutoMutex _l(gMinikinLock); uint32_t langId = FontLanguageListCache::getId(input); return FontLanguageListCache::getById(langId); @@ -217,35 +217,30 @@ TEST_F(FontLanguagesTest, basicTests) { EXPECT_EQ(0u, emptyLangs.size()); FontLanguage english = createFontLanguage("en"); - FontLanguages singletonLangs = createFontLanguages("en"); + const FontLanguages& singletonLangs = createFontLanguages("en"); EXPECT_EQ(1u, singletonLangs.size()); EXPECT_EQ(english, singletonLangs[0]); FontLanguage french = createFontLanguage("fr"); - FontLanguages twoLangs = createFontLanguages("en,fr"); + const FontLanguages& twoLangs = createFontLanguages("en,fr"); EXPECT_EQ(2u, twoLangs.size()); EXPECT_EQ(english, twoLangs[0]); EXPECT_EQ(french, twoLangs[1]); } TEST_F(FontLanguagesTest, unsupportedLanguageTests) { - FontLanguage unsupportedLang = createFontLanguage("abcd"); - ASSERT_TRUE(unsupportedLang.isUnsupported()); + const FontLanguages& oneUnsupported = createFontLanguages("abcd-example"); + EXPECT_TRUE(oneUnsupported.empty()); - FontLanguages oneUnsupported = createFontLanguages("abcd-example"); - EXPECT_EQ(1u, oneUnsupported.size()); - EXPECT_TRUE(oneUnsupported[0].isUnsupported()); - - FontLanguages twoUnsupporteds = createFontLanguages("abcd-example,abcd-example"); - EXPECT_EQ(1u, twoUnsupporteds.size()); - EXPECT_TRUE(twoUnsupporteds[0].isUnsupported()); + const FontLanguages& twoUnsupporteds = createFontLanguages("abcd-example,abcd-example"); + EXPECT_TRUE(twoUnsupporteds.empty()); FontLanguage english = createFontLanguage("en"); - FontLanguages firstUnsupported = createFontLanguages("abcd-example,en"); + const FontLanguages& firstUnsupported = createFontLanguages("abcd-example,en"); EXPECT_EQ(1u, firstUnsupported.size()); EXPECT_EQ(english, firstUnsupported[0]); - FontLanguages lastUnsupported = createFontLanguages("en,abcd-example"); + const FontLanguages& lastUnsupported = createFontLanguages("en,abcd-example"); EXPECT_EQ(1u, lastUnsupported.size()); EXPECT_EQ(english, lastUnsupported[0]); } @@ -256,20 +251,20 @@ TEST_F(FontLanguagesTest, repeatedLanguageTests) { FontLanguage englishInLatn = createFontLanguage("en-Latn"); ASSERT_TRUE(english == englishInLatn); - FontLanguages langs = createFontLanguages("en,en-Latn"); + const FontLanguages& langs = createFontLanguages("en,en-Latn"); EXPECT_EQ(1u, langs.size()); EXPECT_EQ(english, langs[0]); // Country codes are ignored. - FontLanguages fr = createFontLanguages("fr,fr-CA,fr-FR"); + const FontLanguages& fr = createFontLanguages("fr,fr-CA,fr-FR"); EXPECT_EQ(1u, fr.size()); EXPECT_EQ(french, fr[0]); // The order should be kept. - langs = createFontLanguages("en,fr,en-Latn"); - EXPECT_EQ(2u, langs.size()); - EXPECT_EQ(english, langs[0]); - EXPECT_EQ(french, langs[1]); + const FontLanguages& langs2 = createFontLanguages("en,fr,en-Latn"); + EXPECT_EQ(2u, langs2.size()); + EXPECT_EQ(english, langs2[0]); + EXPECT_EQ(french, langs2[1]); } TEST_F(FontLanguagesTest, undEmojiTests) { diff --git a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp index fbbd9376f0..2a046713c9 100644 --- a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp +++ b/engine/src/flutter/tests/FontLanguageListCacheTest.cpp @@ -56,18 +56,18 @@ TEST_F(FontLanguageListCacheTest, getById) { FontLanguage english = FontLanguageListCache::getById(enLangId)[0]; FontLanguage japanese = FontLanguageListCache::getById(jpLangId)[0]; - FontLanguages defLangs = FontLanguageListCache::getById(0); - EXPECT_EQ(1UL, defLangs.size()); - EXPECT_TRUE(defLangs[0].isUnsupported()); + const FontLanguages& defLangs = FontLanguageListCache::getById(0); + EXPECT_TRUE(defLangs.empty()); - FontLanguages langs = FontLanguageListCache::getById(FontLanguageListCache::getId("en")); + const FontLanguages& langs = FontLanguageListCache::getById(FontLanguageListCache::getId("en")); ASSERT_EQ(1UL, langs.size()); EXPECT_EQ(english, langs[0]); - langs = FontLanguageListCache::getById(FontLanguageListCache::getId("en,jp")); - ASSERT_EQ(2UL, langs.size()); - EXPECT_EQ(english, langs[0]); - EXPECT_EQ(japanese, langs[1]); + const FontLanguages& langs2 = + FontLanguageListCache::getById(FontLanguageListCache::getId("en,jp")); + ASSERT_EQ(2UL, langs2.size()); + EXPECT_EQ(english, langs2[0]); + EXPECT_EQ(japanese, langs2[1]); } } // android From 1ea4165cef7651770fe28a0eada3da593bb149ad Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Thu, 7 Apr 2016 12:20:12 -0700 Subject: [PATCH 174/364] Purge hb font on Minikin font destruction This patch eagerly purges the corresponding hb_font_t object from the HbFontCache when the underlying MinikinFont is destroyed. After that, the key will no longer be accessed, so having the entry is wastes memory. Bug: 27251075 Bug: 27860101 Change-Id: I1b98016133fe3baf6525ac37d970a65ddccadb4f --- .../src/flutter/include/minikin/MinikinFont.h | 2 ++ engine/src/flutter/libs/minikin/Android.mk | 1 + .../src/flutter/libs/minikin/HbFontCache.cpp | 10 +++++++ engine/src/flutter/libs/minikin/HbFontCache.h | 1 + .../src/flutter/libs/minikin/MinikinFont.cpp | 26 +++++++++++++++++++ 5 files changed, 40 insertions(+) create mode 100644 engine/src/flutter/libs/minikin/MinikinFont.cpp diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 2ad2151a31..5c0ab0f681 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -96,6 +96,8 @@ class MinikinFontFreeType; class MinikinFont : public MinikinRefCounted { public: + virtual ~MinikinFont(); + virtual float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const = 0; diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 7cd6f6883c..2b5ff0667f 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -32,6 +32,7 @@ minikin_src_files := \ Measurement.cpp \ MinikinInternal.cpp \ MinikinRefCounted.cpp \ + MinikinFont.cpp \ MinikinFontFreeType.cpp \ SparseBitSet.cpp \ WordBreaker.cpp diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index 73308efab7..7a6b3c1c43 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -75,6 +75,10 @@ public: mCache.clear(); } + void remove(int32_t fontId) { + mCache.remove(fontId); + } + private: static const size_t kMaxEntries = 100; @@ -95,6 +99,12 @@ void purgeHbFontCacheLocked() { getFontCacheLocked()->clear(); } +void purgeHbFont(const MinikinFont* minikinFont) { + AutoMutex _l(gMinikinLock); + const int32_t fontId = minikinFont->GetUniqueId(); + getFontCacheLocked()->remove(fontId); +} + hb_font_t* getHbFontLocked(MinikinFont* minikinFont) { assertMinikinLocked(); static hb_font_t* nullFaceFont = nullptr; diff --git a/engine/src/flutter/libs/minikin/HbFontCache.h b/engine/src/flutter/libs/minikin/HbFontCache.h index 62564d35b9..92e465ac40 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.h +++ b/engine/src/flutter/libs/minikin/HbFontCache.h @@ -23,6 +23,7 @@ namespace android { class MinikinFont; void purgeHbFontCacheLocked(); +void purgeHbFont(const MinikinFont* minikinFont); hb_font_t* getHbFontLocked(MinikinFont* minikinFont); } // namespace android diff --git a/engine/src/flutter/libs/minikin/MinikinFont.cpp b/engine/src/flutter/libs/minikin/MinikinFont.cpp new file mode 100644 index 0000000000..d56ec9c701 --- /dev/null +++ b/engine/src/flutter/libs/minikin/MinikinFont.cpp @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2016 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 +#include "HbFontCache.h" + +namespace android { + +MinikinFont::~MinikinFont() { + purgeHbFont(this); +} + +} // namespace android From a8e8948bd792b8c13bbcd5c59496c85c24a2952b Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 6 Apr 2016 15:19:34 -0700 Subject: [PATCH 175/364] Avoid copying of font table data The hb_font_t object holds on to tables of font data, acquired through the MinikinFont::GetTable interface, which is based on copying data into caller-owned buffers. Now that we're caching lots of hb_font_t's, the cost of these buffers is significant. This patch moves to a different interface, inspired by HarfBuzz's hb_reference_table API, where the font can provide a pointer to the actual font data (which will often be mmap'ed, so it doesn't even consume physical RAM). Bug: 27860101 Change-Id: Id766ab16a8d342bf7322a90e076e801271d527d4 --- .../src/flutter/include/minikin/MinikinFont.h | 22 ++++++++- .../include/minikin/MinikinFontFreeType.h | 5 +- .../src/flutter/libs/minikin/FontFamily.cpp | 25 ++++------ .../src/flutter/libs/minikin/HbFontCache.cpp | 47 ++++++++++--------- engine/src/flutter/libs/minikin/Layout.cpp | 1 + .../libs/minikin/MinikinFontFreeType.cpp | 32 ++++++++----- .../flutter/libs/minikin/MinikinInternal.cpp | 10 ++++ .../flutter/libs/minikin/MinikinInternal.h | 33 +++++++++++++ .../src/flutter/tests/MinikinFontForTest.cpp | 22 +++++---- engine/src/flutter/tests/MinikinFontForTest.h | 2 +- 10 files changed, 137 insertions(+), 62 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 5c0ab0f681..02982359d9 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -94,6 +94,9 @@ struct MinikinRect { class MinikinFontFreeType; +// Callback for freeing data +typedef void (*MinikinDestroyFunc) (void* data); + class MinikinFont : public MinikinRefCounted { public: virtual ~MinikinFont(); @@ -104,8 +107,23 @@ public: virtual void GetBounds(MinikinRect* bounds, uint32_t glyph_id, const MinikinPaint &paint) const = 0; - // If buf is NULL, just update size - virtual bool GetTable(uint32_t tag, uint8_t *buf, size_t *size) = 0; + virtual const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) = 0; + + // Override if font can provide access to raw data + virtual const void* GetFontData() const { + return nullptr; + } + + // Override if font can provide access to raw data + virtual size_t GetFontSize() const { + return 0; + } + + // Override if font can provide access to raw data. + // Returns index within OpenType collection + virtual int GetFontIndex() const { + return 0; + } virtual int32_t GetUniqueId() const = 0; diff --git a/engine/src/flutter/include/minikin/MinikinFontFreeType.h b/engine/src/flutter/include/minikin/MinikinFontFreeType.h index a957d124c7..535c2498a2 100644 --- a/engine/src/flutter/include/minikin/MinikinFontFreeType.h +++ b/engine/src/flutter/include/minikin/MinikinFontFreeType.h @@ -48,8 +48,9 @@ public: void GetBounds(MinikinRect* bounds, uint32_t glyph_id, const MinikinPaint& paint) const; - // If buf is NULL, just update size - bool GetTable(uint32_t tag, uint8_t *buf, size_t *size); + const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy); + + // TODO: provide access to raw data, as an optimization. int32_t GetUniqueId() const; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 88448a10fd..0f71f511ca 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -77,15 +77,11 @@ FontFamily::~FontFamily() { bool FontFamily::addFont(MinikinFont* typeface) { AutoMutex _l(gMinikinLock); const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); - size_t os2Size = 0; - bool ok = typeface->GetTable(os2Tag, NULL, &os2Size); - if (!ok) return false; - UniquePtr os2Data(new uint8_t[os2Size]); - ok = typeface->GetTable(os2Tag, os2Data.get(), &os2Size); - if (!ok) return false; + HbBlob os2Table(getFontTable(typeface, os2Tag)); + if (os2Table.get() == nullptr) return false; int weight; bool italic; - if (analyzeStyle(os2Data.get(), os2Size, &weight, &italic)) { + if (analyzeStyle(os2Table.get(), os2Table.size(), &weight, &italic)) { //ALOGD("analyzed weight = %d, italic = %s", weight, italic ? "true" : "false"); FontStyle style(weight, italic); addFontLocked(typeface, style); @@ -165,20 +161,15 @@ const SparseBitSet* FontFamily::getCoverage() { const FontStyle defaultStyle; MinikinFont* typeface = getClosestMatch(defaultStyle).font; const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); - size_t cmapSize = 0; - if (!typeface->GetTable(cmapTag, NULL, &cmapSize)) { + HbBlob cmapTable(getFontTable(typeface, cmapTag)); + if (cmapTable.get() == nullptr) { ALOGE("Could not get cmap table size!\n"); // Note: This means we will retry on the next call to getCoverage, as we can't store // the failure. This is fine, as we assume this doesn't really happen in practice. return nullptr; } - UniquePtr cmapData(new uint8_t[cmapSize]); - if (!typeface->GetTable(cmapTag, cmapData.get(), &cmapSize)) { - ALOGE("Unexpected failure to read cmap table!\n"); - return nullptr; - } // TODO: Error check? - CmapCoverage::getCoverage(mCoverage, cmapData.get(), cmapSize, &mHasVSTable); + CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); #ifdef VERBOSE_DEBUG ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), mCoverage.nextSetBit(0)); @@ -198,7 +189,9 @@ bool FontFamily::hasVariationSelector(uint32_t codepoint, uint32_t variationSele MinikinFont* minikinFont = getClosestMatch(defaultStyle).font; hb_font_t* font = getHbFontLocked(minikinFont); uint32_t unusedGlyph; - return hb_font_get_glyph(font, codepoint, variationSelector, &unusedGlyph); + bool result = hb_font_get_glyph(font, codepoint, variationSelector, &unusedGlyph); + hb_font_destroy(font); + return result; } bool FontFamily::hasVSTable() const { diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index 7a6b3c1c43..9544dc2b11 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -30,26 +30,18 @@ namespace android { static hb_blob_t* referenceTable(hb_face_t* /* face */, hb_tag_t tag, void* userData) { MinikinFont* font = reinterpret_cast(userData); - size_t length = 0; - bool ok = font->GetTable(tag, NULL, &length); - if (!ok) { - return 0; + MinikinDestroyFunc destroy = 0; + size_t size = 0; + const void* buffer = font->GetTable(tag, &size, &destroy); + if (buffer == nullptr) { + return nullptr; } - char* buffer = reinterpret_cast(malloc(length)); - if (!buffer) { - return 0; - } - ok = font->GetTable(tag, reinterpret_cast(buffer), &length); #ifdef VERBOSE_DEBUG - ALOGD("referenceTable %c%c%c%c length=%zd %d", - (tag >>24)&0xff, (tag>>16)&0xff, (tag>>8)&0xff, tag&0xff, length, ok); + ALOGD("referenceTable %c%c%c%c length=%zd", + (tag >>24)&0xff, (tag>>16)&0xff, (tag>>8)&0xff, tag&0xff, size); #endif - if (!ok) { - free(buffer); - return 0; - } - return hb_blob_create(const_cast(buffer), length, - HB_MEMORY_MODE_WRITABLE, buffer, free); + return hb_blob_create(reinterpret_cast(buffer), size, + HB_MEMORY_MODE_READONLY, const_cast(buffer), destroy); } class HbFontCache : private OnEntryRemoved { @@ -105,24 +97,37 @@ void purgeHbFont(const MinikinFont* minikinFont) { getFontCacheLocked()->remove(fontId); } +// Returns a new reference to a hb_font_t object, caller is +// responsible for calling hb_font_destroy() on it. hb_font_t* getHbFontLocked(MinikinFont* minikinFont) { assertMinikinLocked(); + // TODO: get rid of nullFaceFont static hb_font_t* nullFaceFont = nullptr; if (minikinFont == nullptr) { if (nullFaceFont == nullptr) { nullFaceFont = hb_font_create(nullptr); } - return nullFaceFont; + return hb_font_reference(nullFaceFont); } HbFontCache* fontCache = getFontCacheLocked(); const int32_t fontId = minikinFont->GetUniqueId(); hb_font_t* font = fontCache->get(fontId); if (font != nullptr) { - return font; + return hb_font_reference(font); } - hb_face_t* face = hb_face_create_for_tables(referenceTable, minikinFont, nullptr); + hb_face_t* face; + const void* buf = minikinFont->GetFontData(); + if (buf == nullptr) { + face = hb_face_create_for_tables(referenceTable, minikinFont, nullptr); + } else { + size_t size = minikinFont->GetFontSize(); + hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, + HB_MEMORY_MODE_READONLY, nullptr, nullptr); + face = hb_face_create(blob, minikinFont->GetFontIndex()); + hb_blob_destroy(blob); + } hb_font_t* parent_font = hb_font_create(face); hb_ot_font_set_funcs(parent_font); @@ -133,7 +138,7 @@ hb_font_t* getHbFontLocked(MinikinFont* minikinFont) { hb_font_destroy(parent_font); hb_face_destroy(face); fontCache->put(fontId, font); - return font; + return hb_font_reference(font); } } // namespace android diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 3a05acfd9d..9c1d6a873a 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -99,6 +99,7 @@ struct LayoutContext { void clearHbFonts() { for (size_t i = 0; i < hbFonts.size(); i++) { hb_font_set_funcs(hbFonts[i], nullptr, nullptr, nullptr); + hb_font_destroy(hbFonts[i]); } hbFonts.clear(); } diff --git a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp index c9eb456be5..b9ea5d7dff 100644 --- a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp @@ -41,8 +41,8 @@ MinikinFontFreeType::~MinikinFontFreeType() { float MinikinFontFreeType::GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const { FT_Set_Pixel_Sizes(mTypeface, 0, paint.size); - FT_UInt32 flags = FT_LOAD_DEFAULT; // TODO: respect hinting settings - FT_Fixed advance; + FT_UInt32 flags = FT_LOAD_DEFAULT; // TODO: respect hinting settings + FT_Fixed advance; FT_Get_Advance(mTypeface, glyph_id, flags, &advance); return advance * (1.0 / 65536); } @@ -52,18 +52,28 @@ void MinikinFontFreeType::GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph // TODO: NYI } -bool MinikinFontFreeType::GetTable(uint32_t tag, uint8_t *buf, size_t *size) { - FT_ULong ftsize = *size; - FT_Error error = FT_Load_Sfnt_Table(mTypeface, tag, 0, buf, &ftsize); - if (error != 0) { - return false; - } - *size = ftsize; - return true; +const void* MinikinFontFreeType::GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) { + FT_ULong ftsize = 0; + FT_Error error = FT_Load_Sfnt_Table(mTypeface, tag, 0, nullptr, &ftsize); + if (error != 0) { + return nullptr; + } + FT_Byte* buf = reinterpret_cast(malloc(ftsize)); + if (buf == nullptr) { + return nullptr; + } + error = FT_Load_Sfnt_Table(mTypeface, tag, 0, buf, &ftsize); + if (error != 0) { + free(buf); + return nullptr; + } + *destroy = free; + *size = ftsize; + return buf; } int32_t MinikinFontFreeType::GetUniqueId() const { - return mUniqueId; + return mUniqueId; } bool MinikinFontFreeType::Render(uint32_t glyph_id, const MinikinPaint& /* paint */, diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 175ced8c77..e00f63951b 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -17,6 +17,7 @@ // Definitions internal to Minikin #include "MinikinInternal.h" +#include "HbFontCache.h" #include @@ -72,4 +73,13 @@ bool isEmojiBase(uint32_t c) { } } +hb_blob_t* getFontTable(MinikinFont* minikinFont, uint32_t tag) { + assertMinikinLocked(); + hb_font_t* font = getHbFontLocked(minikinFont); + hb_face_t* face = hb_font_get_face(font); + hb_blob_t* blob = hb_face_reference_table(face, tag); + hb_font_destroy(font); + return blob; +} + } diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index 3d68691b35..709fb9f691 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -19,8 +19,12 @@ #ifndef MINIKIN_INTERNAL_H #define MINIKIN_INTERNAL_H +#include + #include +#include + namespace android { // All external Minikin interfaces are designed to be thread-safe. @@ -38,6 +42,35 @@ bool isEmojiBase(uint32_t c); // Returns true if c is emoji modifier. bool isEmojiModifier(uint32_t c); +hb_blob_t* getFontTable(MinikinFont* minikinFont, uint32_t tag); + +// An RAII wrapper for hb_blob_t +class HbBlob { +public: + // Takes ownership of hb_blob_t object, caller is no longer + // responsible for calling hb_blob_destroy(). + HbBlob(hb_blob_t* blob) : mBlob(blob) { + } + + ~HbBlob() { + hb_blob_destroy(mBlob); + } + + const uint8_t* get() const { + const char* data = hb_blob_get_data(mBlob, nullptr); + return reinterpret_cast(data); + } + + size_t size() const { + unsigned int length = 0; + hb_blob_get_data(mBlob, &length); + return (size_t)length; + } + +private: + hb_blob_t* mBlob; +}; + } #endif // MINIKIN_INTERNAL_H diff --git a/engine/src/flutter/tests/MinikinFontForTest.cpp b/engine/src/flutter/tests/MinikinFontForTest.cpp index ed7075188b..96f3326d2a 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/MinikinFontForTest.cpp @@ -40,16 +40,20 @@ void MinikinFontForTest::GetBounds(android::MinikinRect* /* bounds */, uint32_t LOG_ALWAYS_FATAL("MinikinFontForTest::GetBounds is not yet implemented"); } -bool MinikinFontForTest::GetTable(uint32_t tag, uint8_t *buf, size_t *size) { - if (buf == NULL) { - const size_t tableSize = mTypeface->getTableSize(tag); - *size = tableSize; - return tableSize != 0; - } else { - const size_t actualSize = mTypeface->getTableData(tag, 0, *size, buf); - *size = actualSize; - return actualSize != 0; +const void* MinikinFontForTest::GetTable(uint32_t tag, size_t* size, + android::MinikinDestroyFunc* destroy) { + const size_t tableSize = mTypeface->getTableSize(tag); + *size = tableSize; + if (tableSize == 0) { + return nullptr; } + void* buf = malloc(tableSize); + if (buf == nullptr) { + return nullptr; + } + mTypeface->getTableData(tag, 0, tableSize, buf); + *destroy = free; + return buf; } int32_t MinikinFontForTest::GetUniqueId() const { diff --git a/engine/src/flutter/tests/MinikinFontForTest.h b/engine/src/flutter/tests/MinikinFontForTest.h index 790348deae..4686f7ab20 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.h +++ b/engine/src/flutter/tests/MinikinFontForTest.h @@ -30,7 +30,7 @@ public: float GetHorizontalAdvance(uint32_t glyph_id, const android::MinikinPaint &paint) const; void GetBounds(android::MinikinRect* bounds, uint32_t glyph_id, const android::MinikinPaint& paint) const; - bool GetTable(uint32_t tag, uint8_t *buf, size_t *size); + const void* GetTable(uint32_t tag, size_t* size, android::MinikinDestroyFunc* destroy); int32_t GetUniqueId() const; const std::string& fontPath() const { return mFontPath; } From d2161cf80f6f23bb977d92f79e49fba999846c79 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Fri, 8 Apr 2016 10:28:47 -0700 Subject: [PATCH 176/364] Update minikin/sample code to use new GetTable We changed the signature of the MinikinFont::GetTable method. This patch updates the sample code, and fixes the build. Change-Id: I1977be868bf7636986fc802915f3dd54c418a73a --- engine/src/flutter/sample/MinikinSkia.cpp | 22 +++++++++++++--------- engine/src/flutter/sample/MinikinSkia.h | 3 +-- 2 files changed, 14 insertions(+), 11 deletions(-) diff --git a/engine/src/flutter/sample/MinikinSkia.cpp b/engine/src/flutter/sample/MinikinSkia.cpp index feda8adff1..c4971bb6e1 100644 --- a/engine/src/flutter/sample/MinikinSkia.cpp +++ b/engine/src/flutter/sample/MinikinSkia.cpp @@ -47,16 +47,20 @@ void MinikinFontSkia::GetBounds(MinikinRect* bounds, uint32_t glyph_id, bounds->mBottom = skBounds.fBottom; } -bool MinikinFontSkia::GetTable(uint32_t tag, uint8_t *buf, size_t *size) { - if (buf == NULL) { - const size_t tableSize = mTypeface->getTableSize(tag); - *size = tableSize; - return tableSize != 0; - } else { - const size_t actualSize = mTypeface->getTableData(tag, 0, *size, buf); - *size = actualSize; - return actualSize != 0; +const void* MinikinFontSkia::GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) { + // we don't have a buffer to the font data, copy to own buffer + const size_t tableSize = mTypeface->getTableSize(tag); + *size = tableSize; + if (tableSize == 0) { + return nullptr; } + void* buf = malloc(tableSize); + if (buf == nullptr) { + return nullptr; + } + mTypeface->getTableData(tag, 0, tableSize, buf); + *destroy = free; + return buf; } SkTypeface *MinikinFontSkia::GetSkTypeface() { diff --git a/engine/src/flutter/sample/MinikinSkia.h b/engine/src/flutter/sample/MinikinSkia.h index 25ac1b0c08..e1d7bf6da3 100644 --- a/engine/src/flutter/sample/MinikinSkia.h +++ b/engine/src/flutter/sample/MinikinSkia.h @@ -12,8 +12,7 @@ public: void GetBounds(MinikinRect* bounds, uint32_t glyph_id, const MinikinPaint& paint) const; - // If buf is NULL, just update size - bool GetTable(uint32_t tag, uint8_t *buf, size_t *size); + const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy); int32_t GetUniqueId() const; From bb8b7fd32fd69c8b227996c782622f7941a944cb Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Mon, 11 Apr 2016 17:53:34 +0900 Subject: [PATCH 177/364] Fix minikin_unittests This CL fixes following test cases in minikin_tests - FontFamilyTest.hasVariationSelectorTest - HbFontCacheTest.getHbFontLockedTest - HbFontCacheTest.purgeCacheTest For the fix of FontFamilyTest.hasVariationSelectorTest, removing virtual from GetUniqueId() in MinikinFont. After [1], MinikinFont's destructor started calling purgeHbCache() which calls virtual method, MinikinFont::GetUniqueId(). Fortunately, the SkTypeface::uniqueID() returns just internal value, so we can store it at the construction time and use it instead of calling SkTypeface::uniqueID() every time. This patch also changes purgeHbFont to purgeHbFontLocked, as all uses of it were already under global mutex. This change avoids deadlock on explicit unref, as when invoked by a Java finalizer from the Java object that holds a reference to the font. Some of the tests needed to change to using the ref counting protocol rather than explicitly destructing font objects, as well. [1] 1ea4165cef7651770fe28a0eada3da593bb149ad Bug: 28105730 Bug: 28105688 Change-Id: Ie5983c4869147dacabdca81af1605066cd680b3f --- .../src/flutter/include/minikin/MinikinFont.h | 8 +++- .../include/minikin/MinikinFontFreeType.h | 3 -- .../include/minikin/MinikinRefCounted.h | 17 +++++++++ .../src/flutter/libs/minikin/HbFontCache.cpp | 4 +- engine/src/flutter/libs/minikin/HbFontCache.h | 2 +- .../src/flutter/libs/minikin/MinikinFont.cpp | 2 +- .../libs/minikin/MinikinFontFreeType.cpp | 6 +-- engine/src/flutter/sample/MinikinSkia.cpp | 5 +-- engine/src/flutter/sample/MinikinSkia.h | 2 - engine/src/flutter/tests/FontFamilyTest.cpp | 37 ++++++++++--------- .../src/flutter/tests/MinikinFontForTest.cpp | 14 ++++--- engine/src/flutter/tests/MinikinFontForTest.h | 2 +- engine/src/flutter/tests/how_to_run.txt | 2 +- 13 files changed, 58 insertions(+), 46 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 02982359d9..4951514518 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -99,6 +99,8 @@ typedef void (*MinikinDestroyFunc) (void* data); class MinikinFont : public MinikinRefCounted { public: + MinikinFont(int32_t uniqueId) : mUniqueId(uniqueId) {} + virtual ~MinikinFont(); virtual float GetHorizontalAdvance(uint32_t glyph_id, @@ -125,12 +127,14 @@ public: return 0; } - virtual int32_t GetUniqueId() const = 0; - 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 android diff --git a/engine/src/flutter/include/minikin/MinikinFontFreeType.h b/engine/src/flutter/include/minikin/MinikinFontFreeType.h index 535c2498a2..baa08df3b7 100644 --- a/engine/src/flutter/include/minikin/MinikinFontFreeType.h +++ b/engine/src/flutter/include/minikin/MinikinFontFreeType.h @@ -52,8 +52,6 @@ public: // TODO: provide access to raw data, as an optimization. - int32_t GetUniqueId() const; - // Not a virtual method, as the protocol to access rendered // glyph bitmaps is probably different depending on the // backend. @@ -64,7 +62,6 @@ public: private: FT_Face mTypeface; - int32_t mUniqueId; static int32_t sIdCounter; }; diff --git a/engine/src/flutter/include/minikin/MinikinRefCounted.h b/engine/src/flutter/include/minikin/MinikinRefCounted.h index 74d27fec7d..603aff0cce 100644 --- a/engine/src/flutter/include/minikin/MinikinRefCounted.h +++ b/engine/src/flutter/include/minikin/MinikinRefCounted.h @@ -37,6 +37,23 @@ private: int mRefcount_; }; +// An RAII container for reference counted objects. +// Note: this is only suitable for clients which are _not_ holding the global lock. +template +class MinikinAutoUnref { +public: + MinikinAutoUnref(T* obj) : mObj(obj) { + } + ~MinikinAutoUnref() { + mObj->Unref(); + } + T& operator*() const { return *mObj; } + T* operator->() const { return mObj; } + T* get() const { return mObj; } +private: + T* mObj; +}; + } #endif // MINIKIN_REF_COUNTED_H \ No newline at end of file diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index 9544dc2b11..3be942d7b9 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -91,8 +91,8 @@ void purgeHbFontCacheLocked() { getFontCacheLocked()->clear(); } -void purgeHbFont(const MinikinFont* minikinFont) { - AutoMutex _l(gMinikinLock); +void purgeHbFontLocked(const MinikinFont* minikinFont) { + assertMinikinLocked(); const int32_t fontId = minikinFont->GetUniqueId(); getFontCacheLocked()->remove(fontId); } diff --git a/engine/src/flutter/libs/minikin/HbFontCache.h b/engine/src/flutter/libs/minikin/HbFontCache.h index 92e465ac40..449b354c2d 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.h +++ b/engine/src/flutter/libs/minikin/HbFontCache.h @@ -23,7 +23,7 @@ namespace android { class MinikinFont; void purgeHbFontCacheLocked(); -void purgeHbFont(const MinikinFont* minikinFont); +void purgeHbFontLocked(const MinikinFont* minikinFont); hb_font_t* getHbFontLocked(MinikinFont* minikinFont); } // namespace android diff --git a/engine/src/flutter/libs/minikin/MinikinFont.cpp b/engine/src/flutter/libs/minikin/MinikinFont.cpp index d56ec9c701..ef42e9b12f 100644 --- a/engine/src/flutter/libs/minikin/MinikinFont.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFont.cpp @@ -20,7 +20,7 @@ namespace android { MinikinFont::~MinikinFont() { - purgeHbFont(this); + purgeHbFontLocked(this); } } // namespace android diff --git a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp index b9ea5d7dff..4a1b115082 100644 --- a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp @@ -30,8 +30,8 @@ namespace android { int32_t MinikinFontFreeType::sIdCounter = 0; MinikinFontFreeType::MinikinFontFreeType(FT_Face typeface) : + MinikinFont(sIdCounter++), mTypeface(typeface) { - mUniqueId = sIdCounter++; } MinikinFontFreeType::~MinikinFontFreeType() { @@ -72,10 +72,6 @@ const void* MinikinFontFreeType::GetTable(uint32_t tag, size_t* size, MinikinDes return buf; } -int32_t MinikinFontFreeType::GetUniqueId() const { - return mUniqueId; -} - bool MinikinFontFreeType::Render(uint32_t glyph_id, const MinikinPaint& /* paint */, GlyphBitmap *result) { FT_Error error; diff --git a/engine/src/flutter/sample/MinikinSkia.cpp b/engine/src/flutter/sample/MinikinSkia.cpp index c4971bb6e1..e2ecde02d1 100644 --- a/engine/src/flutter/sample/MinikinSkia.cpp +++ b/engine/src/flutter/sample/MinikinSkia.cpp @@ -7,6 +7,7 @@ namespace android { MinikinFontSkia::MinikinFontSkia(SkTypeface *typeface) : + MinikinFont(typeface->uniqueID()), mTypeface(typeface) { } @@ -67,8 +68,4 @@ SkTypeface *MinikinFontSkia::GetSkTypeface() { return mTypeface; } -int32_t MinikinFontSkia::GetUniqueId() const { - return mTypeface->uniqueID(); -} - } diff --git a/engine/src/flutter/sample/MinikinSkia.h b/engine/src/flutter/sample/MinikinSkia.h index e1d7bf6da3..6eb9065cc2 100644 --- a/engine/src/flutter/sample/MinikinSkia.h +++ b/engine/src/flutter/sample/MinikinSkia.h @@ -14,8 +14,6 @@ public: const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy); - int32_t GetUniqueId() const; - SkTypeface *GetSkTypeface(); private: diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index 907f3950bf..194063f5f8 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -350,9 +350,9 @@ void expectVSGlyphs(FontFamily* family, uint32_t codepoint, const std::set minikinFont(new MinikinFontForTest(kVsTestFont)); + MinikinAutoUnref family(new FontFamily); + family->addFont(minikinFont.get()); AutoMutex _l(gMinikinLock); @@ -365,24 +365,24 @@ TEST_F(FontFamilyTest, hasVariationSelectorTest) { const uint32_t kVS20 = 0xE0103; const uint32_t kSupportedChar1 = 0x82A6; - EXPECT_TRUE(family.getCoverage()->get(kSupportedChar1)); - expectVSGlyphs(&family, kSupportedChar1, std::set({kVS1, kVS17, kVS18, kVS19})); + EXPECT_TRUE(family->getCoverage()->get(kSupportedChar1)); + expectVSGlyphs(family.get(), kSupportedChar1, std::set({kVS1, kVS17, kVS18, kVS19})); const uint32_t kSupportedChar2 = 0x845B; - EXPECT_TRUE(family.getCoverage()->get(kSupportedChar2)); - expectVSGlyphs(&family, kSupportedChar2, std::set({kVS2, kVS18, kVS19, kVS20})); + EXPECT_TRUE(family->getCoverage()->get(kSupportedChar2)); + expectVSGlyphs(family.get(), kSupportedChar2, std::set({kVS2, kVS18, kVS19, kVS20})); const uint32_t kNoVsSupportedChar = 0x537F; - EXPECT_TRUE(family.getCoverage()->get(kNoVsSupportedChar)); - expectVSGlyphs(&family, kNoVsSupportedChar, std::set()); + EXPECT_TRUE(family->getCoverage()->get(kNoVsSupportedChar)); + expectVSGlyphs(family.get(), kNoVsSupportedChar, std::set()); const uint32_t kVsOnlySupportedChar = 0x717D; - EXPECT_FALSE(family.getCoverage()->get(kVsOnlySupportedChar)); - expectVSGlyphs(&family, kVsOnlySupportedChar, std::set({kVS3, kVS19, kVS20})); + EXPECT_FALSE(family->getCoverage()->get(kVsOnlySupportedChar)); + expectVSGlyphs(family.get(), kVsOnlySupportedChar, std::set({kVS3, kVS19, kVS20})); const uint32_t kNotSupportedChar = 0x845C; - EXPECT_FALSE(family.getCoverage()->get(kNotSupportedChar)); - expectVSGlyphs(&family, kNotSupportedChar, std::set()); + EXPECT_FALSE(family->getCoverage()->get(kNotSupportedChar)); + expectVSGlyphs(family.get(), kNotSupportedChar, std::set()); } TEST_F(FontFamilyTest, hasVSTableTest) { @@ -403,12 +403,13 @@ TEST_F(FontFamilyTest, hasVSTableTest) { "Font " + testCase.fontPath + " should have a variation sequence table." : "Font " + testCase.fontPath + " shouldn't have a variation sequence table."); - MinikinFontForTest minikinFont(testCase.fontPath); - FontFamily family; - family.addFont(&minikinFont); - family.getCoverage(); + MinikinAutoUnref minikinFont(new MinikinFontForTest(testCase.fontPath)); + MinikinAutoUnref family(new FontFamily); + family->addFont(minikinFont.get()); + AutoMutex _l(gMinikinLock); + family->getCoverage(); - EXPECT_EQ(testCase.hasVSTable, family.hasVSTable()); + EXPECT_EQ(testCase.hasVSTable, family->hasVSTable()); } } diff --git a/engine/src/flutter/tests/MinikinFontForTest.cpp b/engine/src/flutter/tests/MinikinFontForTest.cpp index 96f3326d2a..66dd4ea473 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/MinikinFontForTest.cpp @@ -22,8 +22,14 @@ #include -MinikinFontForTest::MinikinFontForTest(const std::string& font_path) : mFontPath(font_path) { - mTypeface = SkTypeface::CreateFromFile(font_path.c_str()); +MinikinFontForTest::MinikinFontForTest(const std::string& font_path) : + MinikinFontForTest(font_path, SkTypeface::CreateFromFile(font_path.c_str())) { +} + +MinikinFontForTest::MinikinFontForTest(const std::string& font_path, SkTypeface* typeface) : + MinikinFont(typeface->uniqueID()), + mTypeface(typeface), + mFontPath(font_path) { } MinikinFontForTest::~MinikinFontForTest() { @@ -55,7 +61,3 @@ const void* MinikinFontForTest::GetTable(uint32_t tag, size_t* size, *destroy = free; return buf; } - -int32_t MinikinFontForTest::GetUniqueId() const { - return mTypeface->uniqueID(); -} diff --git a/engine/src/flutter/tests/MinikinFontForTest.h b/engine/src/flutter/tests/MinikinFontForTest.h index 4686f7ab20..e527d21e34 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.h +++ b/engine/src/flutter/tests/MinikinFontForTest.h @@ -24,6 +24,7 @@ class SkTypeface; class MinikinFontForTest : public android::MinikinFont { public: explicit MinikinFontForTest(const std::string& font_path); + MinikinFontForTest(const std::string& font_path, SkTypeface* typeface); ~MinikinFontForTest(); // MinikinFont overrides. @@ -31,7 +32,6 @@ public: void GetBounds(android::MinikinRect* bounds, uint32_t glyph_id, const android::MinikinPaint& paint) const; const void* GetTable(uint32_t tag, size_t* size, android::MinikinDestroyFunc* destroy); - int32_t GetUniqueId() const; const std::string& fontPath() const { return mFontPath; } private: diff --git a/engine/src/flutter/tests/how_to_run.txt b/engine/src/flutter/tests/how_to_run.txt index a135c30e13..bee367bd17 100644 --- a/engine/src/flutter/tests/how_to_run.txt +++ b/engine/src/flutter/tests/how_to_run.txt @@ -1,5 +1,5 @@ mmm -j8 frameworks/minikin/tests && adb push $OUT/data/nativetest/minikin_tests/minikin_tests \ /data/nativetest/minikin_tests/minikin_tests && -adb push frameworks/minikin/tests/data /data/nativetest/minikin_tests/data && +adb push frameworks/minikin/tests/data /data/nativetest/minikin_tests/ && adb shell /data/nativetest/minikin_tests/minikin_tests From 0ae37ab603d853cef13857c17ee48eaa8ec76a99 Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Tue, 12 Apr 2016 15:27:17 -0700 Subject: [PATCH 178/364] Clear mLineWidths in LineBreaker::finish() There was the possibility of stale indents from previous invocations persisting in the mLineWidths across multiple invocations. This patch clears them. Bug: 28090810 Change-Id: I3621dfbe983512046289373711709aeade52eab4 --- engine/src/flutter/include/minikin/LineBreaker.h | 3 +++ engine/src/flutter/libs/minikin/LineBreaker.cpp | 1 + 2 files changed, 4 insertions(+) diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index e28f11da44..1d81404045 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -69,6 +69,9 @@ class LineWidths { } return width; } + void clear() { + mIndents.clear(); + } private: float mFirstWidth; int mFirstWidthLineCount; diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 9c4ff6f3be..2a71f044d2 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -419,6 +419,7 @@ size_t LineBreaker::computeBreaks() { void LineBreaker::finish() { mWordBreaker.finish(); mWidth = 0; + mLineWidths.clear(); mCandidates.clear(); mBreaks.clear(); mWidths.clear(); From 0f5d87990b2cc56994f1a3f1de3d0341213f62ce Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Mon, 7 Mar 2016 18:43:15 -0800 Subject: [PATCH 179/364] Returns hasVariationSelector true for VS15/VS16 Minikin has a special font fallback for VS15/VS16, so hasVariationSelector for emojis with VS15/VS16 should always return true. Bug: 27531970 Change-Id: Ieebd58f48b135b6ec50d999df68dcc09b1284606 --- .../src/flutter/include/minikin/FontFamily.h | 5 +- .../flutter/libs/minikin/FontCollection.cpp | 64 ++++++++++++++++--- .../src/flutter/libs/minikin/FontFamily.cpp | 19 +++++- .../tests/FontCollectionItemizeTest.cpp | 27 ++++---- .../src/flutter/tests/FontCollectionTest.cpp | 32 ++++++++++ engine/src/flutter/tests/FontFamilyTest.cpp | 4 +- engine/src/flutter/tests/FontTestUtils.cpp | 8 +-- engine/src/flutter/tests/FontTestUtils.h | 5 +- 8 files changed, 130 insertions(+), 34 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 149dc7b798..81033d23fd 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -100,7 +100,7 @@ struct FakedFont { class FontFamily : public MinikinRefCounted { public: - FontFamily() {} + FontFamily(); FontFamily(int variant); @@ -126,6 +126,7 @@ public: size_t getNumFonts() const; MinikinFont* getFont(size_t index) const; FontStyle getStyle(size_t index) const; + bool isColorEmojiFamily() const; // Get Unicode coverage. Lifetime of returned bitset is same as receiver. May return nullptr on // error. @@ -133,7 +134,7 @@ public: // Returns true if the font has a glyph for the code point and variation selector pair. // Caller should acquire a lock before calling the method. - bool hasVariationSelector(uint32_t codepoint, uint32_t variationSelector); + bool hasGlyph(uint32_t codepoint, uint32_t variationSelector); // Returns true if this font family has a variaion sequence table (cmap format 14 subtable). bool hasVSTable() const; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 75cbd76893..b1b0aaf95f 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -37,6 +37,42 @@ static inline T max(T a, T b) { return a>b ? a : b; } +const uint32_t EMOJI_STYLE_VS = 0xFE0F; +const uint32_t TEXT_STYLE_VS = 0xFE0E; + +// See http://www.unicode.org/Public/9.0.0/ucd/StandardizedVariants-9.0.0d1.txt +// Must be sorted. +const uint32_t EMOJI_STYLE_VS_BASES[] = { + 0x0023, 0x002A, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, + 0x00A9, 0x00AE, 0x203C, 0x2049, 0x2122, 0x2139, 0x2194, 0x2195, 0x2196, 0x2197, 0x2198, 0x2199, + 0x21A9, 0x21AA, 0x231A, 0x231B, 0x2328, 0x23CF, 0x23ED, 0x23EE, 0x23EF, 0x23F1, 0x23F2, 0x23F8, + 0x23F9, 0x23FA, 0x24C2, 0x25AA, 0x25AB, 0x25B6, 0x25C0, 0x25FB, 0x25FC, 0x25FD, 0x25FE, 0x2600, + 0x2601, 0x2602, 0x2603, 0x2604, 0x260E, 0x2611, 0x2614, 0x2615, 0x2618, 0x261D, 0x2620, 0x2622, + 0x2623, 0x2626, 0x262A, 0x262E, 0x262F, 0x2638, 0x2639, 0x263A, 0x2648, 0x2649, 0x264A, 0x264B, + 0x264C, 0x264D, 0x264E, 0x264F, 0x2650, 0x2651, 0x2652, 0x2653, 0x2660, 0x2663, 0x2665, 0x2666, + 0x2668, 0x267B, 0x267F, 0x2692, 0x2693, 0x2694, 0x2696, 0x2697, 0x2699, 0x269B, 0x269C, 0x26A0, + 0x26A1, 0x26AA, 0x26AB, 0x26B0, 0x26B1, 0x26BD, 0x26BE, 0x26C4, 0x26C5, 0x26C8, 0x26CF, 0x26D1, + 0x26D3, 0x26D4, 0x26E9, 0x26EA, 0x26F0, 0x26F1, 0x26F2, 0x26F3, 0x26F4, 0x26F5, 0x26F7, 0x26F8, + 0x26F9, 0x26FA, 0x26FD, 0x2702, 0x2708, 0x2709, 0x270C, 0x270D, 0x270F, 0x2712, 0x2714, 0x2716, + 0x271D, 0x2721, 0x2733, 0x2734, 0x2744, 0x2747, 0x2757, 0x2763, 0x2764, 0x27A1, 0x2934, 0x2935, + 0x2B05, 0x2B06, 0x2B07, 0x2B1B, 0x2B1C, 0x2B50, 0x2B55, 0x3030, 0x303D, 0x3297, 0x3299, + 0x1F004, 0x1F170, 0x1F171, 0x1F17E, 0x1F17F, 0x1F202, 0x1F21A, 0x1F22F, 0x1F237, 0x1F321, + 0x1F324, 0x1F325, 0x1F326, 0x1F327, 0x1F328, 0x1F329, 0x1F32A, 0x1F32B, 0x1F32C, 0x1F336, + 0x1F37D, 0x1F396, 0x1F397, 0x1F399, 0x1F39A, 0x1F39B, 0x1F39E, 0x1F39F, 0x1F3CB, 0x1F3CC, + 0x1F3CD, 0x1F3CE, 0x1F3D4, 0x1F3D5, 0x1F3D6, 0x1F3D7, 0x1F3D8, 0x1F3D9, 0x1F3DA, 0x1F3DB, + 0x1F3DC, 0x1F3DD, 0x1F3DE, 0x1F3DF, 0x1F3F3, 0x1F3F5, 0x1F3F7, 0x1F43F, 0x1F441, 0x1F4FD, + 0x1F549, 0x1F54A, 0x1F56F, 0x1F570, 0x1F573, 0x1F574, 0x1F575, 0x1F576, 0x1F577, 0x1F578, + 0x1F579, 0x1F587, 0x1F58A, 0x1F58B, 0x1F58C, 0x1F58D, 0x1F590, 0x1F5A5, 0x1F5A8, 0x1F5B1, + 0x1F5B2, 0x1F5BC, 0x1F5C2, 0x1F5C3, 0x1F5C4, 0x1F5D1, 0x1F5D2, 0x1F5D3, 0x1F5DC, 0x1F5DD, + 0x1F5DE, 0x1F5E1, 0x1F5E3, 0x1F5E8, 0x1F5EF, 0x1F5F3, 0x1F5FA, 0x1F6CB, 0x1F6CD, 0x1F6CE, + 0x1F6CF, 0x1F6E0, 0x1F6E1, 0x1F6E2, 0x1F6E3, 0x1F6E4, 0x1F6E5, 0x1F6E9, 0x1F6F0, 0x1F6F3, +}; + +static bool isEmojiStyleVSBase(uint32_t cp) { + const size_t length = sizeof(EMOJI_STYLE_VS_BASES) / sizeof(EMOJI_STYLE_VS_BASES[0]); + return std::binary_search(EMOJI_STYLE_VS_BASES, EMOJI_STYLE_VS_BASES + length, cp); +} + uint32_t FontCollection::sNextId = 0; FontCollection::FontCollection(const vector& typefaces) : @@ -156,7 +192,7 @@ uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, // - Returns 1 if the variation selector is not specified or if the font family only supports the // variation sequence's base character. uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* fontFamily) const { - const bool hasVSGlyph = (vs != 0) && fontFamily->hasVariationSelector(ch, vs); + const bool hasVSGlyph = (vs != 0) && fontFamily->hasGlyph(ch, vs); if (!hasVSGlyph && !fontFamily->getCoverage()->get(ch)) { // The font doesn't support either variation sequence or even the base character. return kUnsupportedFontScore; @@ -176,7 +212,7 @@ uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* return 3; } - if (vs == 0xFE0F || vs == 0xFE0E) { + if (vs == EMOJI_STYLE_VS || vs == TEXT_STYLE_VS) { const FontLanguages& langs = FontLanguageListCache::getById(fontFamily->langId()); bool hasEmojiFlag = false; for (size_t i = 0; i < langs.size(); ++i) { @@ -186,9 +222,9 @@ uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* } } - if (vs == 0xFE0F) { + if (vs == EMOJI_STYLE_VS) { return hasEmojiFlag ? 2 : 1; - } else { // vs == 0xFE0E + } else { // vs == TEXT_STYLE_VS return hasEmojiFlag ? 1 : 2; } } @@ -325,17 +361,27 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, if (baseCodepoint >= mMaxChar) { return false; } - if (variationSelector == 0) { - return false; - } + + AutoMutex _l(gMinikinLock); // Currently mRanges can not be used here since it isn't aware of the variation sequence. for (size_t i = 0; i < mVSFamilyVec.size(); i++) { - AutoMutex _l(gMinikinLock); - if (mVSFamilyVec[i]->hasVariationSelector(baseCodepoint, variationSelector)) { + if (mVSFamilyVec[i]->hasGlyph(baseCodepoint, variationSelector)) { return true; } } + + // Even if there is no cmap format 14 subtable entry for the given sequence, should return true + // for emoji + U+FE0E case since we have special fallback rule for the sequence. + if (isEmojiStyleVSBase(baseCodepoint) && variationSelector == TEXT_STYLE_VS) { + for (size_t i = 0; i < mFamilies.size(); ++i) { + if (!mFamilies[i]->isColorEmojiFamily() && variationSelector == TEXT_STYLE_VS && + mFamilies[i]->hasGlyph(baseCodepoint, 0)) { + return true; + } + } + } + return false; } diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 0f71f511ca..e2d86f0bbb 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -65,6 +65,9 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { return (weight & kWeightMask) | (italic ? kItalicMask : 0) | (variant << kVariantShift); } +FontFamily::FontFamily() : FontFamily(0 /* variant */) { +} + FontFamily::FontFamily(int variant) : FontFamily(FontLanguageListCache::kEmptyListId, variant) { } @@ -156,6 +159,16 @@ FontStyle FontFamily::getStyle(size_t index) const { return mFonts[index].style; } +bool FontFamily::isColorEmojiFamily() const { + const FontLanguages& languageList = FontLanguageListCache::getById(mLangId); + for (size_t i = 0; i < languageList.size(); ++i) { + if (languageList[i].hasEmojiFlag()) { + return true; + } + } + return false; +} + const SparseBitSet* FontFamily::getCoverage() { if (!mCoverageValid) { const FontStyle defaultStyle; @@ -179,9 +192,11 @@ const SparseBitSet* FontFamily::getCoverage() { return &mCoverage; } -bool FontFamily::hasVariationSelector(uint32_t codepoint, uint32_t variationSelector) { +bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) { assertMinikinLocked(); - if (!mHasVSTable) { + if (variationSelector != 0 && !mHasVSTable) { + // Early exit if the variation selector is specified but the font doesn't have a cmap format + // 14 subtable. return false; } diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 45587e9d89..8ad9472490 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -32,6 +32,7 @@ using android::FontLanguage; using android::FontLanguages; using android::FontLanguageListCache; using android::FontStyle; +using android::MinikinAutoUnref; using android::MinikinFont; using android::gMinikinLock; @@ -80,7 +81,7 @@ const FontLanguages& registerAndGetFontLanguages(const std::string& lang_string) } TEST_F(FontCollectionItemizeTest, itemize_latin) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; const FontStyle kRegularStyle = FontStyle(); @@ -150,7 +151,7 @@ TEST_F(FontCollectionItemizeTest, itemize_latin) { } TEST_F(FontCollectionItemizeTest, itemize_emoji) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; itemize(collection.get(), "U+1F469 U+1F467", FontStyle(), &runs); @@ -211,7 +212,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emoji) { } TEST_F(FontCollectionItemizeTest, itemize_non_latin) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; FontStyle kJAStyle = FontStyle(FontStyle::registerLanguageList("ja_JP")); @@ -300,7 +301,7 @@ TEST_F(FontCollectionItemizeTest, itemize_non_latin) { } TEST_F(FontCollectionItemizeTest, itemize_mixed) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; FontStyle kUSStyle = FontStyle(FontStyle::registerLanguageList("en_US")); @@ -339,7 +340,7 @@ TEST_F(FontCollectionItemizeTest, itemize_mixed) { } TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; // A glyph for U+4FAE is provided by both Japanese font and Simplified @@ -478,7 +479,7 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { } TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; // A glyph for U+845B is provided by both Japanese font and Simplified @@ -603,7 +604,7 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { } TEST_F(FontCollectionItemizeTest, itemize_no_crash) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; // Broken Surrogate pairs. Check only not crashing. @@ -627,7 +628,7 @@ TEST_F(FontCollectionItemizeTest, itemize_no_crash) { } TEST_F(FontCollectionItemizeTest, itemize_fakery) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; FontStyle kJABoldStyle = FontStyle(FontStyle::registerLanguageList("ja_JP"), 0, 7, false); @@ -1134,7 +1135,7 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageAndCoverage) { { "U+1F469", "zh-Hant,ja-Jpan,zh-Hans", kEmojiFont }, }; - std::unique_ptr collection = getFontCollection(kTestFontDir, kItemizeFontXml); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); for (auto testCase : testCases) { SCOPED_TRACE("Test for \"" + testCase.testString + "\" with languages " + @@ -1150,7 +1151,7 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageAndCoverage) { } TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); std::vector runs; const FontStyle kDefaultFontStyle; @@ -1232,7 +1233,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { } TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); std::vector runs; const FontStyle kDefaultFontStyle; @@ -1314,7 +1315,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { } TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_with_skinTone) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); std::vector runs; const FontStyle kDefaultFontStyle; @@ -1353,7 +1354,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_with_skinTone) { } TEST_F(FontCollectionItemizeTest, itemize_PrivateUseArea) { - std::unique_ptr collection = getFontCollection(kTestFontDir, kEmojiXmlFile); + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); std::vector runs; const FontStyle kDefaultFontStyle; diff --git a/engine/src/flutter/tests/FontCollectionTest.cpp b/engine/src/flutter/tests/FontCollectionTest.cpp index bbc53e3645..5a03f60d26 100644 --- a/engine/src/flutter/tests/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/FontCollectionTest.cpp @@ -17,6 +17,7 @@ #include #include +#include "FontTestUtils.h" #include "MinikinFontForTest.h" #include "MinikinInternal.h" @@ -75,4 +76,35 @@ TEST(FontCollectionTest, hasVariationSelectorTest) { expectVSGlyphs(fc, 0x717D, std::set({0xFE02, 0xE0102, 0xE0103})); } +const char kEmojiXmlFile[] = kTestFontDir "emoji.xml"; + +TEST(FontCollectionTest, hasVariationSelectorTest_emoji) { + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + + // Both text/color font have cmap format 14 subtable entry for VS15/VS16 respectively. + EXPECT_TRUE(collection->hasVariationSelector(0x2623, 0xFE0E)); + EXPECT_TRUE(collection->hasVariationSelector(0x2623, 0xFE0F)); + + // The text font has cmap format 14 subtable entry for VS15 but the color font doesn't have for + // VS16 + EXPECT_TRUE(collection->hasVariationSelector(0x2626, 0xFE0E)); + EXPECT_FALSE(collection->hasVariationSelector(0x2626, 0xFE0F)); + + // The color font has cmap format 14 subtable entry for VS16 but the text font doesn't have for + // VS15. + EXPECT_TRUE(collection->hasVariationSelector(0x262A, 0xFE0E)); + EXPECT_TRUE(collection->hasVariationSelector(0x262A, 0xFE0F)); + + // Neither text/color font have cmap format 14 subtable entry for VS15/VS16. + EXPECT_TRUE(collection->hasVariationSelector(0x262E, 0xFE0E)); + EXPECT_FALSE(collection->hasVariationSelector(0x262E, 0xFE0F)); + + // Text font doesn't have U+262F U+FE0E or even its base code point U+262F. + EXPECT_FALSE(collection->hasVariationSelector(0x262F, 0xFE0E)); + + // VS15/VS16 is only for emoji, should return false for not an emoji code point. + EXPECT_FALSE(collection->hasVariationSelector(0x2229, 0xFE0E)); + EXPECT_FALSE(collection->hasVariationSelector(0x2229, 0xFE0F)); +} + } // namespace android diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index 194063f5f8..1b2457695c 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -339,10 +339,10 @@ void expectVSGlyphs(FontFamily* family, uint32_t codepoint, const std::sethasVariationSelector(codepoint, i)) + EXPECT_FALSE(family->hasGlyph(codepoint, i)) << "Glyph for U+" << std::hex << codepoint << " U+" << i; } else { - EXPECT_TRUE(family->hasVariationSelector(codepoint, i)) + EXPECT_TRUE(family->hasGlyph(codepoint, i)) << "Glyph for U+" << std::hex << codepoint << " U+" << i; } diff --git a/engine/src/flutter/tests/FontTestUtils.cpp b/engine/src/flutter/tests/FontTestUtils.cpp index 98dab5121b..fdc3ed6ee9 100644 --- a/engine/src/flutter/tests/FontTestUtils.cpp +++ b/engine/src/flutter/tests/FontTestUtils.cpp @@ -24,8 +24,7 @@ #include "FontLanguage.h" #include "MinikinFontForTest.h" -std::unique_ptr getFontCollection( - const char* fontDir, const char* fontXml) { +android::FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { xmlDoc* doc = xmlReadFile(fontXml, NULL, 0); xmlNode* familySet = xmlDocGetRootElement(doc); @@ -73,9 +72,10 @@ std::unique_ptr getFontCollection( } xmlFreeDoc(doc); - std::unique_ptr r(new android::FontCollection(families)); + android::FontCollection* collection = new android::FontCollection(families); + collection->Ref(); for (size_t i = 0; i < families.size(); ++i) { families[i]->Unref(); } - return r; + return collection; } diff --git a/engine/src/flutter/tests/FontTestUtils.h b/engine/src/flutter/tests/FontTestUtils.h index 7c62c46407..5258a766ae 100644 --- a/engine/src/flutter/tests/FontTestUtils.h +++ b/engine/src/flutter/tests/FontTestUtils.h @@ -24,8 +24,9 @@ * * This function reads /system/etc/fonts.xml and make font families and * collections of them. MinikinFontForTest is used for FontFamily creation. + * + * Caller must unref the returned pointer. */ -std::unique_ptr getFontCollection( - const char* fontDir, const char* fontXml); +android::FontCollection* getFontCollection(const char* fontDir, const char* fontXml); #endif // MINIKIN_FONT_TEST_UTILS_H From 47932fa53b75744a30034467cfae6333468f54bb Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 19 Apr 2016 17:14:27 +0900 Subject: [PATCH 180/364] Do not break before and after ZWJ. The emoji list is generated from external/unicode/emoji-data.txt Bug: 28248662 Change-Id: Ie49b3782505665d62c24371ca23d317ae5e9c5f7 --- engine/src/flutter/libs/minikin/Android.mk | 16 ++- .../flutter/libs/minikin/GraphemeBreak.cpp | 17 +-- .../flutter/libs/minikin/MinikinInternal.cpp | 6 + .../flutter/libs/minikin/MinikinInternal.h | 3 + .../src/flutter/libs/minikin/WordBreaker.cpp | 15 +-- .../libs/minikin/unicode_emoji_h_gen.py | 105 ++++++++++++++++++ engine/src/flutter/tests/Android.mk | 1 + .../src/flutter/tests/GraphemeBreakTests.cpp | 4 + .../src/flutter/tests/MinikinInternalTest.cpp | 34 ++++++ engine/src/flutter/tests/WordBreakerTests.cpp | 7 +- 10 files changed, 179 insertions(+), 29 deletions(-) create mode 100644 engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py create mode 100644 engine/src/flutter/tests/MinikinInternalTest.cpp diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 2b5ff0667f..9d8257944f 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -15,7 +15,20 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) +# Generate unicode emoji data from UCD. +UNICODE_EMOJI_H_GEN_PY := $(LOCAL_PATH)/unicode_emoji_h_gen.py +UNICODE_EMOJI_DATA := $(TOP)/external/unicode/emoji-data.txt +UNICODE_EMOJI_H := $(intermediates)/generated/UnicodeData.h +$(UNICODE_EMOJI_H): $(UNICODE_EMOJI_H_GEN_PY) $(UNICODE_EMOJI_DATA) +$(LOCAL_PATH)/MinikinInternal.cpp: $(UNICODE_EMOJI_H) +$(UNICODE_EMOJI_H): PRIVATE_CUSTOM_TOOL := python $(UNICODE_EMOJI_H_GEN_PY) \ + -i $(UNICODE_EMOJI_DATA) \ + -o $(UNICODE_EMOJI_H) +$(UNICODE_EMOJI_H): + $(transform-generated-source) + +include $(CLEAR_VARS) minikin_src_files := \ AnalyzeStyle.cpp \ CmapCoverage.cpp \ @@ -40,7 +53,8 @@ minikin_src_files := \ minikin_c_includes := \ external/harfbuzz_ng/src \ external/freetype/include \ - frameworks/minikin/include + frameworks/minikin/include \ + $(intermediates) minikin_shared_libraries := \ libharfbuzz_ng \ diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index 1f361ba1a7..45dd0fff69 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -66,19 +66,6 @@ bool isPureKiller(uint32_t c) { || c == 0xA953 || c == 0xABED || c == 0x11134 || c == 0x112EA || c == 0x1172B); } -// Returns true if the character appears before or after zwj in a zwj emoji sequence. See -// http://www.unicode.org/emoji/charts/emoji-zwj-sequences.html -bool isZwjEmoji(uint32_t c) { - return (c == 0x2764 // HEAVY BLACK HEART - || c == 0x1F468 // MAN - || c == 0x1F469 // WOMAN - || c == 0x1F48B // KISS MARK - || c == 0x1F466 // BOY - || c == 0x1F467 // GIRL - || c == 0x1F441 // EYE - || c == 0x1F5E8); // LEFT SPEECH BUBBLE -} - bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t count, size_t offset) { // This implementation closely follows Unicode Standard Annex #29 on @@ -163,7 +150,7 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co return false; } // Tailoring: make emoji sequences with ZWJ a single grapheme cluster - if (c1 == 0x200D && isZwjEmoji(c2) && offset_back > start) { + if (c1 == 0x200D && isEmoji(c2) && offset_back > start) { // look at character before ZWJ to see that both can participate in an emoji zwj sequence uint32_t c0 = 0; U16_PREV(buf, start, offset_back, c0); @@ -171,7 +158,7 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co // skip over emoji variation selector U16_PREV(buf, start, offset_back, c0); } - if (isZwjEmoji(c0)) { + if (isEmoji(c0)) { return false; } } diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index e00f63951b..7fcc7b7f8b 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -18,6 +18,7 @@ #include "MinikinInternal.h" #include "HbFontCache.h" +#include "generated/UnicodeData.h" #include @@ -31,6 +32,11 @@ void assertMinikinLocked() { #endif } +bool isEmoji(uint32_t c) { + const size_t length = sizeof(generated::EMOJI_LIST) / sizeof(generated::EMOJI_LIST[0]); + return std::binary_search(generated::EMOJI_LIST, generated::EMOJI_LIST + length, c); +} + // Based on Modifiers from http://www.unicode.org/L2/L2016/16011-data-file.txt bool isEmojiModifier(uint32_t c) { return (0x1F3FB <= c && c <= 0x1F3FF); diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index 709fb9f691..88cc9475c8 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -36,6 +36,9 @@ extern Mutex gMinikinLock; // Aborts if gMinikinLock is not acquired. Do nothing on the release build. void assertMinikinLocked(); +// Returns true if c is emoji. +bool isEmoji(uint32_t c); + // Returns true if c is emoji modifier base. bool isEmojiBase(uint32_t c); diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index d420a6a0a8..34e7a932c9 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -90,18 +90,9 @@ static bool isBreakValid(const uint16_t* buf, size_t bufEnd, size_t i) { } } - // Known emoji ZWJ sequences - if (codePoint == CHAR_ZWJ) { - // Possible emoji ZWJ sequence - if (next_codepoint == 0x2764 || // HEAVY BLACK HEART - next_codepoint == 0x1F466 || // BOY - next_codepoint == 0x1F467 || // GIRL - next_codepoint == 0x1F468 || // MAN - next_codepoint == 0x1F469 || // WOMAN - next_codepoint == 0x1F48B || // KISS MARK - next_codepoint == 0x1F5E8) { // LEFT SPEECH BUBBLE - return false; - } + // Emoji ZWJ sequences. + if (codePoint == CHAR_ZWJ && isEmoji(next_codepoint)) { + return false; } // Proposed Rule LB30b from http://www.unicode.org/L2/L2016/16011r3-break-prop-emoji.pdf diff --git a/engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py b/engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py new file mode 100644 index 0000000000..7233ef621e --- /dev/null +++ b/engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python +# +# Copyright (C) 2016 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. +# +"""Generate header file for unicode data.""" + +import optparse +import sys + + +UNICODE_EMOJI_TEMPLATE=""" +/* file generated by frameworks/minikin/lib/minikin/Android.mk */ +#ifndef MINIKIN_UNICODE_EMOJI_H +#define MINIKIN_UNICODE_EMOJI_H + +#include + +namespace android { +namespace generated { + +int32_t EMOJI_LIST[] = { +@@@EMOJI_DATA@@@ +}; + +} // namespace generated +} // namespace android + +#endif // MINIKIN_UNICODE_EMOJI_H +""" + + +def _create_opt_parser(): + parser = optparse.OptionParser() + parser.add_option('-i', '--input', type='str', action='store', + help='path to input emoji-data.txt') + parser.add_option('-o', '--output', type='str', action='store', + help='path to output UnicodeEmoji.h') + return parser + + +def _read_emoji_data(emoji_data_file_path): + result = [] + with open(emoji_data_file_path) as emoji_data_file: + for line in emoji_data_file: + if '#' in line: + line = line[:line.index('#')] # Drop comments. + if not line.strip(): + continue # Skip empty line. + + code_points, prop = line.split(';') + code_points = code_points.strip() + prop = prop.strip() + if prop != 'Emoji': + break # Only collect Emoji property code points + + if '..' in code_points: # code point range + cp_start, cp_end = code_points.split('..') + result.extend(xrange(int(cp_start, 16), int(cp_end, 16) + 1)) + else: + code_point = int(code_points, 16) + result.append(code_point) + return result + + +def _generate_header_contents(emoji_list): + INDENT = ' ' * 4 + JOINER = ', ' + + hex_list = ['0x%04X' % x for x in emoji_list] + lines = [] + tmp_line = '%s%s' % (INDENT, hex_list[0]) + for hex_str in hex_list[1:]: + if len(tmp_line) + len(JOINER) + len(hex_str) >= 100: + lines.append(tmp_line + ',') + tmp_line = '%s%s' % (INDENT, hex_str) + else: + tmp_line = '%s%s%s' % (tmp_line, JOINER, hex_str) + lines.append(tmp_line) + + template = UNICODE_EMOJI_TEMPLATE + template = template.replace('@@@EMOJI_DATA@@@', '\n'.join(lines)) + return template + + +if __name__ == '__main__': + opt_parser = _create_opt_parser() + opts, _ = opt_parser.parse_args() + + emoji_list = _read_emoji_data(opts.input) + header = _generate_header_contents(emoji_list) + with open(opts.output, 'w') as header_file: + header_file.write(header) + diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index e6586d7178..b33631eb28 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -77,6 +77,7 @@ LOCAL_SRC_FILES += \ FontTestUtils.cpp \ HbFontCacheTest.cpp \ MinikinFontForTest.cpp \ + MinikinInternalTest.cpp \ GraphemeBreakTests.cpp \ LayoutUtilsTest.cpp \ UnicodeUtils.cpp \ diff --git a/engine/src/flutter/tests/GraphemeBreakTests.cpp b/engine/src/flutter/tests/GraphemeBreakTests.cpp index 3bfa5ecd8b..cec5308877 100644 --- a/engine/src/flutter/tests/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/GraphemeBreakTests.cpp @@ -148,6 +148,10 @@ TEST(GraphemeBreak, tailoring) { EXPECT_FALSE(IsBreak("U+1F469 U+200D U+1F469 U+200D U+1F467 U+200D | U+1F466")); EXPECT_FALSE(IsBreak("U+1F441 U+200D | U+1F5E8")); + // Do not break before and after zwj with all kind of emoji characters. + EXPECT_FALSE(IsBreak("U+1F431 | U+200D U+1F464")); + EXPECT_FALSE(IsBreak("U+1F431 U+200D | U+1F464")); + // ARABIC LETTER BEH + ZWJ + heart, not a zwj emoji sequence, so we preserve the break EXPECT_TRUE(IsBreak("U+0628 U+200D | U+2764")); } diff --git a/engine/src/flutter/tests/MinikinInternalTest.cpp b/engine/src/flutter/tests/MinikinInternalTest.cpp new file mode 100644 index 0000000000..9c1a1e54a4 --- /dev/null +++ b/engine/src/flutter/tests/MinikinInternalTest.cpp @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2016 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 + +#include "MinikinInternal.h" + +namespace android { + +TEST(MinikinInternalTest, isEmojiTest) { + EXPECT_TRUE(isEmoji(0x0023)); // NUMBER SIGN + EXPECT_TRUE(isEmoji(0x0035)); // DIGIT FIVE + EXPECT_TRUE(isEmoji(0x1F0CF)); // PLAYING CARD BLACK JOKER + EXPECT_TRUE(isEmoji(0x1F1E9)); // REGIONAL INDICATOR SYMBOL LETTER D + + EXPECT_FALSE(isEmoji(0x0000)); // + EXPECT_FALSE(isEmoji(0x0061)); // LATIN SMALL LETTER A + EXPECT_FALSE(isEmoji(0x29E3D)); // A han character. +} + +} // namespace android diff --git a/engine/src/flutter/tests/WordBreakerTests.cpp b/engine/src/flutter/tests/WordBreakerTests.cpp index 480c57da96..9fa9da3af7 100644 --- a/engine/src/flutter/tests/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/WordBreakerTests.cpp @@ -93,6 +93,8 @@ TEST_F(WordBreakerTest, zwjEmojiSequences) { UTF16(0x1F469), 0x200D, 0x2764, 0x200D, UTF16(0x1F48B), 0x200D, UTF16(0x1F469), // eye + zwj + left speech bubble UTF16(0x1F441), 0x200D, UTF16(0x1F5E8), + // CAT FACE + zwj + BUST IN SILHOUETTE + UTF16(0x1F431), 0x200D, UTF16(0x1F464), }; WordBreaker breaker; breaker.setLocale(icu::Locale::getEnglish()); @@ -104,9 +106,12 @@ TEST_F(WordBreakerTest, zwjEmojiSequences) { EXPECT_EQ(17, breaker.next()); // after woman + zwj + heart + zwj + woman EXPECT_EQ(7, breaker.wordStart()); EXPECT_EQ(17, breaker.wordEnd()); - EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(22, breaker.next()); // after eye + zwj + left speech bubble EXPECT_EQ(17, breaker.wordStart()); EXPECT_EQ(22, breaker.wordEnd()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end + EXPECT_EQ(22, breaker.wordStart()); + EXPECT_EQ(27, breaker.wordEnd()); } TEST_F(WordBreakerTest, emojiWithModifier) { From 1cec37d918795065ba409fe67a379b7ec12ed057 Mon Sep 17 00:00:00 2001 From: Adam Buchbinder Date: Mon, 23 May 2016 13:16:13 -0700 Subject: [PATCH 181/364] Fix a leaked file in HyphTool.cpp. This addresses the following cppcheck reports: [frameworks/minikin/app/HyphTool.cpp:30]: (error) Resource leak: f [frameworks/minikin/app/HyphTool.cpp:32]: (error) Resource leak: f Change-Id: I5113e0a7268bd3a45bf1498fd023042d9dfe2b87 --- engine/src/flutter/app/HyphTool.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/engine/src/flutter/app/HyphTool.cpp b/engine/src/flutter/app/HyphTool.cpp index 730abadcba..b535d9da8f 100644 --- a/engine/src/flutter/app/HyphTool.cpp +++ b/engine/src/flutter/app/HyphTool.cpp @@ -24,6 +24,7 @@ Hyphenator* loadHybFile(const char* fn) { } uint8_t* buf = new uint8_t[size]; size_t read_size = fread(buf, 1, size, f); + fclose(f); if (read_size < size) { fprintf(stderr, "error reading %s\n", fn); delete[] buf; From acaf5cc08defe3dfaa1e0caa945be494532cbaa0 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Wed, 25 May 2016 16:46:56 -0700 Subject: [PATCH 182/364] Do not break after Myanmar viramas This is to work around a bug in ICU's line breaker, which thinks there is a valid line break between a Myanmar kinzi and a consonant. See http://bugs.icu-project.org/trac/ticket/12561 for the ICU bug. Bug: 28964845 Change-Id: I076ac15077e5627cbccf6732900bcc60d8596dda --- engine/src/flutter/libs/minikin/WordBreaker.cpp | 10 +++++++++- engine/src/flutter/tests/WordBreakerTests.cpp | 13 +++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index 34e7a932c9..38f03caf6a 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -76,12 +76,20 @@ static bool isBreakValid(const uint16_t* buf, size_t bufEnd, size_t i) { if (codePoint == CHAR_SOFT_HYPHEN) { return false; } + // For Myanmar kinzi sequences, created by . This is to go + // around a bug in ICU line breaking: http://bugs.icu-project.org/trac/ticket/12561. To avoid + // too much looking around in the strings, we simply avoid breaking after any Myanmar virama, + // where no line break could be imagined, since the Myanmar virama is a pure stacker. + if (codePoint == 0x1039) { // MYANMAR SIGN VIRAMA + return false; + } + uint32_t next_codepoint; size_t next_offset = i; U16_NEXT(buf, next_offset, bufEnd, next_codepoint); // Proposed change to LB24 from http://www.unicode.org/L2/L2016/16043r-line-break-pr-po.txt - //(AL | HL) × (PR | PO) + // (AL | HL) × (PR | PO) int32_t lineBreak = u_getIntPropertyValue(codePoint, UCHAR_LINE_BREAK); if (lineBreak == U_LB_ALPHABETIC || lineBreak == U_LB_HEBREW_LETTER) { lineBreak = u_getIntPropertyValue(next_codepoint, UCHAR_LINE_BREAK); diff --git a/engine/src/flutter/tests/WordBreakerTests.cpp b/engine/src/flutter/tests/WordBreakerTests.cpp index 9fa9da3af7..8ed87cc506 100644 --- a/engine/src/flutter/tests/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/WordBreakerTests.cpp @@ -85,6 +85,19 @@ TEST_F(WordBreakerTest, postfixAndPrefix) { EXPECT_EQ((ssize_t)NELEM(buf), breaker.wordEnd()); } +TEST_F(WordBreakerTest, MyanmarKinzi) { + uint16_t buf[] = {0x1004, 0x103A, 0x1039, 0x1000, 0x102C}; // NGA, ASAT, VIRAMA, KA, UU + WordBreaker breaker; + icu::Locale burmese("my"); + breaker.setLocale(burmese); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end of string + EXPECT_EQ(0, breaker.wordStart()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.wordEnd()); +} + TEST_F(WordBreakerTest, zwjEmojiSequences) { uint16_t buf[] = { // man + zwj + heart + zwj + man From 96c4e3971652301b0b412f292e46d8c9a643b233 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 31 May 2016 15:25:21 +0900 Subject: [PATCH 183/364] Introduce initial minikin perftest Bug: 28992567 Change-Id: Id14cc86761d6c5b408262fe8684e2b293a420a4f --- engine/src/flutter/tests/perftests/Android.mk | 31 +++++++++++++++++ .../flutter/tests/perftests/FontLanguage.cpp | 34 +++++++++++++++++++ .../flutter/tests/perftests/how_to_run.txt | 4 +++ engine/src/flutter/tests/perftests/main.cpp | 18 ++++++++++ 4 files changed, 87 insertions(+) create mode 100644 engine/src/flutter/tests/perftests/Android.mk create mode 100644 engine/src/flutter/tests/perftests/FontLanguage.cpp create mode 100644 engine/src/flutter/tests/perftests/how_to_run.txt create mode 100644 engine/src/flutter/tests/perftests/main.cpp diff --git a/engine/src/flutter/tests/perftests/Android.mk b/engine/src/flutter/tests/perftests/Android.mk new file mode 100644 index 0000000000..3b49036cee --- /dev/null +++ b/engine/src/flutter/tests/perftests/Android.mk @@ -0,0 +1,31 @@ +# +# Copyright (C) 2016 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. +# + +LOCAL_PATH := $(call my-dir) + +perftest_src_files := \ + FontLanguage.cpp \ + main.cpp + +include $(CLEAR_VARS) +LOCAL_MODULE := minikin_perftests +LOCAL_CPPFLAGS := -Werror -Wall -Wextra +LOCAL_SRC_FILES := $(perftest_src_files) +LOCAL_STATIC_LIBRARIES := libminikin +LOCAL_C_INCLUDES := \ + $(LOCAL_PATH)/../../libs/minikin \ + external/harfbuzz_ng/src +include $(BUILD_NATIVE_BENCHMARK) diff --git a/engine/src/flutter/tests/perftests/FontLanguage.cpp b/engine/src/flutter/tests/perftests/FontLanguage.cpp new file mode 100644 index 0000000000..ac7af6f909 --- /dev/null +++ b/engine/src/flutter/tests/perftests/FontLanguage.cpp @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2016 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 + +#include "FontLanguage.h" + +using android::FontLanguage; + +static void BM_FontLanguage_en_US(benchmark::State& state) { + while (state.KeepRunning()) { + FontLanguage language("en-US", 5); + } +} +BENCHMARK(BM_FontLanguage_en_US); + +static void BM_FontLanguage_en_Latn_US(benchmark::State& state) { + while (state.KeepRunning()) { + FontLanguage language("en-Latn-US", 10); + } +} +BENCHMARK(BM_FontLanguage_en_Latn_US); diff --git a/engine/src/flutter/tests/perftests/how_to_run.txt b/engine/src/flutter/tests/perftests/how_to_run.txt new file mode 100644 index 0000000000..3390522c2f --- /dev/null +++ b/engine/src/flutter/tests/perftests/how_to_run.txt @@ -0,0 +1,4 @@ +mmm -j8 frameworks/minikin/tests/perftests && +adb push $OUT/data/benchmarktest/minikin_perftests/minikin_perftests \ + /data/benchmarktest/minikin_perftests/minikin_perftests && +adb shell /data/benchmarktest/minikin_perftests/minikin_perftests diff --git a/engine/src/flutter/tests/perftests/main.cpp b/engine/src/flutter/tests/perftests/main.cpp new file mode 100644 index 0000000000..e39c7f8838 --- /dev/null +++ b/engine/src/flutter/tests/perftests/main.cpp @@ -0,0 +1,18 @@ +/* + * Copyright (C) 2016 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 + +BENCHMARK_MAIN(); From 2eef839c8e61512d0a031100db9da477fe2a54c6 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Fri, 3 Jun 2016 16:10:02 +0900 Subject: [PATCH 184/364] Reconstruct the directory structure of minikin tests. To add perftests and reuse some utility classes, reconstruct test directory structure. - Move unit tests from minikin/tests to minikin/tests/unittests - Extract utilitiy classes to minikin/tests/utils which will be used by perftests eventually. Change-Id: I5026b177934e72ae67d362ee888302037da2f808 --- engine/src/flutter/tests/{ => unittest}/Android.mk | 13 +++++++------ .../{ => unittest}/FontCollectionItemizeTest.cpp | 0 .../tests/{ => unittest}/FontCollectionTest.cpp | 0 .../flutter/tests/{ => unittest}/FontFamilyTest.cpp | 0 .../{ => unittest}/FontLanguageListCacheTest.cpp | 0 .../tests/{ => unittest}/GraphemeBreakTests.cpp | 0 .../tests/{ => unittest}/HbFontCacheTest.cpp | 0 .../src/flutter/tests/{ => unittest}/ICUTestBase.h | 0 .../tests/{ => unittest}/LayoutUtilsTest.cpp | 0 .../tests/{ => unittest}/MinikinInternalTest.cpp | 0 .../tests/{ => unittest}/WordBreakerTests.cpp | 0 .../src/flutter/tests/{ => unittest}/how_to_run.txt | 2 +- .../src/flutter/tests/{ => util}/FontTestUtils.cpp | 0 engine/src/flutter/tests/{ => util}/FontTestUtils.h | 0 .../flutter/tests/{ => util}/MinikinFontForTest.cpp | 0 .../flutter/tests/{ => util}/MinikinFontForTest.h | 0 .../src/flutter/tests/{ => util}/UnicodeUtils.cpp | 0 engine/src/flutter/tests/{ => util}/UnicodeUtils.h | 0 18 files changed, 8 insertions(+), 7 deletions(-) rename engine/src/flutter/tests/{ => unittest}/Android.mk (92%) rename engine/src/flutter/tests/{ => unittest}/FontCollectionItemizeTest.cpp (100%) rename engine/src/flutter/tests/{ => unittest}/FontCollectionTest.cpp (100%) rename engine/src/flutter/tests/{ => unittest}/FontFamilyTest.cpp (100%) rename engine/src/flutter/tests/{ => unittest}/FontLanguageListCacheTest.cpp (100%) rename engine/src/flutter/tests/{ => unittest}/GraphemeBreakTests.cpp (100%) rename engine/src/flutter/tests/{ => unittest}/HbFontCacheTest.cpp (100%) rename engine/src/flutter/tests/{ => unittest}/ICUTestBase.h (100%) rename engine/src/flutter/tests/{ => unittest}/LayoutUtilsTest.cpp (100%) rename engine/src/flutter/tests/{ => unittest}/MinikinInternalTest.cpp (100%) rename engine/src/flutter/tests/{ => unittest}/WordBreakerTests.cpp (100%) rename engine/src/flutter/tests/{ => unittest}/how_to_run.txt (83%) rename engine/src/flutter/tests/{ => util}/FontTestUtils.cpp (100%) rename engine/src/flutter/tests/{ => util}/FontTestUtils.h (100%) rename engine/src/flutter/tests/{ => util}/MinikinFontForTest.cpp (100%) rename engine/src/flutter/tests/{ => util}/MinikinFontForTest.h (100%) rename engine/src/flutter/tests/{ => util}/UnicodeUtils.cpp (100%) rename engine/src/flutter/tests/{ => util}/UnicodeUtils.h (100%) diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/unittest/Android.mk similarity index 92% rename from engine/src/flutter/tests/Android.mk rename to engine/src/flutter/tests/unittest/Android.mk index b33631eb28..885127199d 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -45,9 +45,9 @@ LOCAL_MODULE := minikin_tests LOCAL_MODULE_TAGS := tests GEN := $(addprefix $(minikin_tests_root_for_test_zip)/, $(font_src_files)) -$(GEN): PRIVATE_PATH := $(LOCAL_PATH) +$(GEN): PRIVATE_PATH := $(LOCAL_PATH)/../ $(GEN): PRIVATE_CUSTOM_TOOL = cp $< $@ -$(GEN): $(minikin_tests_root_for_test_zip)/data/% : $(LOCAL_PATH)/data/% +$(GEN): $(minikin_tests_root_for_test_zip)/data/% : $(LOCAL_PATH)/../data/% $(transform-generated-source) LOCAL_GENERATED_SOURCES += $(GEN) @@ -70,21 +70,22 @@ LOCAL_STATIC_LIBRARIES += \ libxml2 LOCAL_SRC_FILES += \ + ../util/FontTestUtils.cpp \ + ../util/MinikinFontForTest.cpp \ + ../util/UnicodeUtils.cpp \ FontCollectionTest.cpp \ FontCollectionItemizeTest.cpp \ FontFamilyTest.cpp \ FontLanguageListCacheTest.cpp \ - FontTestUtils.cpp \ HbFontCacheTest.cpp \ - MinikinFontForTest.cpp \ MinikinInternalTest.cpp \ GraphemeBreakTests.cpp \ LayoutUtilsTest.cpp \ - UnicodeUtils.cpp \ WordBreakerTests.cpp LOCAL_C_INCLUDES := \ - $(LOCAL_PATH)/../libs/minikin/ \ + $(LOCAL_PATH)/../../libs/minikin/ \ + $(LOCAL_PATH)/../util \ external/harfbuzz_ng/src \ external/libxml2/include \ external/skia/src/core diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp similarity index 100% rename from engine/src/flutter/tests/FontCollectionItemizeTest.cpp rename to engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp diff --git a/engine/src/flutter/tests/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp similarity index 100% rename from engine/src/flutter/tests/FontCollectionTest.cpp rename to engine/src/flutter/tests/unittest/FontCollectionTest.cpp diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp similarity index 100% rename from engine/src/flutter/tests/FontFamilyTest.cpp rename to engine/src/flutter/tests/unittest/FontFamilyTest.cpp diff --git a/engine/src/flutter/tests/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp similarity index 100% rename from engine/src/flutter/tests/FontLanguageListCacheTest.cpp rename to engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp diff --git a/engine/src/flutter/tests/GraphemeBreakTests.cpp b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp similarity index 100% rename from engine/src/flutter/tests/GraphemeBreakTests.cpp rename to engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp diff --git a/engine/src/flutter/tests/HbFontCacheTest.cpp b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp similarity index 100% rename from engine/src/flutter/tests/HbFontCacheTest.cpp rename to engine/src/flutter/tests/unittest/HbFontCacheTest.cpp diff --git a/engine/src/flutter/tests/ICUTestBase.h b/engine/src/flutter/tests/unittest/ICUTestBase.h similarity index 100% rename from engine/src/flutter/tests/ICUTestBase.h rename to engine/src/flutter/tests/unittest/ICUTestBase.h diff --git a/engine/src/flutter/tests/LayoutUtilsTest.cpp b/engine/src/flutter/tests/unittest/LayoutUtilsTest.cpp similarity index 100% rename from engine/src/flutter/tests/LayoutUtilsTest.cpp rename to engine/src/flutter/tests/unittest/LayoutUtilsTest.cpp diff --git a/engine/src/flutter/tests/MinikinInternalTest.cpp b/engine/src/flutter/tests/unittest/MinikinInternalTest.cpp similarity index 100% rename from engine/src/flutter/tests/MinikinInternalTest.cpp rename to engine/src/flutter/tests/unittest/MinikinInternalTest.cpp diff --git a/engine/src/flutter/tests/WordBreakerTests.cpp b/engine/src/flutter/tests/unittest/WordBreakerTests.cpp similarity index 100% rename from engine/src/flutter/tests/WordBreakerTests.cpp rename to engine/src/flutter/tests/unittest/WordBreakerTests.cpp diff --git a/engine/src/flutter/tests/how_to_run.txt b/engine/src/flutter/tests/unittest/how_to_run.txt similarity index 83% rename from engine/src/flutter/tests/how_to_run.txt rename to engine/src/flutter/tests/unittest/how_to_run.txt index bee367bd17..c90c6640bd 100644 --- a/engine/src/flutter/tests/how_to_run.txt +++ b/engine/src/flutter/tests/unittest/how_to_run.txt @@ -1,4 +1,4 @@ -mmm -j8 frameworks/minikin/tests && +mmm -j8 frameworks/minikin/tests/unittests && adb push $OUT/data/nativetest/minikin_tests/minikin_tests \ /data/nativetest/minikin_tests/minikin_tests && adb push frameworks/minikin/tests/data /data/nativetest/minikin_tests/ && diff --git a/engine/src/flutter/tests/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp similarity index 100% rename from engine/src/flutter/tests/FontTestUtils.cpp rename to engine/src/flutter/tests/util/FontTestUtils.cpp diff --git a/engine/src/flutter/tests/FontTestUtils.h b/engine/src/flutter/tests/util/FontTestUtils.h similarity index 100% rename from engine/src/flutter/tests/FontTestUtils.h rename to engine/src/flutter/tests/util/FontTestUtils.h diff --git a/engine/src/flutter/tests/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp similarity index 100% rename from engine/src/flutter/tests/MinikinFontForTest.cpp rename to engine/src/flutter/tests/util/MinikinFontForTest.cpp diff --git a/engine/src/flutter/tests/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h similarity index 100% rename from engine/src/flutter/tests/MinikinFontForTest.h rename to engine/src/flutter/tests/util/MinikinFontForTest.h diff --git a/engine/src/flutter/tests/UnicodeUtils.cpp b/engine/src/flutter/tests/util/UnicodeUtils.cpp similarity index 100% rename from engine/src/flutter/tests/UnicodeUtils.cpp rename to engine/src/flutter/tests/util/UnicodeUtils.cpp diff --git a/engine/src/flutter/tests/UnicodeUtils.h b/engine/src/flutter/tests/util/UnicodeUtils.h similarity index 100% rename from engine/src/flutter/tests/UnicodeUtils.h rename to engine/src/flutter/tests/util/UnicodeUtils.h From 2fdcf62495d27f95b130013ae0b45f9c0dc03593 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 9 Jun 2016 19:40:58 +0900 Subject: [PATCH 185/364] Always use minikin namespace. Here is a new policy of the namespace of minikin. - All components should be in minikin namespace. - All tests are also in minikin namespace and no anonymous namespace. Bug: 29233740 Change-Id: I71a8a35049bb8d624f7a78797231e90fed1e2b8c --- engine/src/flutter/app/HyphTool.cpp | 2 +- .../flutter/include/minikin/AnalyzeStyle.h | 6 +- .../flutter/include/minikin/CmapCoverage.h | 4 +- .../flutter/include/minikin/FontCollection.h | 4 +- .../src/flutter/include/minikin/FontFamily.h | 8 +-- .../flutter/include/minikin/GraphemeBreak.h | 6 +- .../src/flutter/include/minikin/Hyphenator.h | 4 +- engine/src/flutter/include/minikin/Layout.h | 8 +-- .../src/flutter/include/minikin/LineBreaker.h | 4 +- .../src/flutter/include/minikin/Measurement.h | 4 +- .../src/flutter/include/minikin/MinikinFont.h | 4 +- .../include/minikin/MinikinFontFreeType.h | 4 +- .../include/minikin/MinikinRefCounted.h | 6 +- .../flutter/include/minikin/SparseBitSet.h | 4 +- .../src/flutter/include/minikin/WordBreaker.h | 4 +- .../src/flutter/libs/minikin/AnalyzeStyle.cpp | 4 +- .../src/flutter/libs/minikin/CmapCoverage.cpp | 4 +- .../flutter/libs/minikin/FontCollection.cpp | 8 +-- .../src/flutter/libs/minikin/FontFamily.cpp | 18 +++--- .../src/flutter/libs/minikin/FontLanguage.cpp | 4 +- .../src/flutter/libs/minikin/FontLanguage.h | 4 +- .../libs/minikin/FontLanguageListCache.cpp | 4 +- .../libs/minikin/FontLanguageListCache.h | 4 +- .../flutter/libs/minikin/GraphemeBreak.cpp | 4 +- .../src/flutter/libs/minikin/HbFontCache.cpp | 8 +-- engine/src/flutter/libs/minikin/HbFontCache.h | 4 +- .../src/flutter/libs/minikin/Hyphenator.cpp | 4 +- engine/src/flutter/libs/minikin/Layout.cpp | 63 ++++++++++--------- .../src/flutter/libs/minikin/LayoutUtils.cpp | 4 ++ engine/src/flutter/libs/minikin/LayoutUtils.h | 3 + .../src/flutter/libs/minikin/LineBreaker.cpp | 4 +- .../src/flutter/libs/minikin/Measurement.cpp | 4 +- .../src/flutter/libs/minikin/MinikinFont.cpp | 4 +- .../libs/minikin/MinikinFontFreeType.cpp | 4 +- .../flutter/libs/minikin/MinikinInternal.cpp | 6 +- .../flutter/libs/minikin/MinikinInternal.h | 6 +- .../libs/minikin/MinikinRefCounted.cpp | 8 +-- .../src/flutter/libs/minikin/SparseBitSet.cpp | 4 +- .../src/flutter/libs/minikin/WordBreaker.cpp | 4 +- .../libs/minikin/unicode_emoji_h_gen.py | 4 +- engine/src/flutter/sample/MinikinSkia.cpp | 4 +- engine/src/flutter/sample/MinikinSkia.h | 19 +++++- engine/src/flutter/sample/example.cpp | 1 - engine/src/flutter/sample/example_skia.cpp | 6 +- .../flutter/tests/perftests/FontLanguage.cpp | 4 +- .../unittest/FontCollectionItemizeTest.cpp | 23 +++---- .../tests/unittest/FontCollectionTest.cpp | 4 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 12 ++-- .../unittest/FontLanguageListCacheTest.cpp | 8 +-- .../tests/unittest/GraphemeBreakTests.cpp | 4 +- .../tests/unittest/HbFontCacheTest.cpp | 12 ++-- .../src/flutter/tests/unittest/ICUTestBase.h | 4 +- .../tests/unittest/LayoutUtilsTest.cpp | 4 +- .../tests/unittest/MinikinInternalTest.cpp | 4 +- .../tests/unittest/WordBreakerTests.cpp | 4 +- .../src/flutter/tests/util/FontTestUtils.cpp | 22 ++++--- engine/src/flutter/tests/util/FontTestUtils.h | 5 +- .../flutter/tests/util/MinikinFontForTest.cpp | 12 ++-- .../flutter/tests/util/MinikinFontForTest.h | 14 +++-- .../src/flutter/tests/util/UnicodeUtils.cpp | 4 ++ engine/src/flutter/tests/util/UnicodeUtils.h | 6 +- 61 files changed, 238 insertions(+), 198 deletions(-) diff --git a/engine/src/flutter/app/HyphTool.cpp b/engine/src/flutter/app/HyphTool.cpp index 730abadcba..e421cf9671 100644 --- a/engine/src/flutter/app/HyphTool.cpp +++ b/engine/src/flutter/app/HyphTool.cpp @@ -7,7 +7,7 @@ #include #include -using android::Hyphenator; +using minikin::Hyphenator; Hyphenator* loadHybFile(const char* fn) { struct stat statbuf; diff --git a/engine/src/flutter/include/minikin/AnalyzeStyle.h b/engine/src/flutter/include/minikin/AnalyzeStyle.h index 298947742a..b4cd915108 100644 --- a/engine/src/flutter/include/minikin/AnalyzeStyle.h +++ b/engine/src/flutter/include/minikin/AnalyzeStyle.h @@ -17,10 +17,10 @@ #ifndef MINIKIN_ANALYZE_STYLE_H #define MINIKIN_ANALYZE_STYLE_H -namespace android { +namespace minikin { bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic); -} // namespace android +} // namespace minikin -#endif // MINIKIN_ANALYZE_STYLE_H \ No newline at end of file +#endif // MINIKIN_ANALYZE_STYLE_H diff --git a/engine/src/flutter/include/minikin/CmapCoverage.h b/engine/src/flutter/include/minikin/CmapCoverage.h index 56abac7bec..19b43f38de 100644 --- a/engine/src/flutter/include/minikin/CmapCoverage.h +++ b/engine/src/flutter/include/minikin/CmapCoverage.h @@ -19,7 +19,7 @@ #include -namespace android { +namespace minikin { class CmapCoverage { public: @@ -27,6 +27,6 @@ public: bool* has_cmap_format14_subtable); }; -} // namespace android +} // namespace minikin #endif // MINIKIN_CMAP_COVERAGE_H diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index c3c183db3b..c9c8520be6 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -23,7 +23,7 @@ #include #include -namespace android { +namespace minikin { class FontCollection : public MinikinRefCounted { public: @@ -98,6 +98,6 @@ private: std::vector mRanges; }; -} // namespace android +} // namespace minikin #endif // MINIKIN_FONT_COLLECTION_H diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 81033d23fd..f4b1f468d7 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -26,7 +26,7 @@ #include #include -namespace android { +namespace minikin { class MinikinFont; @@ -52,7 +52,7 @@ public: return bits == other.bits && mLanguageListId == other.mLanguageListId; } - hash_t hash() const; + android::hash_t hash() const; // Looks up a language list from an internal cache and returns its ID. // If the passed language list is not in the cache, registers it and returns newly assigned ID. @@ -75,7 +75,7 @@ enum FontVariant { VARIANT_ELEGANT = 2, }; -inline hash_t hash_type(const FontStyle &style) { +inline android::hash_t hash_type(const FontStyle &style) { return style.hash(); } @@ -158,6 +158,6 @@ private: bool mCoverageValid; }; -} // namespace android +} // namespace minikin #endif // MINIKIN_FONT_FAMILY_H diff --git a/engine/src/flutter/include/minikin/GraphemeBreak.h b/engine/src/flutter/include/minikin/GraphemeBreak.h index 3120101585..b501f6784f 100644 --- a/engine/src/flutter/include/minikin/GraphemeBreak.h +++ b/engine/src/flutter/include/minikin/GraphemeBreak.h @@ -17,7 +17,7 @@ #ifndef MINIKIN_GRAPHEME_BREAK_H #define MINIKIN_GRAPHEME_BREAK_H -namespace android { +namespace minikin { class GraphemeBreak { public: @@ -42,6 +42,6 @@ public: size_t offset, MoveOpt opt); }; -} // namespace android +} // namespace minikin -#endif // MINIKIN_GRAPHEME_BREAK_H \ No newline at end of file +#endif // MINIKIN_GRAPHEME_BREAK_H diff --git a/engine/src/flutter/include/minikin/Hyphenator.h b/engine/src/flutter/include/minikin/Hyphenator.h index 9605205a29..f922dcbfb7 100644 --- a/engine/src/flutter/include/minikin/Hyphenator.h +++ b/engine/src/flutter/include/minikin/Hyphenator.h @@ -24,7 +24,7 @@ #ifndef MINIKIN_HYPHENATOR_H #define MINIKIN_HYPHENATOR_H -namespace android { +namespace minikin { // hyb file header; implementation details are in the .cpp file struct Header; @@ -78,6 +78,6 @@ private: }; -} // namespace android +} // namespace minikin #endif // MINIKIN_HYPHENATOR_H diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index d9bb01f1a7..87d5e0534b 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -34,17 +34,13 @@ public: Bitmap(int width, int height); ~Bitmap(); void writePnm(std::ofstream& o) const; - void drawGlyph(const android::GlyphBitmap& bitmap, int x, int y); + void drawGlyph(const GlyphBitmap& bitmap, int x, int y); private: int width; int height; uint8_t* buf; }; -} // namespace minikin - -namespace android { - struct LayoutGlyph { // index into mFaces and mHbFonts vectors. We could imagine // moving this into a run length representation, because it's @@ -160,6 +156,6 @@ private: MinikinRect mBounds; }; -} // namespace android +} // namespace minikin #endif // MINIKIN_LAYOUT_H diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index 1d81404045..feaffe74e3 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -29,7 +29,7 @@ #include "minikin/Hyphenator.h" #include "minikin/WordBreaker.h" -namespace android { +namespace minikin { enum BreakStrategy { kBreakStrategy_Greedy = 0, @@ -243,6 +243,6 @@ class LineBreaker { int mFirstTabIndex; }; -} // namespace android +} // namespace minikin #endif // MINIKIN_LINE_BREAKER_H diff --git a/engine/src/flutter/include/minikin/Measurement.h b/engine/src/flutter/include/minikin/Measurement.h index 7bcab669de..b00c2120a7 100644 --- a/engine/src/flutter/include/minikin/Measurement.h +++ b/engine/src/flutter/include/minikin/Measurement.h @@ -19,7 +19,7 @@ #include -namespace android { +namespace minikin { float getRunAdvance(const float* advances, const uint16_t* buf, size_t start, size_t count, size_t offset); @@ -27,6 +27,6 @@ float getRunAdvance(const float* advances, const uint16_t* buf, size_t start, si size_t getOffsetForAdvance(const float* advances, const uint16_t* buf, size_t start, size_t count, float advance); -} +} // namespace minikin #endif // MINIKIN_MEASUREMENT_H diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 4951514518..9d4f937089 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -25,7 +25,7 @@ // An abstraction for platform fonts, allowing Minikin to be used with // multiple actual implementations of fonts. -namespace android { +namespace minikin { // The hyphen edit represents an edit to the string when a word is // hyphenated. The most common hyphen edit is adding a "-" at the end @@ -137,6 +137,6 @@ private: const int32_t mUniqueId; }; -} // namespace android +} // namespace minikin #endif // MINIKIN_FONT_H diff --git a/engine/src/flutter/include/minikin/MinikinFontFreeType.h b/engine/src/flutter/include/minikin/MinikinFontFreeType.h index baa08df3b7..34c3fd92d4 100644 --- a/engine/src/flutter/include/minikin/MinikinFontFreeType.h +++ b/engine/src/flutter/include/minikin/MinikinFontFreeType.h @@ -26,7 +26,7 @@ // An abstraction for platform fonts, allowing Minikin to be used with // multiple actual implementations of fonts. -namespace android { +namespace minikin { struct GlyphBitmap { uint8_t *buffer; @@ -65,6 +65,6 @@ private: static int32_t sIdCounter; }; -} // namespace android +} // namespace minikin #endif // MINIKIN_FONT_FREETYPE_H diff --git a/engine/src/flutter/include/minikin/MinikinRefCounted.h b/engine/src/flutter/include/minikin/MinikinRefCounted.h index 603aff0cce..0ee44747c1 100644 --- a/engine/src/flutter/include/minikin/MinikinRefCounted.h +++ b/engine/src/flutter/include/minikin/MinikinRefCounted.h @@ -19,7 +19,7 @@ #ifndef MINIKIN_REF_COUNTED_H #define MINIKIN_REF_COUNTED_H -namespace android { +namespace minikin { class MinikinRefCounted { public: @@ -54,6 +54,6 @@ private: T* mObj; }; -} +} // namespace minikin -#endif // MINIKIN_REF_COUNTED_H \ No newline at end of file +#endif // MINIKIN_REF_COUNTED_H diff --git a/engine/src/flutter/include/minikin/SparseBitSet.h b/engine/src/flutter/include/minikin/SparseBitSet.h index 72b83057c6..00babbbf2f 100644 --- a/engine/src/flutter/include/minikin/SparseBitSet.h +++ b/engine/src/flutter/include/minikin/SparseBitSet.h @@ -23,7 +23,7 @@ // --------------------------------------------------------------------------- -namespace android { +namespace minikin { // This is an implementation of a set of integers. It is optimized for // values that are somewhat sparse, in the ballpark of a maximum value @@ -87,6 +87,6 @@ private: // Note: this thing cannot be used in vectors yet. If that were important, we'd need to // make the copy constructor work, and probably set up move traits as well. -}; // namespace android +} // namespace minikin #endif // MINIKIN_SPARSE_BIT_SET_H diff --git a/engine/src/flutter/include/minikin/WordBreaker.h b/engine/src/flutter/include/minikin/WordBreaker.h index 4eff9d1755..0f95bb208a 100644 --- a/engine/src/flutter/include/minikin/WordBreaker.h +++ b/engine/src/flutter/include/minikin/WordBreaker.h @@ -26,7 +26,7 @@ #include "unicode/brkiter.h" #include -namespace android { +namespace minikin { class WordBreaker { public: @@ -68,6 +68,6 @@ private: bool mInEmailOrUrl; }; -} // namespace +} // namespace minikin #endif // MINIKIN_WORD_BREAKER_H diff --git a/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp b/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp index 0961645290..333f008f7f 100644 --- a/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp +++ b/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp @@ -19,7 +19,7 @@ #include -namespace android { +namespace minikin { // should we have a single FontAnalyzer class this stuff lives in, to avoid dup? static int32_t readU16(const uint8_t* data, size_t offset) { @@ -40,4 +40,4 @@ bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* i return true; } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index 2961d2ffa8..3dc2cd3074 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -25,7 +25,7 @@ using std::vector; #include #include -namespace android { +namespace minikin { // These could perhaps be optimized to use __builtin_bswap16 and friends. static uint32_t readU16(const uint8_t* data, size_t offset) { @@ -203,4 +203,4 @@ bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, return success; } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index b1b0aaf95f..90b67d2550 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -30,7 +30,7 @@ using std::vector; -namespace android { +namespace minikin { template static inline T max(T a, T b) { @@ -77,7 +77,7 @@ uint32_t FontCollection::sNextId = 0; FontCollection::FontCollection(const vector& typefaces) : mMaxChar(0) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); mId = sNextId++; vector lastChar; size_t nTypefaces = typefaces.size(); @@ -362,7 +362,7 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, return false; } - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); // Currently mRanges can not be used here since it isn't aware of the variation sequence. for (size_t i = 0; i < mVSFamilyVec.size(); i++) { @@ -471,4 +471,4 @@ uint32_t FontCollection::getId() const { return mId; } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index e2d86f0bbb..99edb87473 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -38,7 +38,7 @@ using std::vector; -namespace android { +namespace minikin { FontStyle::FontStyle(int variant, int weight, bool italic) : FontStyle(FontLanguageListCache::kEmptyListId, variant, weight, italic) { @@ -48,15 +48,15 @@ FontStyle::FontStyle(uint32_t languageListId, int variant, int weight, bool ital : bits(pack(variant, weight, italic)), mLanguageListId(languageListId) { } -hash_t FontStyle::hash() const { - uint32_t hash = JenkinsHashMix(0, bits); - hash = JenkinsHashMix(hash, mLanguageListId); - return JenkinsHashWhiten(hash); +android::hash_t FontStyle::hash() const { + uint32_t hash = android::JenkinsHashMix(0, bits); + hash = android::JenkinsHashMix(hash, mLanguageListId); + return android::JenkinsHashWhiten(hash); } // static uint32_t FontStyle::registerLanguageList(const std::string& languages) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); return FontLanguageListCache::getId(languages); } @@ -78,7 +78,7 @@ FontFamily::~FontFamily() { } bool FontFamily::addFont(MinikinFont* typeface) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); HbBlob os2Table(getFontTable(typeface, os2Tag)); if (os2Table.get() == nullptr) return false; @@ -96,7 +96,7 @@ bool FontFamily::addFont(MinikinFont* typeface) { } void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); addFontLocked(typeface, style); } @@ -214,4 +214,4 @@ bool FontFamily::hasVSTable() const { return mHasVSTable; } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontLanguage.cpp b/engine/src/flutter/libs/minikin/FontLanguage.cpp index bccb4bf9e8..9cfa0aa664 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguage.cpp @@ -21,7 +21,7 @@ #include #include -namespace android { +namespace minikin { #define SCRIPT_TAG(c1, c2, c3, c4) \ (((uint32_t)(c1)) << 24 | ((uint32_t)(c2)) << 16 | ((uint32_t)(c3)) << 8 | \ @@ -183,4 +183,4 @@ FontLanguages::FontLanguages(std::vector&& languages) } #undef SCRIPT_TAG -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontLanguage.h b/engine/src/flutter/libs/minikin/FontLanguage.h index f944174a86..f28a4a8e72 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.h +++ b/engine/src/flutter/libs/minikin/FontLanguage.h @@ -22,7 +22,7 @@ #include -namespace android { +namespace minikin { // Due to the limits in font fallback score calculation, we can't use anything more than 17 // languages. @@ -121,6 +121,6 @@ private: void operator=(const FontLanguages&) = delete; }; -} // namespace android +} // namespace minikin #endif // MINIKIN_FONT_LANGUAGE_H diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp index 6b661f0384..bf46d4f6ea 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp @@ -25,7 +25,7 @@ #include "MinikinInternal.h" #include "FontLanguage.h" -namespace android { +namespace minikin { const uint32_t FontLanguageListCache::kEmptyListId; @@ -152,4 +152,4 @@ FontLanguageListCache* FontLanguageListCache::getInstance() { return instance; } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.h b/engine/src/flutter/libs/minikin/FontLanguageListCache.h index c961882f0a..9bf156f9de 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.h +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.h @@ -22,7 +22,7 @@ #include #include "FontLanguage.h" -namespace android { +namespace minikin { class FontLanguageListCache { public: @@ -51,6 +51,6 @@ private: std::unordered_map mLanguageListLookupTable; }; -} // namespace android +} // namespace minikin #endif // MINIKIN_FONT_LANGUAGE_LIST_CACHE_H diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index 45dd0fff69..dc5a761937 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -22,7 +22,7 @@ #include #include "MinikinInternal.h" -namespace android { +namespace minikin { int32_t tailoredGraphemeClusterBreak(uint32_t c) { // Characters defined as Control that we want to treat them as Extend. @@ -209,4 +209,4 @@ size_t GraphemeBreak::getTextRunCursor(const uint16_t* buf, size_t start, size_t return offset; } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index 3be942d7b9..45c3f5807b 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -26,7 +26,7 @@ #include #include "MinikinInternal.h" -namespace android { +namespace minikin { static hb_blob_t* referenceTable(hb_face_t* /* face */, hb_tag_t tag, void* userData) { MinikinFont* font = reinterpret_cast(userData); @@ -44,7 +44,7 @@ static hb_blob_t* referenceTable(hb_face_t* /* face */, hb_tag_t tag, void* user HB_MEMORY_MODE_READONLY, const_cast(buffer), destroy); } -class HbFontCache : private OnEntryRemoved { +class HbFontCache : private android::OnEntryRemoved { public: HbFontCache() : mCache(kMaxEntries) { mCache.setOnEntryRemovedListener(this); @@ -74,7 +74,7 @@ public: private: static const size_t kMaxEntries = 100; - LruCache mCache; + android::LruCache mCache; }; HbFontCache* getFontCacheLocked() { @@ -141,4 +141,4 @@ hb_font_t* getHbFontLocked(MinikinFont* minikinFont) { return hb_font_reference(font); } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/HbFontCache.h b/engine/src/flutter/libs/minikin/HbFontCache.h index 449b354c2d..fba685aeb2 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.h +++ b/engine/src/flutter/libs/minikin/HbFontCache.h @@ -19,12 +19,12 @@ struct hb_font_t; -namespace android { +namespace minikin { class MinikinFont; void purgeHbFontCacheLocked(); void purgeHbFontLocked(const MinikinFont* minikinFont); hb_font_t* getHbFontLocked(MinikinFont* minikinFont); -} // namespace android +} // namespace minikin #endif // MINIKIN_HBFONT_CACHE_H diff --git a/engine/src/flutter/libs/minikin/Hyphenator.cpp b/engine/src/flutter/libs/minikin/Hyphenator.cpp index c5eb60b8e5..c170c6bd48 100644 --- a/engine/src/flutter/libs/minikin/Hyphenator.cpp +++ b/engine/src/flutter/libs/minikin/Hyphenator.cpp @@ -30,7 +30,7 @@ using std::vector; -namespace android { +namespace minikin { static const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; @@ -232,4 +232,4 @@ void Hyphenator::hyphenateFromCodes(uint8_t* result, const uint16_t* codes, size } } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 9c1d6a873a..713ac84f0a 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -63,7 +63,7 @@ void Bitmap::writePnm(std::ofstream &o) const { o.close(); } -void Bitmap::drawGlyph(const android::GlyphBitmap& bitmap, int x, int y) { +void Bitmap::drawGlyph(const GlyphBitmap& bitmap, int x, int y) { int bmw = bitmap.width; int bmh = bitmap.height; x += bitmap.left; @@ -85,10 +85,6 @@ void Bitmap::drawGlyph(const android::GlyphBitmap& bitmap, int x, int y) { } } -} // namespace minikin - -namespace android { - const int kDirection_Mask = 0x1; struct LayoutContext { @@ -120,7 +116,7 @@ public: } bool operator==(const LayoutCacheKey &other) const; - hash_t hash() const { + android::hash_t hash() const { return mHash; } @@ -157,12 +153,12 @@ private: bool mIsRtl; // Note: any fields added to MinikinPaint must also be reflected here. // TODO: language matching (possibly integrate into style) - hash_t mHash; + android::hash_t mHash; - hash_t computeHash() const; + android::hash_t computeHash() const; }; -class LayoutCache : private OnEntryRemoved { +class LayoutCache : private android::OnEntryRemoved { public: LayoutCache() : mCache(kMaxEntries) { mCache.setOnEntryRemovedListener(this); @@ -190,7 +186,7 @@ private: delete value; } - LruCache mCache; + android::LruCache mCache; //static const size_t kMaxEntries = LruCache::kUnlimitedCapacity; @@ -204,7 +200,7 @@ static unsigned int disabledDecomposeCompatibility(hb_unicode_funcs_t*, hb_codep return 0; } -class LayoutEngine : public Singleton { +class LayoutEngine : public ::android::Singleton { public: LayoutEngine() { unicodeFunctions = hb_unicode_funcs_create(hb_icu_get_unicode_funcs()); @@ -220,8 +216,6 @@ public: LayoutCache layoutCache; }; -ANDROID_SINGLETON_STATIC_INSTANCE(LayoutEngine); - bool LayoutCacheKey::operator==(const LayoutCacheKey& other) const { return mId == other.mId && mStart == other.mStart @@ -238,23 +232,23 @@ bool LayoutCacheKey::operator==(const LayoutCacheKey& other) const { && !memcmp(mChars, other.mChars, mNchars * sizeof(uint16_t)); } -hash_t LayoutCacheKey::computeHash() const { - uint32_t hash = JenkinsHashMix(0, mId); - hash = JenkinsHashMix(hash, mStart); - hash = JenkinsHashMix(hash, mCount); - hash = JenkinsHashMix(hash, hash_type(mStyle)); - hash = JenkinsHashMix(hash, hash_type(mSize)); - hash = JenkinsHashMix(hash, hash_type(mScaleX)); - hash = JenkinsHashMix(hash, hash_type(mSkewX)); - hash = JenkinsHashMix(hash, hash_type(mLetterSpacing)); - hash = JenkinsHashMix(hash, hash_type(mPaintFlags)); - hash = JenkinsHashMix(hash, hash_type(mHyphenEdit.hasHyphen())); - hash = JenkinsHashMix(hash, hash_type(mIsRtl)); - hash = JenkinsHashMixShorts(hash, mChars, mNchars); - return JenkinsHashWhiten(hash); +android::hash_t LayoutCacheKey::computeHash() const { + uint32_t hash = android::JenkinsHashMix(0, mId); + hash = android::JenkinsHashMix(hash, mStart); + hash = android::JenkinsHashMix(hash, mCount); + hash = android::JenkinsHashMix(hash, hash_type(mStyle)); + hash = android::JenkinsHashMix(hash, hash_type(mSize)); + hash = android::JenkinsHashMix(hash, hash_type(mScaleX)); + hash = android::JenkinsHashMix(hash, hash_type(mSkewX)); + hash = android::JenkinsHashMix(hash, hash_type(mLetterSpacing)); + hash = android::JenkinsHashMix(hash, hash_type(mPaintFlags)); + hash = android::JenkinsHashMix(hash, hash_type(mHyphenEdit.hasHyphen())); + hash = android::JenkinsHashMix(hash, hash_type(mIsRtl)); + hash = android::JenkinsHashMixShorts(hash, mChars, mNchars); + return android::JenkinsHashWhiten(hash); } -hash_t hash_type(const LayoutCacheKey& key) { +android::hash_t hash_type(const LayoutCacheKey& key) { return key.hash(); } @@ -578,7 +572,7 @@ BidiText::BidiText(const uint16_t* buf, size_t start, size_t count, size_t bufSi void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); LayoutContext ctx; ctx.style = style; @@ -597,7 +591,7 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu float Layout::measureText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint, const FontCollection* collection, float* advances) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); LayoutContext ctx; ctx.style = style; @@ -965,10 +959,17 @@ void Layout::getBounds(MinikinRect* bounds) { } void Layout::purgeCaches() { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); LayoutCache& layoutCache = LayoutEngine::getInstance().layoutCache; layoutCache.clear(); purgeHbFontCacheLocked(); } +} // namespace minikin + +// Unable to define the static data member outside of android. +// TODO: introduce our own Singleton to drop android namespace. +namespace android { +ANDROID_SINGLETON_STATIC_INSTANCE(minikin::LayoutEngine); } // namespace android + diff --git a/engine/src/flutter/libs/minikin/LayoutUtils.cpp b/engine/src/flutter/libs/minikin/LayoutUtils.cpp index 418268286c..4e59afd6b2 100644 --- a/engine/src/flutter/libs/minikin/LayoutUtils.cpp +++ b/engine/src/flutter/libs/minikin/LayoutUtils.cpp @@ -18,6 +18,8 @@ #include "LayoutUtils.h" +namespace minikin { + /** * For the purpose of layout, a word break is a boundary with no * kerning or complex script processing. This is necessarily a @@ -74,3 +76,5 @@ size_t getNextWordBreakForCache( } return len; } + +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/LayoutUtils.h b/engine/src/flutter/libs/minikin/LayoutUtils.h index 83ddd0a255..f35e843cfa 100644 --- a/engine/src/flutter/libs/minikin/LayoutUtils.h +++ b/engine/src/flutter/libs/minikin/LayoutUtils.h @@ -19,6 +19,8 @@ #include +namespace minikin { + /** * Return offset of previous word break. It is either < offset or == 0. * @@ -39,4 +41,5 @@ size_t getPrevWordBreakForCache( size_t getNextWordBreakForCache( const uint16_t* chars, size_t offset, size_t len); +} // namespace minikin #endif // MINIKIN_LAYOUT_UTILS_H diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 2a71f044d2..1940062eaf 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -26,7 +26,7 @@ using std::vector; -namespace android { +namespace minikin { const int CHAR_TAB = 0x0009; @@ -441,4 +441,4 @@ void LineBreaker::finish() { mLinePenalty = 0.0f; } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/Measurement.cpp b/engine/src/flutter/libs/minikin/Measurement.cpp index 1ba6678373..a9655e4eaf 100644 --- a/engine/src/flutter/libs/minikin/Measurement.cpp +++ b/engine/src/flutter/libs/minikin/Measurement.cpp @@ -23,7 +23,7 @@ #include #include -namespace android { +namespace minikin { // These could be considered helper methods of layout, but need only be loosely coupled, so // are separate. @@ -119,4 +119,4 @@ size_t getOffsetForAdvance(const float* advances, const uint16_t* buf, size_t st return best; } -} +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/MinikinFont.cpp b/engine/src/flutter/libs/minikin/MinikinFont.cpp index ef42e9b12f..8aee01de7e 100644 --- a/engine/src/flutter/libs/minikin/MinikinFont.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFont.cpp @@ -17,10 +17,10 @@ #include #include "HbFontCache.h" -namespace android { +namespace minikin { MinikinFont::~MinikinFont() { purgeHbFontLocked(this); } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp index 4a1b115082..6f56a8dd55 100644 --- a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp @@ -25,7 +25,7 @@ #include -namespace android { +namespace minikin { int32_t MinikinFontFreeType::sIdCounter = 0; @@ -97,4 +97,4 @@ MinikinFontFreeType* MinikinFontFreeType::GetFreeType() { return this; } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 7fcc7b7f8b..b1ca2df669 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -22,9 +22,9 @@ #include -namespace android { +namespace minikin { -Mutex gMinikinLock; +android::Mutex gMinikinLock; void assertMinikinLocked() { #ifdef ENABLE_RACE_DETECTION @@ -88,4 +88,4 @@ hb_blob_t* getFontTable(MinikinFont* minikinFont, uint32_t tag) { return blob; } -} +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index 88cc9475c8..88c0d5f510 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -25,13 +25,13 @@ #include -namespace android { +namespace minikin { // All external Minikin interfaces are designed to be thread-safe. // Presently, that's implemented by through a global lock, and having // all external interfaces take that lock. -extern Mutex gMinikinLock; +extern android::Mutex gMinikinLock; // Aborts if gMinikinLock is not acquired. Do nothing on the release build. void assertMinikinLocked(); @@ -74,6 +74,6 @@ private: hb_blob_t* mBlob; }; -} +} // namespace minikin #endif // MINIKIN_INTERNAL_H diff --git a/engine/src/flutter/libs/minikin/MinikinRefCounted.cpp b/engine/src/flutter/libs/minikin/MinikinRefCounted.cpp index 9fa3ae4631..6914a012f8 100644 --- a/engine/src/flutter/libs/minikin/MinikinRefCounted.cpp +++ b/engine/src/flutter/libs/minikin/MinikinRefCounted.cpp @@ -20,16 +20,16 @@ #include -namespace android { +namespace minikin { void MinikinRefCounted::Ref() { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); this->RefLocked(); } void MinikinRefCounted::Unref() { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); this->UnrefLocked(); } -} +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp index de0791445c..d78dd246ed 100644 --- a/engine/src/flutter/libs/minikin/SparseBitSet.cpp +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -19,7 +19,7 @@ #include #include -namespace android { +namespace minikin { const uint32_t SparseBitSet::kNotFound; @@ -146,4 +146,4 @@ uint32_t SparseBitSet::nextSetBit(uint32_t fromIndex) const { return kNotFound; } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index 38f03caf6a..a852eddddf 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -23,7 +23,7 @@ #include #include -namespace android { +namespace minikin { const uint32_t CHAR_SOFT_HYPHEN = 0x00AD; const uint32_t CHAR_ZWJ = 0x200D; @@ -258,4 +258,4 @@ void WordBreaker::finish() { utext_close(&mUText); } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py b/engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py index 7233ef621e..5186455188 100644 --- a/engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py +++ b/engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py @@ -27,7 +27,7 @@ UNICODE_EMOJI_TEMPLATE=""" #include -namespace android { +namespace minikin { namespace generated { int32_t EMOJI_LIST[] = { @@ -35,7 +35,7 @@ int32_t EMOJI_LIST[] = { }; } // namespace generated -} // namespace android +} // namespace minikin #endif // MINIKIN_UNICODE_EMOJI_H """ diff --git a/engine/src/flutter/sample/MinikinSkia.cpp b/engine/src/flutter/sample/MinikinSkia.cpp index e2ecde02d1..c920ca63e5 100644 --- a/engine/src/flutter/sample/MinikinSkia.cpp +++ b/engine/src/flutter/sample/MinikinSkia.cpp @@ -4,7 +4,7 @@ #include #include "MinikinSkia.h" -namespace android { +namespace minikin { MinikinFontSkia::MinikinFontSkia(SkTypeface *typeface) : MinikinFont(typeface->uniqueID()), @@ -68,4 +68,4 @@ SkTypeface *MinikinFontSkia::GetSkTypeface() { return mTypeface; } -} +} // namespace minikin diff --git a/engine/src/flutter/sample/MinikinSkia.h b/engine/src/flutter/sample/MinikinSkia.h index 6eb9065cc2..92f5ed2f52 100644 --- a/engine/src/flutter/sample/MinikinSkia.h +++ b/engine/src/flutter/sample/MinikinSkia.h @@ -1,4 +1,19 @@ -namespace android { +/* + * Copyright (C) 2016 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. + */ +namespace minikin { class MinikinFontSkia : public MinikinFont { public: @@ -21,4 +36,4 @@ private: }; -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index f4c6a07a4a..a27918ea75 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -28,7 +28,6 @@ #include using std::vector; -using namespace android; using namespace minikin; FT_Library library; // TODO: this should not be a global diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index f892b8c987..bd2d779b9e 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -37,7 +37,7 @@ using std::vector; -namespace android { +namespace minikin { FT_Library library; // TODO: this should not be a global @@ -145,8 +145,8 @@ int runMinikinTest() { return 0; } -} +} // namespace minikin int main(int argc, const char** argv) { - return android::runMinikinTest(); + return minikin::runMinikinTest(); } diff --git a/engine/src/flutter/tests/perftests/FontLanguage.cpp b/engine/src/flutter/tests/perftests/FontLanguage.cpp index ac7af6f909..8f77e12b75 100644 --- a/engine/src/flutter/tests/perftests/FontLanguage.cpp +++ b/engine/src/flutter/tests/perftests/FontLanguage.cpp @@ -17,7 +17,7 @@ #include "FontLanguage.h" -using android::FontLanguage; +namespace minikin { static void BM_FontLanguage_en_US(benchmark::State& state) { while (state.KeepRunning()) { @@ -32,3 +32,5 @@ static void BM_FontLanguage_en_Latn_US(benchmark::State& state) { } } BENCHMARK(BM_FontLanguage_en_Latn_US); + +} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 8ad9472490..8ae703ea12 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -25,16 +25,7 @@ #include "UnicodeUtils.h" #include "minikin/FontFamily.h" -using android::AutoMutex; -using android::FontCollection; -using android::FontFamily; -using android::FontLanguage; -using android::FontLanguages; -using android::FontLanguageListCache; -using android::FontStyle; -using android::MinikinAutoUnref; -using android::MinikinFont; -using android::gMinikinLock; +namespace minikin { const char kItemizeFontXml[] = kTestFontDir "itemize.xml"; const char kEmojiFont[] = kTestFontDir "Emoji.ttf"; @@ -64,7 +55,7 @@ void itemize(FontCollection* collection, const char* str, FontStyle style, result->clear(); ParseUnicode(buf, BUF_SIZE, str, &len, NULL); - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); collection->itemize(buf, len, style, result); } @@ -76,7 +67,7 @@ const std::string& getFontPath(const FontCollection::Run& run) { // Utility function to obtain FontLanguages from string. const FontLanguages& registerAndGetFontLanguages(const std::string& lang_string) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); return FontLanguageListCache::getById(FontLanguageListCache::getId(lang_string)); } @@ -673,12 +664,12 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { // point. const std::string kVSTestFont = kTestFontDir "VarioationSelectorTest-Regular.ttf"; - std::vector families; - FontFamily* family1 = new FontFamily(android::VARIANT_DEFAULT); + std::vector families; + FontFamily* family1 = new FontFamily(VARIANT_DEFAULT); family1->addFont(new MinikinFontForTest(kLatinFont)); families.push_back(family1); - FontFamily* family2 = new FontFamily(android::VARIANT_DEFAULT); + FontFamily* family2 = new FontFamily(VARIANT_DEFAULT); family2->addFont(new MinikinFontForTest(kVSTestFont)); families.push_back(family2); @@ -1372,3 +1363,5 @@ TEST_F(FontCollectionItemizeTest, itemize_PrivateUseArea) { EXPECT_EQ(4, runs[0].end); EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); } + +} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index 5a03f60d26..a22067a5b0 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -21,7 +21,7 @@ #include "MinikinFontForTest.h" #include "MinikinInternal.h" -namespace android { +namespace minikin { // The test font has following glyphs. // U+82A6 @@ -107,4 +107,4 @@ TEST(FontCollectionTest, hasVariationSelectorTest_emoji) { EXPECT_FALSE(collection->hasVariationSelector(0x2229, 0xFE0F)); } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 1b2457695c..384703f8c4 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -25,19 +25,19 @@ #include "MinikinFontForTest.h" #include "MinikinInternal.h" -namespace android { +namespace minikin { typedef ICUTestBase FontLanguagesTest; typedef ICUTestBase FontLanguageTest; static const FontLanguages& createFontLanguages(const std::string& input) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); uint32_t langId = FontLanguageListCache::getId(input); return FontLanguageListCache::getById(langId); } static FontLanguage createFontLanguage(const std::string& input) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); uint32_t langId = FontLanguageListCache::getId(input); return FontLanguageListCache::getById(langId)[0]; } @@ -354,7 +354,7 @@ TEST_F(FontFamilyTest, hasVariationSelectorTest) { MinikinAutoUnref family(new FontFamily); family->addFont(minikinFont.get()); - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); const uint32_t kVS1 = 0xFE00; const uint32_t kVS2 = 0xFE01; @@ -406,11 +406,11 @@ TEST_F(FontFamilyTest, hasVSTableTest) { MinikinAutoUnref minikinFont(new MinikinFontForTest(testCase.fontPath)); MinikinAutoUnref family(new FontFamily); family->addFont(minikinFont.get()); - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); family->getCoverage(); EXPECT_EQ(testCase.hasVSTable, family->hasVSTable()); } } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp index 2a046713c9..81d84a8a28 100644 --- a/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp @@ -22,7 +22,7 @@ #include "ICUTestBase.h" #include "MinikinInternal.h" -namespace android { +namespace minikin { typedef ICUTestBase FontLanguageListCacheTest; @@ -31,7 +31,7 @@ TEST_F(FontLanguageListCacheTest, getId) { EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en,zh-Hans")); - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); EXPECT_EQ(0UL, FontLanguageListCache::getId("")); EXPECT_EQ(FontLanguageListCache::getId("en"), FontLanguageListCache::getId("en")); @@ -50,7 +50,7 @@ TEST_F(FontLanguageListCacheTest, getId) { } TEST_F(FontLanguageListCacheTest, getById) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); uint32_t enLangId = FontLanguageListCache::getId("en"); uint32_t jpLangId = FontLanguageListCache::getId("jp"); FontLanguage english = FontLanguageListCache::getById(enLangId)[0]; @@ -70,4 +70,4 @@ TEST_F(FontLanguageListCacheTest, getById) { EXPECT_EQ(japanese, langs2[1]); } -} // android +} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp index cec5308877..07ddf82ce6 100644 --- a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp @@ -18,7 +18,7 @@ #include #include -using namespace android; +namespace minikin { bool IsBreak(const char* src) { const size_t BUF_SIZE = 256; @@ -188,3 +188,5 @@ TEST(GraphemeBreak, offsets) { EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(string, 2, 3, 4)); EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(string, 2, 3, 5)); } + +} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp index 2dee61aff0..82adc4f768 100644 --- a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp @@ -26,19 +26,18 @@ #include "MinikinFontForTest.h" #include -namespace android { -namespace { +namespace minikin { class HbFontCacheTest : public testing::Test { public: virtual void TearDown() { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); purgeHbFontCacheLocked(); } }; TEST_F(HbFontCacheTest, getHbFontLockedTest) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); MinikinFontForTest fontA(kTestFontDir "Regular.ttf"); MinikinFontForTest fontB(kTestFontDir "Bold.ttf"); @@ -62,7 +61,7 @@ TEST_F(HbFontCacheTest, getHbFontLockedTest) { } TEST_F(HbFontCacheTest, purgeCacheTest) { - AutoMutex _l(gMinikinLock); + android::AutoMutex _l(gMinikinLock); MinikinFontForTest minikinFont(kTestFontDir "Regular.ttf"); hb_font_t* font = getHbFontLocked(&minikinFont); @@ -83,5 +82,4 @@ TEST_F(HbFontCacheTest, purgeCacheTest) { EXPECT_EQ(nullptr, hb_font_get_user_data(font, &key)); } -} // namespace -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/ICUTestBase.h b/engine/src/flutter/tests/unittest/ICUTestBase.h index 3bcfaf3694..f915cf80ce 100644 --- a/engine/src/flutter/tests/unittest/ICUTestBase.h +++ b/engine/src/flutter/tests/unittest/ICUTestBase.h @@ -26,6 +26,8 @@ #include #include +namespace minikin { + class ICUTestBase : public testing::Test { protected: virtual void SetUp() override { @@ -48,5 +50,5 @@ protected: } }; - +} // namespace minikin #endif // MINIKIN_TEST_ICU_TEST_BASE_H diff --git a/engine/src/flutter/tests/unittest/LayoutUtilsTest.cpp b/engine/src/flutter/tests/unittest/LayoutUtilsTest.cpp index f4fbb18107..e7e6c273d6 100644 --- a/engine/src/flutter/tests/unittest/LayoutUtilsTest.cpp +++ b/engine/src/flutter/tests/unittest/LayoutUtilsTest.cpp @@ -19,7 +19,7 @@ #include "LayoutUtils.h" -namespace { +namespace minikin { void ExpectNextWordBreakForCache(size_t offset_in, const char* query_str) { const size_t BUF_SIZE = 256U; @@ -507,4 +507,4 @@ TEST(WordBreakTest, goPrevWordBreakTest) { ExpectPrevWordBreakForCache(1000, "U+4444 U+302D U+302D | U+4444"); } -} // namespace +} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/MinikinInternalTest.cpp b/engine/src/flutter/tests/unittest/MinikinInternalTest.cpp index 9c1a1e54a4..e314dd1be5 100644 --- a/engine/src/flutter/tests/unittest/MinikinInternalTest.cpp +++ b/engine/src/flutter/tests/unittest/MinikinInternalTest.cpp @@ -18,7 +18,7 @@ #include "MinikinInternal.h" -namespace android { +namespace minikin { TEST(MinikinInternalTest, isEmojiTest) { EXPECT_TRUE(isEmoji(0x0023)); // NUMBER SIGN @@ -31,4 +31,4 @@ TEST(MinikinInternalTest, isEmojiTest) { EXPECT_FALSE(isEmoji(0x29E3D)); // A han character. } -} // namespace android +} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/WordBreakerTests.cpp b/engine/src/flutter/tests/unittest/WordBreakerTests.cpp index 8ed87cc506..bacf3178a1 100644 --- a/engine/src/flutter/tests/unittest/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/unittest/WordBreakerTests.cpp @@ -31,7 +31,7 @@ #define UTF16(codepoint) U16_LEAD(codepoint), U16_TRAIL(codepoint) -using namespace android; +namespace minikin { typedef ICUTestBase WordBreakerTest; @@ -388,3 +388,5 @@ TEST_F(WordBreakerTest, emailStartsWithSlash) { EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end EXPECT_TRUE(breaker.wordStart() >= breaker.wordEnd()); } + +} // namespace minikin diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index fdc3ed6ee9..76d3ea20a2 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -24,31 +24,33 @@ #include "FontLanguage.h" #include "MinikinFontForTest.h" -android::FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { +namespace minikin { + +FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { xmlDoc* doc = xmlReadFile(fontXml, NULL, 0); xmlNode* familySet = xmlDocGetRootElement(doc); - std::vector families; + std::vector families; for (xmlNode* familyNode = familySet->children; familyNode; familyNode = familyNode->next) { if (xmlStrcmp(familyNode->name, (const xmlChar*)"family") != 0) { continue; } xmlChar* variantXmlch = xmlGetProp(familyNode, (const xmlChar*)"variant"); - int variant = android::VARIANT_DEFAULT; + int variant = VARIANT_DEFAULT; if (variantXmlch) { if (xmlStrcmp(variantXmlch, (const xmlChar*)"elegant") == 0) { - variant = android::VARIANT_ELEGANT; + variant = VARIANT_ELEGANT; } else if (xmlStrcmp(variantXmlch, (const xmlChar*)"compact") == 0) { - variant = android::VARIANT_COMPACT; + variant = VARIANT_COMPACT; } } xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); - uint32_t langId = android::FontStyle::registerLanguageList( + uint32_t langId = FontStyle::registerLanguageList( std::string((const char*)lang, xmlStrlen(lang))); - android::FontFamily* family = new android::FontFamily(langId, variant); + FontFamily* family = new FontFamily(langId, variant); for (xmlNode* fontNode = familyNode->children; fontNode; fontNode = fontNode->next) { if (xmlStrcmp(fontNode->name, (const xmlChar*)"font") != 0) { @@ -66,16 +68,18 @@ android::FontCollection* getFontCollection(const char* fontDir, const char* font LOG_ALWAYS_FATAL_IF(access(fontPath.c_str(), R_OK) != 0, "%s is not found", fontPath.c_str()); - family->addFont(new MinikinFontForTest(fontPath), android::FontStyle(weight, italic)); + family->addFont(new MinikinFontForTest(fontPath), FontStyle(weight, italic)); } families.push_back(family); } xmlFreeDoc(doc); - android::FontCollection* collection = new android::FontCollection(families); + FontCollection* collection = new FontCollection(families); collection->Ref(); for (size_t i = 0; i < families.size(); ++i) { families[i]->Unref(); } return collection; } + +} // namespace minikin diff --git a/engine/src/flutter/tests/util/FontTestUtils.h b/engine/src/flutter/tests/util/FontTestUtils.h index 5258a766ae..69ba841b43 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.h +++ b/engine/src/flutter/tests/util/FontTestUtils.h @@ -19,6 +19,8 @@ #include +namespace minikin { + /** * Returns FontCollection from installed fonts. * @@ -27,6 +29,7 @@ * * Caller must unref the returned pointer. */ -android::FontCollection* getFontCollection(const char* fontDir, const char* fontXml); +FontCollection* getFontCollection(const char* fontDir, const char* fontXml); +} // namespace minikin #endif // MINIKIN_FONT_TEST_UTILS_H diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index 66dd4ea473..ae8ef72bcf 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -22,6 +22,8 @@ #include +namespace minikin { + MinikinFontForTest::MinikinFontForTest(const std::string& font_path) : MinikinFontForTest(font_path, SkTypeface::CreateFromFile(font_path.c_str())) { } @@ -36,18 +38,18 @@ MinikinFontForTest::~MinikinFontForTest() { } float MinikinFontForTest::GetHorizontalAdvance(uint32_t /* glyph_id */, - const android::MinikinPaint& /* paint */) const { + const MinikinPaint& /* paint */) const { LOG_ALWAYS_FATAL("MinikinFontForTest::GetHorizontalAdvance is not yet implemented"); return 0.0f; } -void MinikinFontForTest::GetBounds(android::MinikinRect* /* bounds */, uint32_t /* glyph_id */, - const android::MinikinPaint& /* paint */) const { +void MinikinFontForTest::GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph_id */, + const MinikinPaint& /* paint */) const { LOG_ALWAYS_FATAL("MinikinFontForTest::GetBounds is not yet implemented"); } const void* MinikinFontForTest::GetTable(uint32_t tag, size_t* size, - android::MinikinDestroyFunc* destroy) { + MinikinDestroyFunc* destroy) { const size_t tableSize = mTypeface->getTableSize(tag); *size = tableSize; if (tableSize == 0) { @@ -61,3 +63,5 @@ const void* MinikinFontForTest::GetTable(uint32_t tag, size_t* size, *destroy = free; return buf; } + +} // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index e527d21e34..56f63adaff 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -21,17 +21,19 @@ class SkTypeface; -class MinikinFontForTest : public android::MinikinFont { +namespace minikin { + +class MinikinFontForTest : public MinikinFont { public: explicit MinikinFontForTest(const std::string& font_path); MinikinFontForTest(const std::string& font_path, SkTypeface* typeface); ~MinikinFontForTest(); // MinikinFont overrides. - float GetHorizontalAdvance(uint32_t glyph_id, const android::MinikinPaint &paint) const; - void GetBounds(android::MinikinRect* bounds, uint32_t glyph_id, - const android::MinikinPaint& paint) const; - const void* GetTable(uint32_t tag, size_t* size, android::MinikinDestroyFunc* destroy); + float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const; + void GetBounds(MinikinRect* bounds, uint32_t glyph_id, + const MinikinPaint& paint) const; + const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy); const std::string& fontPath() const { return mFontPath; } private: @@ -39,4 +41,6 @@ private: const std::string mFontPath; }; +} // namespace minikin + #endif // MINIKIN_TEST_MINIKIN_FONT_FOR_TEST_H diff --git a/engine/src/flutter/tests/util/UnicodeUtils.cpp b/engine/src/flutter/tests/util/UnicodeUtils.cpp index 501fc9f480..bb652ff63d 100644 --- a/engine/src/flutter/tests/util/UnicodeUtils.cpp +++ b/engine/src/flutter/tests/util/UnicodeUtils.cpp @@ -18,6 +18,8 @@ #include #include +namespace minikin { + // src is of the form "U+1F431 | 'h' 'i'". Position of "|" gets saved to offset if non-null. // Size is returned in an out parameter because gtest needs a void return for ASSERT to work. void ParseUnicode(uint16_t* buf, size_t buf_size, const char* src, size_t* result_size, @@ -94,3 +96,5 @@ TEST(UnicodeUtils, parse) { EXPECT_EQ(buf[2], 0xDC31); EXPECT_EQ(buf[3], 'a'); } + +} // namespace minikin diff --git a/engine/src/flutter/tests/util/UnicodeUtils.h b/engine/src/flutter/tests/util/UnicodeUtils.h index 4f1b06a2fc..64b90c91b1 100644 --- a/engine/src/flutter/tests/util/UnicodeUtils.h +++ b/engine/src/flutter/tests/util/UnicodeUtils.h @@ -14,5 +14,9 @@ * limitations under the License. */ - void ParseUnicode(uint16_t* buf, size_t buf_size, const char* src, size_t* result_size, +namespace minikin { + +void ParseUnicode(uint16_t* buf, size_t buf_size, const char* src, size_t* result_size, size_t* offset); + +} // namespace minikin From c3b9f7dadde2701885950c0d6aa0f6f739b5cecb Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 16 Jun 2016 16:59:30 +0900 Subject: [PATCH 186/364] Fix test utilities This fixes following three memory leaks in test utilities. There is no problem in production code and this CL doesn't affect any production behaviors. - SkTypeface leaks due to forget calling SkSafeUnref in dtor. - MinikinFontForTest leaks during constructing FontCollection. - FontCollection leaks due to unnecessary AddRef. Change-Id: I22e1e0307f1b2499296acb1aacc3ef66076a36e9 --- .../unittest/FontCollectionItemizeTest.cpp | 23 ++++++----- .../tests/unittest/FontCollectionTest.cpp | 32 +++++++-------- .../flutter/tests/unittest/FontFamilyTest.cpp | 6 ++- .../tests/unittest/HbFontCacheTest.cpp | 39 +++++++++++-------- .../src/flutter/tests/util/FontTestUtils.cpp | 6 ++- .../flutter/tests/util/MinikinFontForTest.cpp | 16 +++++--- .../flutter/tests/util/MinikinFontForTest.h | 9 ++++- 7 files changed, 78 insertions(+), 53 deletions(-) diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 8ae703ea12..b28820b1f8 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -666,11 +666,13 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { std::vector families; FontFamily* family1 = new FontFamily(VARIANT_DEFAULT); - family1->addFont(new MinikinFontForTest(kLatinFont)); + MinikinAutoUnref font(MinikinFontForTest::createFromFile(kLatinFont)); + family1->addFont(font.get()); families.push_back(family1); FontFamily* family2 = new FontFamily(VARIANT_DEFAULT); - family2->addFont(new MinikinFontForTest(kVSTestFont)); + MinikinAutoUnref font2(MinikinFontForTest::createFromFile(kVSTestFont)); + family2->addFont(font2.get()); families.push_back(family2); FontCollection collection(families); @@ -794,8 +796,9 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { // Prepare first font which doesn't supports U+9AA8 FontFamily* firstFamily = new FontFamily( FontStyle::registerLanguageList("und"), 0 /* variant */); - MinikinFont* firstFamilyMinikinFont = new MinikinFontForTest(kNoGlyphFont); - firstFamily->addFont(firstFamilyMinikinFont); + MinikinAutoUnref firstFamilyMinikinFont( + MinikinFontForTest::createFromFile(kNoGlyphFont)); + firstFamily->addFont(firstFamilyMinikinFont.get()); families.push_back(firstFamily); // Prepare font families @@ -806,12 +809,12 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { for (size_t i = 0; i < testCase.fontLanguages.size(); ++i) { FontFamily* family = new FontFamily( FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */); - MinikinFont* minikin_font = new MinikinFontForTest(kJAFont); - family->addFont(minikin_font); + MinikinAutoUnref minikin_font(MinikinFontForTest::createFromFile(kJAFont)); + family->addFont(minikin_font.get()); families.push_back(family); - fontLangIdxMap.insert(std::make_pair(minikin_font, i)); + fontLangIdxMap.insert(std::make_pair(minikin_font.get(), i)); } - FontCollection collection(families); + MinikinAutoUnref collection(new FontCollection(families)); for (auto family : families) { family->Unref(); } @@ -820,13 +823,13 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { const FontStyle style = FontStyle( FontStyle::registerLanguageList(testCase.userPreferredLanguages)); std::vector runs; - itemize(&collection, "U+9AA8", style, &runs); + itemize(collection.get(), "U+9AA8", style, &runs); ASSERT_EQ(1U, runs.size()); ASSERT_NE(nullptr, runs[0].fakedFont.font); // First family doesn't support U+9AA8 and others support it, so the first font should not // be selected. - EXPECT_NE(firstFamilyMinikinFont, runs[0].fakedFont.font); + EXPECT_NE(firstFamilyMinikinFont.get(), runs[0].fakedFont.font); // Lookup used font family by MinikinFont*. const int usedLangIndex = fontLangIdxMap[runs[0].fakedFont.font]; diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index a22067a5b0..3f365be083 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -40,40 +40,40 @@ namespace minikin { // U+717D U+E0103 (VS20) const char kVsTestFont[] = kTestFontDir "/VarioationSelectorTest-Regular.ttf"; -void expectVSGlyphs(const FontCollection& fc, uint32_t codepoint, const std::set& vsSet) { +void expectVSGlyphs(const FontCollection* fc, uint32_t codepoint, const std::set& vsSet) { for (uint32_t vs = 0xFE00; vs <= 0xE01EF; ++vs) { // Move to variation selectors supplements after variation selectors. if (vs == 0xFF00) { vs = 0xE0100; } if (vsSet.find(vs) == vsSet.end()) { - EXPECT_FALSE(fc.hasVariationSelector(codepoint, vs)) + EXPECT_FALSE(fc->hasVariationSelector(codepoint, vs)) << "Glyph for U+" << std::hex << codepoint << " U+" << vs; } else { - EXPECT_TRUE(fc.hasVariationSelector(codepoint, vs)) + EXPECT_TRUE(fc->hasVariationSelector(codepoint, vs)) << "Glyph for U+" << std::hex << codepoint << " U+" << vs; } } } TEST(FontCollectionTest, hasVariationSelectorTest) { - FontFamily* family = new FontFamily(); - family->addFont(new MinikinFontForTest(kVsTestFont)); - std::vector families({family}); - FontCollection fc(families); - family->Unref(); + MinikinAutoUnref family(new FontFamily()); + MinikinAutoUnref font(MinikinFontForTest::createFromFile(kVsTestFont)); + family->addFont(font.get()); + std::vector families({family.get()}); + MinikinAutoUnref fc(new FontCollection(families)); - EXPECT_FALSE(fc.hasVariationSelector(0x82A6, 0)); - expectVSGlyphs(fc, 0x82A6, std::set({0xFE00, 0xE0100, 0xE0101, 0xE0102})); + EXPECT_FALSE(fc->hasVariationSelector(0x82A6, 0)); + expectVSGlyphs(fc.get(), 0x82A6, std::set({0xFE00, 0xE0100, 0xE0101, 0xE0102})); - EXPECT_FALSE(fc.hasVariationSelector(0x845B, 0)); - expectVSGlyphs(fc, 0x845B, std::set({0xFE01, 0xE0101, 0xE0102, 0xE0103})); + EXPECT_FALSE(fc->hasVariationSelector(0x845B, 0)); + expectVSGlyphs(fc.get(), 0x845B, std::set({0xFE01, 0xE0101, 0xE0102, 0xE0103})); - EXPECT_FALSE(fc.hasVariationSelector(0x537F, 0)); - expectVSGlyphs(fc, 0x537F, std::set({})); + EXPECT_FALSE(fc->hasVariationSelector(0x537F, 0)); + expectVSGlyphs(fc.get(), 0x537F, std::set({})); - EXPECT_FALSE(fc.hasVariationSelector(0x717D, 0)); - expectVSGlyphs(fc, 0x717D, std::set({0xFE02, 0xE0102, 0xE0103})); + EXPECT_FALSE(fc->hasVariationSelector(0x717D, 0)); + expectVSGlyphs(fc.get(), 0x717D, std::set({0xFE02, 0xE0102, 0xE0103})); } const char kEmojiXmlFile[] = kTestFontDir "emoji.xml"; diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 384703f8c4..69fef23da8 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -350,7 +350,8 @@ void expectVSGlyphs(FontFamily* family, uint32_t codepoint, const std::set minikinFont(new MinikinFontForTest(kVsTestFont)); + MinikinAutoUnref + minikinFont(MinikinFontForTest::createFromFile(kVsTestFont)); MinikinAutoUnref family(new FontFamily); family->addFont(minikinFont.get()); @@ -403,7 +404,8 @@ TEST_F(FontFamilyTest, hasVSTableTest) { "Font " + testCase.fontPath + " should have a variation sequence table." : "Font " + testCase.fontPath + " shouldn't have a variation sequence table."); - MinikinAutoUnref minikinFont(new MinikinFontForTest(testCase.fontPath)); + MinikinAutoUnref minikinFont( + MinikinFontForTest::createFromFile(testCase.fontPath)); MinikinAutoUnref family(new FontFamily); family->addFont(minikinFont.get()); android::AutoMutex _l(gMinikinLock); diff --git a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp index 82adc4f768..aa4cb34c05 100644 --- a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp @@ -37,34 +37,39 @@ public: }; TEST_F(HbFontCacheTest, getHbFontLockedTest) { + MinikinAutoUnref fontA( + MinikinFontForTest::createFromFile(kTestFontDir "Regular.ttf")); + + MinikinAutoUnref fontB( + MinikinFontForTest::createFromFile(kTestFontDir "Bold.ttf")); + + MinikinAutoUnref fontC( + MinikinFontForTest::createFromFile(kTestFontDir "BoldItalic.ttf")); + android::AutoMutex _l(gMinikinLock); - - MinikinFontForTest fontA(kTestFontDir "Regular.ttf"); - MinikinFontForTest fontB(kTestFontDir "Bold.ttf"); - MinikinFontForTest fontC(kTestFontDir "BoldItalic.ttf"); - // Never return NULL. - EXPECT_NE(nullptr, getHbFontLocked(&fontA)); - EXPECT_NE(nullptr, getHbFontLocked(&fontB)); - EXPECT_NE(nullptr, getHbFontLocked(&fontC)); + EXPECT_NE(nullptr, getHbFontLocked(fontA.get())); + EXPECT_NE(nullptr, getHbFontLocked(fontB.get())); + EXPECT_NE(nullptr, getHbFontLocked(fontC.get())); EXPECT_NE(nullptr, getHbFontLocked(nullptr)); // Must return same object if same font object is passed. - EXPECT_EQ(getHbFontLocked(&fontA), getHbFontLocked(&fontA)); - EXPECT_EQ(getHbFontLocked(&fontB), getHbFontLocked(&fontB)); - EXPECT_EQ(getHbFontLocked(&fontC), getHbFontLocked(&fontC)); + EXPECT_EQ(getHbFontLocked(fontA.get()), getHbFontLocked(fontA.get())); + EXPECT_EQ(getHbFontLocked(fontB.get()), getHbFontLocked(fontB.get())); + EXPECT_EQ(getHbFontLocked(fontC.get()), getHbFontLocked(fontC.get())); // Different object must be returned if the passed minikinFont has different ID. - EXPECT_NE(getHbFontLocked(&fontA), getHbFontLocked(&fontB)); - EXPECT_NE(getHbFontLocked(&fontA), getHbFontLocked(&fontC)); + EXPECT_NE(getHbFontLocked(fontA.get()), getHbFontLocked(fontB.get())); + EXPECT_NE(getHbFontLocked(fontA.get()), getHbFontLocked(fontC.get())); } TEST_F(HbFontCacheTest, purgeCacheTest) { - android::AutoMutex _l(gMinikinLock); - MinikinFontForTest minikinFont(kTestFontDir "Regular.ttf"); + MinikinAutoUnref minikinFont( + MinikinFontForTest::createFromFile(kTestFontDir "Regular.ttf")); - hb_font_t* font = getHbFontLocked(&minikinFont); + android::AutoMutex _l(gMinikinLock); + hb_font_t* font = getHbFontLocked(minikinFont.get()); ASSERT_NE(nullptr, font); // Set user data to identify the font object. @@ -78,7 +83,7 @@ TEST_F(HbFontCacheTest, purgeCacheTest) { // By checking user data, confirm that the object after purge is different from previously // created one. Do not compare the returned pointer here since memory allocator may assign // same region for new object. - font = getHbFontLocked(&minikinFont); + font = getHbFontLocked(minikinFont.get()); EXPECT_EQ(nullptr, hb_font_get_user_data(font, &key)); } diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index 76d3ea20a2..eaf3610df2 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -68,14 +68,16 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { LOG_ALWAYS_FATAL_IF(access(fontPath.c_str(), R_OK) != 0, "%s is not found", fontPath.c_str()); - family->addFont(new MinikinFontForTest(fontPath), FontStyle(weight, italic)); + MinikinAutoUnref + minikinFont(MinikinFontForTest::createFromFile(fontPath)); + + family->addFont(minikinFont.get(), FontStyle(weight, italic)); } families.push_back(family); } xmlFreeDoc(doc); FontCollection* collection = new FontCollection(families); - collection->Ref(); for (size_t i = 0; i < families.size(); ++i) { families[i]->Unref(); } diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index ae8ef72bcf..93e3e66d2d 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -24,17 +24,23 @@ namespace minikin { -MinikinFontForTest::MinikinFontForTest(const std::string& font_path) : - MinikinFontForTest(font_path, SkTypeface::CreateFromFile(font_path.c_str())) { +// static +MinikinFontForTest* MinikinFontForTest::createFromFile(const std::string& font_path) { + SkTypeface* typeface = SkTypeface::CreateFromFile(font_path.c_str()); + MinikinFontForTest* font = new MinikinFontForTest(font_path, typeface); + SkSafeUnref(typeface); + return font; } MinikinFontForTest::MinikinFontForTest(const std::string& font_path, SkTypeface* typeface) : - MinikinFont(typeface->uniqueID()), - mTypeface(typeface), - mFontPath(font_path) { + MinikinFont(typeface->uniqueID()), + mTypeface(typeface), + mFontPath(font_path) { + SkSafeRef(mTypeface); } MinikinFontForTest::~MinikinFontForTest() { + SkSafeUnref(mTypeface); } float MinikinFontForTest::GetHorizontalAdvance(uint32_t /* glyph_id */, diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index 56f63adaff..bfd8421525 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -25,10 +25,13 @@ namespace minikin { class MinikinFontForTest : public MinikinFont { public: - explicit MinikinFontForTest(const std::string& font_path); MinikinFontForTest(const std::string& font_path, SkTypeface* typeface); ~MinikinFontForTest(); + // Helper function for creating MinikinFontForTest instance from font file. + // Calller need to unref returned object. + static MinikinFontForTest* createFromFile(const std::string& font_path); + // MinikinFont overrides. float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const; void GetBounds(MinikinRect* bounds, uint32_t glyph_id, @@ -37,6 +40,10 @@ public: const std::string& fontPath() const { return mFontPath; } private: + MinikinFontForTest() = delete; + MinikinFontForTest(const MinikinFontForTest&) = delete; + MinikinFontForTest& operator=(MinikinFontForTest&) = delete; + SkTypeface *mTypeface; const std::string mFontPath; }; From df66baa6fa6461e7acd1e3521c6a0a66a0f6d6a1 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 14 Jun 2016 15:43:57 +0900 Subject: [PATCH 187/364] Add more native perf tests to minikin. This CL introduces performance tests for following three modules: - Hyphenator - WordBreaker - GraphemeBreak During using UnicodeUtils, need to decouple it from gtest since perftest doesn't have gtest dependencies. Bug:29142734 Change-Id: I700c662fa7d0a52f19d8e93150ad1a85dc28769f --- engine/src/flutter/tests/perftests/Android.mk | 9 +++ .../flutter/tests/perftests/GraphemeBreak.cpp | 79 +++++++++++++++++++ .../flutter/tests/perftests/Hyphenator.cpp | 55 +++++++++++++ .../flutter/tests/perftests/WordBreaker.cpp | 39 +++++++++ engine/src/flutter/tests/perftests/main.cpp | 30 ++++++- engine/src/flutter/tests/unittest/Android.mk | 1 + .../tests/unittest/UnicodeUtilsTest.cpp | 37 +++++++++ engine/src/flutter/tests/util/FileUtils.cpp | 35 ++++++++ engine/src/flutter/tests/util/FileUtils.h | 18 +++++ .../src/flutter/tests/util/UnicodeUtils.cpp | 64 ++++++++------- engine/src/flutter/tests/util/UnicodeUtils.h | 3 + 11 files changed, 341 insertions(+), 29 deletions(-) create mode 100644 engine/src/flutter/tests/perftests/GraphemeBreak.cpp create mode 100644 engine/src/flutter/tests/perftests/Hyphenator.cpp create mode 100644 engine/src/flutter/tests/perftests/WordBreaker.cpp create mode 100644 engine/src/flutter/tests/unittest/UnicodeUtilsTest.cpp create mode 100644 engine/src/flutter/tests/util/FileUtils.cpp create mode 100644 engine/src/flutter/tests/util/FileUtils.h diff --git a/engine/src/flutter/tests/perftests/Android.mk b/engine/src/flutter/tests/perftests/Android.mk index 3b49036cee..d3ed600b6e 100644 --- a/engine/src/flutter/tests/perftests/Android.mk +++ b/engine/src/flutter/tests/perftests/Android.mk @@ -17,7 +17,12 @@ LOCAL_PATH := $(call my-dir) perftest_src_files := \ + ../util/FileUtils.cpp \ + ../util/UnicodeUtils.cpp \ FontLanguage.cpp \ + GraphemeBreak.cpp \ + Hyphenator.cpp \ + WordBreaker.cpp \ main.cpp include $(CLEAR_VARS) @@ -25,7 +30,11 @@ LOCAL_MODULE := minikin_perftests LOCAL_CPPFLAGS := -Werror -Wall -Wextra LOCAL_SRC_FILES := $(perftest_src_files) LOCAL_STATIC_LIBRARIES := libminikin +LOCAL_SHARED_LIBRARIES := \ + libicuuc \ + liblog LOCAL_C_INCLUDES := \ + $(LOCAL_PATH)/../ \ $(LOCAL_PATH)/../../libs/minikin \ external/harfbuzz_ng/src include $(BUILD_NATIVE_BENCHMARK) diff --git a/engine/src/flutter/tests/perftests/GraphemeBreak.cpp b/engine/src/flutter/tests/perftests/GraphemeBreak.cpp new file mode 100644 index 0000000000..4db8f75d3d --- /dev/null +++ b/engine/src/flutter/tests/perftests/GraphemeBreak.cpp @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2016 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 + +#include + +#include "minikin/GraphemeBreak.h" +#include "util/UnicodeUtils.h" + +namespace minikin { + +const char* ASCII_TEST_STR = "'L' 'o' 'r' 'e' 'm' ' ' 'i' 'p' 's' 'u' 'm' '.'"; +// U+261D: WHITE UP POINTING INDEX +// U+1F3FD: EMOJI MODIFIER FITZPATRICK TYPE-4 +const char* EMOJI_TEST_STR = "U+261D U+1F3FD U+261D U+1F3FD U+261D U+1F3FD U+261D U+1F3FD"; +// U+1F1FA: REGIONAL INDICATOR SYMBOL LETTER U +// U+1F1F8: REGIONAL INDICATOR SYMBOL LETTER S +const char* FLAGS_TEST_STR = "U+1F1FA U+1F1F8 U+1F1FA U+1F1F8 U+1F1FA U+1F1F8"; + +// TODO: Migrate BENCHMARK_CAPTURE for parameterizing. +static void BM_GraphemeBreak_Ascii(benchmark::State& state) { + size_t result_size; + uint16_t buffer[12]; + ParseUnicode(buffer, 12, ASCII_TEST_STR, &result_size, nullptr); + LOG_ALWAYS_FATAL_IF(result_size != 12); + const size_t testIndex = state.range_x(); + while (state.KeepRunning()) { + GraphemeBreak::isGraphemeBreak(buffer, 0, result_size, testIndex); + } +} +BENCHMARK(BM_GraphemeBreak_Ascii) + ->Arg(0) // Begining of the text. + ->Arg(1) // Middle of the text. + ->Arg(12); // End of the text. + +static void BM_GraphemeBreak_Emoji(benchmark::State& state) { + size_t result_size; + uint16_t buffer[12]; + ParseUnicode(buffer, 12, EMOJI_TEST_STR, &result_size, nullptr); + LOG_ALWAYS_FATAL_IF(result_size != 12); + const size_t testIndex = state.range_x(); + while (state.KeepRunning()) { + GraphemeBreak::isGraphemeBreak(buffer, 0, result_size, testIndex); + } +} +BENCHMARK(BM_GraphemeBreak_Emoji) + ->Arg(1) // Middle of emoji modifier sequence. + ->Arg(2) // Middle of the surrogate pairs. + ->Arg(3); // After emoji modifier sequence. Here is boundary of grapheme cluster. + +static void BM_GraphemeBreak_Emoji_Flags(benchmark::State& state) { + size_t result_size; + uint16_t buffer[12]; + ParseUnicode(buffer, 12, FLAGS_TEST_STR, &result_size, nullptr); + LOG_ALWAYS_FATAL_IF(result_size != 12); + const size_t testIndex = state.range_x(); + while (state.KeepRunning()) { + GraphemeBreak::isGraphemeBreak(buffer, 0, result_size, testIndex); + } +} +BENCHMARK(BM_GraphemeBreak_Emoji_Flags) + ->Arg(2) // Middle of flag sequence. + ->Arg(4) // After flag sequence. Here is boundary of grapheme cluster. + ->Arg(10); // Middle of 3rd flag sequence. + +} // namespace minikin diff --git a/engine/src/flutter/tests/perftests/Hyphenator.cpp b/engine/src/flutter/tests/perftests/Hyphenator.cpp new file mode 100644 index 0000000000..692e06d2bf --- /dev/null +++ b/engine/src/flutter/tests/perftests/Hyphenator.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2016 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 + +#include +#include +#include + +namespace minikin { + +const char* enUsHyph = "/system/usr/hyphen-data/hyph-en-us.hyb"; + +static void BM_Hyphenator_short_word(benchmark::State& state) { + Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(enUsHyph).data()); + std::vector word = utf8ToUtf16("hyphen"); + std::vector result; + while (state.KeepRunning()) { + hyphenator->hyphenate(&result, word.data(), word.size()); + } + Hyphenator::loadBinary(nullptr); +} + +// TODO: Use BENCHMARK_CAPTURE for parametrise. +BENCHMARK(BM_Hyphenator_short_word); + +static void BM_Hyphenator_long_word(benchmark::State& state) { + Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(enUsHyph).data()); + std::vector word = utf8ToUtf16( + "Pneumonoultramicroscopicsilicovolcanoconiosis"); + std::vector result; + while (state.KeepRunning()) { + hyphenator->hyphenate(&result, word.data(), word.size()); + } + Hyphenator::loadBinary(nullptr); +} + +// TODO: Use BENCHMARK_CAPTURE for parametrise. +BENCHMARK(BM_Hyphenator_long_word); + +// TODO: Add more tests for other languages. + +} // namespace minikin diff --git a/engine/src/flutter/tests/perftests/WordBreaker.cpp b/engine/src/flutter/tests/perftests/WordBreaker.cpp new file mode 100644 index 0000000000..6758cf97e5 --- /dev/null +++ b/engine/src/flutter/tests/perftests/WordBreaker.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2016 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 + +#include "minikin/WordBreaker.h" +#include "util/UnicodeUtils.h" + +namespace minikin { + +static void BM_WordBreaker_English(benchmark::State& state) { + const char* kLoremIpsum = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do " + "eiusmod tempor incididunt ut labore et dolore magna aliqua."; + + WordBreaker wb; + wb.setLocale(icu::Locale::getEnglish()); + std::vector text = utf8ToUtf16(kLoremIpsum); + while (state.KeepRunning()) { + wb.setText(text.data(), text.size()); + while (wb.next() != -1) {} + } +} +BENCHMARK(BM_WordBreaker_English); + +// TODO: Add more tests for other languages. + +} // namespace minikin diff --git a/engine/src/flutter/tests/perftests/main.cpp b/engine/src/flutter/tests/perftests/main.cpp index e39c7f8838..e6f9d14cda 100644 --- a/engine/src/flutter/tests/perftests/main.cpp +++ b/engine/src/flutter/tests/perftests/main.cpp @@ -15,4 +15,32 @@ */ #include -BENCHMARK_MAIN(); +#include + +#include +#include + +#include +#include +#include + +int main(int argc, char** argv) { + const char* fn = "/system/usr/icu/" U_ICUDATA_NAME ".dat"; + int fd = open(fn, O_RDONLY); + LOG_ALWAYS_FATAL_IF(fd == -1); + struct stat st; + LOG_ALWAYS_FATAL_IF(fstat(fd, &st) != 0); + void* data = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0); + + UErrorCode errorCode = U_ZERO_ERROR; + udata_setCommonData(data, &errorCode); + LOG_ALWAYS_FATAL_IF(U_FAILURE(errorCode)); + u_init(&errorCode); + LOG_ALWAYS_FATAL_IF(U_FAILURE(errorCode)); + + benchmark::Initialize(&argc, argv); + benchmark::RunSpecifiedBenchmarks(); + + u_cleanup(); + return 0; +} diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index 885127199d..b43e3c8570 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -81,6 +81,7 @@ LOCAL_SRC_FILES += \ MinikinInternalTest.cpp \ GraphemeBreakTests.cpp \ LayoutUtilsTest.cpp \ + UnicodeUtilsTest.cpp \ WordBreakerTests.cpp LOCAL_C_INCLUDES := \ diff --git a/engine/src/flutter/tests/unittest/UnicodeUtilsTest.cpp b/engine/src/flutter/tests/unittest/UnicodeUtilsTest.cpp new file mode 100644 index 0000000000..99327235c5 --- /dev/null +++ b/engine/src/flutter/tests/unittest/UnicodeUtilsTest.cpp @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2016 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 + +#include "UnicodeUtils.h" + +namespace minikin { + +TEST(UnicodeUtils, parse) { + const size_t BUF_SIZE = 256; + uint16_t buf[BUF_SIZE]; + size_t offset; + size_t size; + ParseUnicode(buf, BUF_SIZE, "U+000D U+1F431 | 'a'", &size, &offset); + EXPECT_EQ(size, 4u); + EXPECT_EQ(offset, 3u); + EXPECT_EQ(buf[0], 0x000D); + EXPECT_EQ(buf[1], 0xD83D); + EXPECT_EQ(buf[2], 0xDC31); + EXPECT_EQ(buf[3], 'a'); +} + +} // namespace minikin diff --git a/engine/src/flutter/tests/util/FileUtils.cpp b/engine/src/flutter/tests/util/FileUtils.cpp new file mode 100644 index 0000000000..dfe15225dd --- /dev/null +++ b/engine/src/flutter/tests/util/FileUtils.cpp @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2016 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 + +#include +#include + +#include +#include + +std::vector readWholeFile(const std::string& filePath) { + FILE* fp = fopen(filePath.c_str(), "r"); + LOG_ALWAYS_FATAL_IF(fp == nullptr); + struct stat st; + LOG_ALWAYS_FATAL_IF(fstat(fileno(fp), &st) != 0); + + std::vector result(st.st_size); + LOG_ALWAYS_FATAL_IF(fread(result.data(), 1, st.st_size, fp) != st.st_size); + fclose(fp); + return result; +} diff --git a/engine/src/flutter/tests/util/FileUtils.h b/engine/src/flutter/tests/util/FileUtils.h new file mode 100644 index 0000000000..1e66d1b701 --- /dev/null +++ b/engine/src/flutter/tests/util/FileUtils.h @@ -0,0 +1,18 @@ +/* + * 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. + */ + +std::vector readWholeFile(const std::string& filePath); + diff --git a/engine/src/flutter/tests/util/UnicodeUtils.cpp b/engine/src/flutter/tests/util/UnicodeUtils.cpp index bb652ff63d..2f811daec2 100644 --- a/engine/src/flutter/tests/util/UnicodeUtils.cpp +++ b/engine/src/flutter/tests/util/UnicodeUtils.cpp @@ -14,9 +14,12 @@ * limitations under the License. */ -#include #include +#include #include +#include +#include +#include namespace minikin { @@ -32,33 +35,35 @@ void ParseUnicode(uint16_t* buf, size_t buf_size, const char* src, size_t* resul switch (src[input_ix]) { case '\'': // single ASCII char - ASSERT_LT(src[input_ix], 0x80); + LOG_ALWAYS_FATAL_IF(static_cast(src[input_ix]) >= 0x80); input_ix++; - ASSERT_NE(src[input_ix], 0); - ASSERT_LT(output_ix, buf_size); + LOG_ALWAYS_FATAL_IF(src[input_ix] == 0); + LOG_ALWAYS_FATAL_IF(output_ix >= buf_size); buf[output_ix++] = (uint16_t)src[input_ix++]; - ASSERT_EQ(src[input_ix], '\''); + LOG_ALWAYS_FATAL_IF(src[input_ix] != '\''); input_ix++; break; case 'u': case 'U': { // Unicode codepoint in hex syntax input_ix++; - ASSERT_EQ(src[input_ix], '+'); + LOG_ALWAYS_FATAL_IF(src[input_ix] != '+'); input_ix++; char* endptr = (char*)src + input_ix; unsigned long int codepoint = strtoul(src + input_ix, &endptr, 16); size_t num_hex_digits = endptr - (src + input_ix); - ASSERT_GE(num_hex_digits, 4u); // also triggers on invalid number syntax, digits = 0 - ASSERT_LE(num_hex_digits, 6u); - ASSERT_LE(codepoint, 0x10FFFFu); + + // also triggers on invalid number syntax, digits = 0 + LOG_ALWAYS_FATAL_IF(num_hex_digits < 4u); + LOG_ALWAYS_FATAL_IF(num_hex_digits > 6u); + LOG_ALWAYS_FATAL_IF(codepoint > 0x10FFFFu); input_ix += num_hex_digits; if (U16_LENGTH(codepoint) == 1) { - ASSERT_LE(output_ix + 1, buf_size); + LOG_ALWAYS_FATAL_IF(output_ix + 1 > buf_size); buf[output_ix++] = codepoint; } else { // UTF-16 encoding - ASSERT_LE(output_ix + 2, buf_size); + LOG_ALWAYS_FATAL_IF(output_ix + 2 > buf_size); buf[output_ix++] = U16_LEAD(codepoint); buf[output_ix++] = U16_TRAIL(codepoint); } @@ -68,33 +73,36 @@ void ParseUnicode(uint16_t* buf, size_t buf_size, const char* src, size_t* resul input_ix++; break; case '|': - ASSERT_FALSE(seen_offset); - ASSERT_NE(offset, nullptr); + LOG_ALWAYS_FATAL_IF(seen_offset); + LOG_ALWAYS_FATAL_IF(offset == nullptr); *offset = output_ix; seen_offset = true; input_ix++; break; default: - FAIL(); // unexpected character + LOG_ALWAYS_FATAL("Unexpected Character"); } } - ASSERT_NE(result_size, nullptr); + LOG_ALWAYS_FATAL_IF(result_size == nullptr); *result_size = output_ix; - ASSERT_TRUE(seen_offset || offset == nullptr); + LOG_ALWAYS_FATAL_IF(!seen_offset && offset != nullptr); } -TEST(UnicodeUtils, parse) { - const size_t BUF_SIZE = 256; - uint16_t buf[BUF_SIZE]; - size_t offset; - size_t size; - ParseUnicode(buf, BUF_SIZE, "U+000D U+1F431 | 'a'", &size, &offset); - EXPECT_EQ(size, 4u); - EXPECT_EQ(offset, 3u); - EXPECT_EQ(buf[0], 0x000D); - EXPECT_EQ(buf[1], 0xD83D); - EXPECT_EQ(buf[2], 0xDC31); - EXPECT_EQ(buf[3], 'a'); +std::vector utf8ToUtf16(const std::string& text) { + std::vector result; + int32_t i = 0; + const int32_t textLength = static_cast(text.size()); + uint32_t c = 0; + while (i < textLength) { + U8_NEXT(text.c_str(), i, textLength, c); + if (U16_LENGTH(c) == 1) { + result.push_back(c); + } else { + result.push_back(U16_LEAD(c)); + result.push_back(U16_TRAIL(c)); + } + } + return result; } } // namespace minikin diff --git a/engine/src/flutter/tests/util/UnicodeUtils.h b/engine/src/flutter/tests/util/UnicodeUtils.h index 64b90c91b1..571be7a31e 100644 --- a/engine/src/flutter/tests/util/UnicodeUtils.h +++ b/engine/src/flutter/tests/util/UnicodeUtils.h @@ -19,4 +19,7 @@ namespace minikin { void ParseUnicode(uint16_t* buf, size_t buf_size, const char* src, size_t* result_size, size_t* offset); +// Converts UTF-8 to UTF-16. +std::vector utf8ToUtf16(const std::string& text); + } // namespace minikin From a89c08ae496e402b46a71e2f86941c1f3968b2a5 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 16 Jun 2016 16:58:14 +0900 Subject: [PATCH 188/364] Introduce FontCollection perftest This CL introduces performance tests for FontCollection. To support TTC file in /system/fonts, this CL also extends FontTestUtils Bug:29142734 Change-Id: I9d8ad24ca55f61031b85623ab7c26234239e4f41 --- engine/src/flutter/tests/perftests/Android.mk | 17 +++- .../tests/perftests/FontCollection.cpp | 90 +++++++++++++++++++ .../src/flutter/tests/util/FontTestUtils.cpp | 33 ++++--- .../flutter/tests/util/MinikinFontForTest.cpp | 9 ++ .../flutter/tests/util/MinikinFontForTest.h | 1 + 5 files changed, 137 insertions(+), 13 deletions(-) create mode 100644 engine/src/flutter/tests/perftests/FontCollection.cpp diff --git a/engine/src/flutter/tests/perftests/Android.mk b/engine/src/flutter/tests/perftests/Android.mk index d3ed600b6e..de5769c743 100644 --- a/engine/src/flutter/tests/perftests/Android.mk +++ b/engine/src/flutter/tests/perftests/Android.mk @@ -18,7 +18,10 @@ LOCAL_PATH := $(call my-dir) perftest_src_files := \ ../util/FileUtils.cpp \ + ../util/FontTestUtils.cpp \ + ../util/MinikinFontForTest.cpp \ ../util/UnicodeUtils.cpp \ + FontCollection.cpp \ FontLanguage.cpp \ GraphemeBreak.cpp \ Hyphenator.cpp \ @@ -29,12 +32,20 @@ include $(CLEAR_VARS) LOCAL_MODULE := minikin_perftests LOCAL_CPPFLAGS := -Werror -Wall -Wextra LOCAL_SRC_FILES := $(perftest_src_files) -LOCAL_STATIC_LIBRARIES := libminikin +LOCAL_STATIC_LIBRARIES := \ + libminikin \ + libxml2 + LOCAL_SHARED_LIBRARIES := \ + libharfbuzz_ng \ libicuuc \ - liblog + liblog \ + libskia + LOCAL_C_INCLUDES := \ $(LOCAL_PATH)/../ \ $(LOCAL_PATH)/../../libs/minikin \ - external/harfbuzz_ng/src + external/harfbuzz_ng/src \ + external/libxml2/include + include $(BUILD_NATIVE_BENCHMARK) diff --git a/engine/src/flutter/tests/perftests/FontCollection.cpp b/engine/src/flutter/tests/perftests/FontCollection.cpp new file mode 100644 index 0000000000..490f5d85fe --- /dev/null +++ b/engine/src/flutter/tests/perftests/FontCollection.cpp @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2016 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 + +#include +#include +#include +#include +#include + +namespace minikin { + +const char* SYSTEM_FONT_PATH = "/system/fonts/"; +const char* SYSTEM_FONT_XML = "/system/etc/fonts.xml"; + +static void BM_FontCollection_hasVariationSelector(benchmark::State& state) { + MinikinAutoUnref collection( + getFontCollection(SYSTEM_FONT_PATH, SYSTEM_FONT_XML)); + + uint32_t baseCp = state.range_x(); + uint32_t vsCp = state.range_y(); + + char titleBuffer[64]; + snprintf(titleBuffer, 64, "hasVariationSelector U+%04X,U+%04X", baseCp, vsCp); + state.SetLabel(titleBuffer); + + while (state.KeepRunning()) { + collection->hasVariationSelector(baseCp, vsCp); + } +} + +// TODO: Rewrite with BENCHMARK_CAPTURE for better test name. +BENCHMARK(BM_FontCollection_hasVariationSelector) + ->ArgPair(0x2708, 0xFE0F) + ->ArgPair(0x2708, 0xFE0E) + ->ArgPair(0x3402, 0xE0100); + +struct ItemizeTestCases { + std::string itemizeText; + std::string languageTag; + std::string labelText; +} ITEMIZE_TEST_CASES[] = { + { "'A' 'n' 'd' 'r' 'o' 'i' 'd'", "en", "English" }, + { "U+4E16", "zh-Hans", "CJK Ideograph" }, + { "U+4E16", "zh-Hans,zh-Hant,ja,en,es,pt,fr,de", "CJK Ideograph with many language fallback" }, + { "U+3402 U+E0100", "ja", "CJK Ideograph with variation selector" }, + { "'A' 'n' U+0E1A U+0E31 U+0645 U+062D U+0648", "en", "Mixture of English, Thai and Arabic" }, + { "U+2708 U+FE0E", "en", "Emoji with variation selector" }, + { "U+0031 U+FE0F U+20E3", "en", "KEYCAP" }, +}; + +static void BM_FontCollection_itemize(benchmark::State& state) { + MinikinAutoUnref collection( + getFontCollection(SYSTEM_FONT_PATH, SYSTEM_FONT_XML)); + + size_t testIndex = state.range_x(); + state.SetLabel("Itemize: " + ITEMIZE_TEST_CASES[testIndex].labelText); + + uint16_t buffer[64]; + size_t utf16_length = 0; + ParseUnicode( + buffer, 64, ITEMIZE_TEST_CASES[testIndex].itemizeText.c_str(), &utf16_length, nullptr); + std::vector result; + FontStyle style(FontStyle::registerLanguageList(ITEMIZE_TEST_CASES[testIndex].languageTag)); + + android::AutoMutex _l(gMinikinLock); + while (state.KeepRunning()) { + result.clear(); + collection->itemize(buffer, utf16_length, style, &result); + } +} + +// TODO: Rewrite with BENCHMARK_CAPTURE once it is available in Android. +BENCHMARK(BM_FontCollection_itemize) + ->Arg(0)->Arg(1)->Arg(2)->Arg(3)->Arg(4)->Arg(5)->Arg(6); + +} // namespace minikin diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index eaf3610df2..246c87231a 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -47,10 +47,14 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { } xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); - uint32_t langId = FontStyle::registerLanguageList( - std::string((const char*)lang, xmlStrlen(lang))); - - FontFamily* family = new FontFamily(langId, variant); + FontFamily* family; + if (lang == nullptr) { + family = new FontFamily(variant); + } else { + uint32_t langId = FontStyle::registerLanguageList( + std::string((const char*)lang, xmlStrlen(lang))); + family = new FontFamily(langId, variant); + } for (xmlNode* fontNode = familyNode->children; fontNode; fontNode = fontNode->next) { if (xmlStrcmp(fontNode->name, (const xmlChar*)"font") != 0) { @@ -60,18 +64,27 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { int weight = atoi((const char*)(xmlGetProp(fontNode, (const xmlChar*)"weight"))) / 100; bool italic = xmlStrcmp( xmlGetProp(fontNode, (const xmlChar*)"style"), (const xmlChar*)"italic") == 0; + xmlChar* index = xmlGetProp(familyNode, (const xmlChar*)"index"); xmlChar* fontFileName = xmlNodeListGetString(doc, fontNode->xmlChildrenNode, 1); std::string fontPath = fontDir + std::string((const char*)fontFileName); xmlFree(fontFileName); - LOG_ALWAYS_FATAL_IF(access(fontPath.c_str(), R_OK) != 0, - "%s is not found", fontPath.c_str()); + if (access(fontPath.c_str(), R_OK) != 0) { + ALOGW("%s is not found.", fontPath.c_str()); + continue; + } - MinikinAutoUnref - minikinFont(MinikinFontForTest::createFromFile(fontPath)); - - family->addFont(minikinFont.get(), FontStyle(weight, italic)); + if (index == nullptr) { + MinikinAutoUnref + minikinFont(MinikinFontForTest::createFromFile(fontPath)); + family->addFont(minikinFont.get(), FontStyle(weight, italic)); + } else { + MinikinAutoUnref + minikinFont(MinikinFontForTest::createFromFileWithIndex(fontPath, + atoi((const char*)index))); + family->addFont(minikinFont.get(), FontStyle(weight, italic)); + } } families.push_back(family); } diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index 93e3e66d2d..392d5b2ea5 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -32,6 +32,15 @@ MinikinFontForTest* MinikinFontForTest::createFromFile(const std::string& font_p return font; } +// static +MinikinFontForTest* MinikinFontForTest::createFromFileWithIndex(const std::string& font_path, + int index) { + SkTypeface* typeface = SkTypeface::CreateFromFile(font_path.c_str(), index); + MinikinFontForTest* font = new MinikinFontForTest(font_path, typeface); + SkSafeUnref(typeface); + return font; +} + MinikinFontForTest::MinikinFontForTest(const std::string& font_path, SkTypeface* typeface) : MinikinFont(typeface->uniqueID()), mTypeface(typeface), diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index bfd8421525..7b5322ca0b 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -31,6 +31,7 @@ public: // Helper function for creating MinikinFontForTest instance from font file. // Calller need to unref returned object. static MinikinFontForTest* createFromFile(const std::string& font_path); + static MinikinFontForTest* createFromFileWithIndex(const std::string& font_path, int index); // MinikinFont overrides. float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const; From cd8eea620534db54e34e2755c270b37c2248564b Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 28 Jun 2016 18:35:48 +0900 Subject: [PATCH 189/364] Fix build failure of minikin_perftest stat.st_size is off_t not size_t, so need to cast to size_t before compare it. Change-Id: I6b742746fbb9f254701fc91e515c293f93f912c5 --- engine/src/flutter/tests/util/FileUtils.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/tests/util/FileUtils.cpp b/engine/src/flutter/tests/util/FileUtils.cpp index dfe15225dd..68cc45cf4d 100644 --- a/engine/src/flutter/tests/util/FileUtils.cpp +++ b/engine/src/flutter/tests/util/FileUtils.cpp @@ -29,7 +29,7 @@ std::vector readWholeFile(const std::string& filePath) { LOG_ALWAYS_FATAL_IF(fstat(fileno(fp), &st) != 0); std::vector result(st.st_size); - LOG_ALWAYS_FATAL_IF(fread(result.data(), 1, st.st_size, fp) != st.st_size); + LOG_ALWAYS_FATAL_IF(fread(result.data(), 1, st.st_size, fp) != static_cast(st.st_size)); fclose(fp); return result; } From dc6138ffeb80368d532f3b8f55b42f287e966170 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Fri, 8 Jul 2016 15:19:22 +0900 Subject: [PATCH 190/364] Add some gender balanced components in to the sticky whitelist. FEMALE SIGN(U+2640), MALE SIGN(U+2642), StAFF OF AESCULAPIUS(U+2695) will be used as the ZWJ sequenced in gender balanced emoji sequence. To be in the same run with ZWJ, mark these emoji as sticky chracters. With this fix, Female police officer sequence will be shown correctly regardless of VS16. Bug: 30026374 Change-Id: I503fc061eaa943d45208bb69e885151610c430ce --- .../flutter/libs/minikin/FontCollection.cpp | 5 +++- .../unittest/FontCollectionItemizeTest.cpp | 25 +++++++++++++++++++ 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 90b67d2550..d1a1924ae0 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -336,11 +336,14 @@ const uint32_t ZWJ = 0x200c; const uint32_t ZWNJ = 0x200d; const uint32_t HYPHEN = 0x2010; const uint32_t NB_HYPHEN = 0x2011; +const uint32_t FEMALE_SIGN = 0x2640; +const uint32_t MALE_SIGN = 0x2642; +const uint32_t STAFF_OF_AESCULAPIUS = 0x2695; // Characters where we want to continue using existing font run instead of // recomputing the best match in the fallback list. static const uint32_t stickyWhitelist[] = { '!', ',', '-', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, - HYPHEN, NB_HYPHEN }; + HYPHEN, NB_HYPHEN, FEMALE_SIGN, MALE_SIGN, STAFF_OF_AESCULAPIUS }; static bool isStickyWhitelisted(uint32_t c) { for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) { diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index b28820b1f8..367739683d 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -1367,4 +1367,29 @@ TEST_F(FontCollectionItemizeTest, itemize_PrivateUseArea) { EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); } +TEST_F(FontCollectionItemizeTest, itemize_genderBalancedEmoji) { + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + std::vector runs; + + const FontStyle kDefaultFontStyle; + + itemize(collection.get(), "U+1F469 U+200D U+1F373", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+1F469 U+200D U+2695 U+FE0F", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+1F469 U+200D U+2695", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(4, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); +} + } // namespace minikin From 9c9fda459efec0be097b122c6c2f39fd3edbc7a5 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 30 Jun 2016 16:48:45 +0900 Subject: [PATCH 191/364] Treat U+2695, U+2640, U+2642 as emoji characters. Bug: 29885295 Change-Id: I1bf191a46d05e7099265d863bae0523c50817d0b --- .../flutter/libs/minikin/FontCollection.cpp | 41 ++++++++++--------- .../flutter/libs/minikin/MinikinInternal.cpp | 5 +++ .../tests/unittest/FontCollectionTest.cpp | 14 +++++++ .../tests/unittest/GraphemeBreakTests.cpp | 11 +++++ 4 files changed, 52 insertions(+), 19 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index d1a1924ae0..97c206881f 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -40,7 +40,9 @@ static inline T max(T a, T b) { const uint32_t EMOJI_STYLE_VS = 0xFE0F; const uint32_t TEXT_STYLE_VS = 0xFE0E; -// See http://www.unicode.org/Public/9.0.0/ucd/StandardizedVariants-9.0.0d1.txt +// See http://www.unicode.org/Public/9.0.0/ucd/StandardizedVariants.txt +// U+2640, U+2642, U+2695 are now in emoji category but not listed in above file, so added them by +// manual. // Must be sorted. const uint32_t EMOJI_STYLE_VS_BASES[] = { 0x0023, 0x002A, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, @@ -48,24 +50,25 @@ const uint32_t EMOJI_STYLE_VS_BASES[] = { 0x21A9, 0x21AA, 0x231A, 0x231B, 0x2328, 0x23CF, 0x23ED, 0x23EE, 0x23EF, 0x23F1, 0x23F2, 0x23F8, 0x23F9, 0x23FA, 0x24C2, 0x25AA, 0x25AB, 0x25B6, 0x25C0, 0x25FB, 0x25FC, 0x25FD, 0x25FE, 0x2600, 0x2601, 0x2602, 0x2603, 0x2604, 0x260E, 0x2611, 0x2614, 0x2615, 0x2618, 0x261D, 0x2620, 0x2622, - 0x2623, 0x2626, 0x262A, 0x262E, 0x262F, 0x2638, 0x2639, 0x263A, 0x2648, 0x2649, 0x264A, 0x264B, - 0x264C, 0x264D, 0x264E, 0x264F, 0x2650, 0x2651, 0x2652, 0x2653, 0x2660, 0x2663, 0x2665, 0x2666, - 0x2668, 0x267B, 0x267F, 0x2692, 0x2693, 0x2694, 0x2696, 0x2697, 0x2699, 0x269B, 0x269C, 0x26A0, - 0x26A1, 0x26AA, 0x26AB, 0x26B0, 0x26B1, 0x26BD, 0x26BE, 0x26C4, 0x26C5, 0x26C8, 0x26CF, 0x26D1, - 0x26D3, 0x26D4, 0x26E9, 0x26EA, 0x26F0, 0x26F1, 0x26F2, 0x26F3, 0x26F4, 0x26F5, 0x26F7, 0x26F8, - 0x26F9, 0x26FA, 0x26FD, 0x2702, 0x2708, 0x2709, 0x270C, 0x270D, 0x270F, 0x2712, 0x2714, 0x2716, - 0x271D, 0x2721, 0x2733, 0x2734, 0x2744, 0x2747, 0x2757, 0x2763, 0x2764, 0x27A1, 0x2934, 0x2935, - 0x2B05, 0x2B06, 0x2B07, 0x2B1B, 0x2B1C, 0x2B50, 0x2B55, 0x3030, 0x303D, 0x3297, 0x3299, - 0x1F004, 0x1F170, 0x1F171, 0x1F17E, 0x1F17F, 0x1F202, 0x1F21A, 0x1F22F, 0x1F237, 0x1F321, - 0x1F324, 0x1F325, 0x1F326, 0x1F327, 0x1F328, 0x1F329, 0x1F32A, 0x1F32B, 0x1F32C, 0x1F336, - 0x1F37D, 0x1F396, 0x1F397, 0x1F399, 0x1F39A, 0x1F39B, 0x1F39E, 0x1F39F, 0x1F3CB, 0x1F3CC, - 0x1F3CD, 0x1F3CE, 0x1F3D4, 0x1F3D5, 0x1F3D6, 0x1F3D7, 0x1F3D8, 0x1F3D9, 0x1F3DA, 0x1F3DB, - 0x1F3DC, 0x1F3DD, 0x1F3DE, 0x1F3DF, 0x1F3F3, 0x1F3F5, 0x1F3F7, 0x1F43F, 0x1F441, 0x1F4FD, - 0x1F549, 0x1F54A, 0x1F56F, 0x1F570, 0x1F573, 0x1F574, 0x1F575, 0x1F576, 0x1F577, 0x1F578, - 0x1F579, 0x1F587, 0x1F58A, 0x1F58B, 0x1F58C, 0x1F58D, 0x1F590, 0x1F5A5, 0x1F5A8, 0x1F5B1, - 0x1F5B2, 0x1F5BC, 0x1F5C2, 0x1F5C3, 0x1F5C4, 0x1F5D1, 0x1F5D2, 0x1F5D3, 0x1F5DC, 0x1F5DD, - 0x1F5DE, 0x1F5E1, 0x1F5E3, 0x1F5E8, 0x1F5EF, 0x1F5F3, 0x1F5FA, 0x1F6CB, 0x1F6CD, 0x1F6CE, - 0x1F6CF, 0x1F6E0, 0x1F6E1, 0x1F6E2, 0x1F6E3, 0x1F6E4, 0x1F6E5, 0x1F6E9, 0x1F6F0, 0x1F6F3, + 0x2623, 0x2626, 0x262A, 0x262E, 0x262F, 0x2638, 0x2639, 0x263A, 0x2640, 0x2642, 0x2648, 0x2649, + 0x264A, 0x264B, 0x264C, 0x264D, 0x264E, 0x264F, 0x2650, 0x2651, 0x2652, 0x2653, 0x2660, 0x2663, + 0x2665, 0x2666, 0x2668, 0x267B, 0x267F, 0x2692, 0x2693, 0x2694, 0x2695, 0x2696, 0x2697, 0x2699, + 0x269B, 0x269C, 0x26A0, 0x26A1, 0x26AA, 0x26AB, 0x26B0, 0x26B1, 0x26BD, 0x26BE, 0x26C4, 0x26C5, + 0x26C8, 0x26CF, 0x26D1, 0x26D3, 0x26D4, 0x26E9, 0x26EA, 0x26F0, 0x26F1, 0x26F2, 0x26F3, 0x26F4, + 0x26F5, 0x26F7, 0x26F8, 0x26F9, 0x26FA, 0x26FD, 0x2702, 0x2708, 0x2709, 0x270C, 0x270D, 0x270F, + 0x2712, 0x2714, 0x2716, 0x271D, 0x2721, 0x2733, 0x2734, 0x2744, 0x2747, 0x2757, 0x2763, 0x2764, + 0x27A1, 0x2934, 0x2935, 0x2B05, 0x2B06, 0x2B07, 0x2B1B, 0x2B1C, 0x2B50, 0x2B55, 0x3030, 0x303D, + 0x3297, 0x3299, 0x1F004, 0x1F170, 0x1F171, 0x1F17E, 0x1F17F, 0x1F202, 0x1F21A, 0x1F22F, 0x1F237, + 0x1F321, 0x1F324, 0x1F325, 0x1F326, 0x1F327, 0x1F328, 0x1F329, 0x1F32A, 0x1F32B, 0x1F32C, + 0x1F336, 0x1F37D, 0x1F396, 0x1F397, 0x1F399, 0x1F39A, 0x1F39B, 0x1F39E, 0x1F39F, 0x1F3CB, + 0x1F3CC, 0x1F3CD, 0x1F3CE, 0x1F3D4, 0x1F3D5, 0x1F3D6, 0x1F3D7, 0x1F3D8, 0x1F3D9, 0x1F3DA, + 0x1F3DB, 0x1F3DC, 0x1F3DD, 0x1F3DE, 0x1F3DF, 0x1F3F3, 0x1F3F5, 0x1F3F7, 0x1F43F, 0x1F441, + 0x1F4FD, 0x1F549, 0x1F54A, 0x1F56F, 0x1F570, 0x1F573, 0x1F574, 0x1F575, 0x1F576, 0x1F577, + 0x1F578, 0x1F579, 0x1F587, 0x1F58A, 0x1F58B, 0x1F58C, 0x1F58D, 0x1F590, 0x1F5A5, 0x1F5A8, + 0x1F5B1, 0x1F5B2, 0x1F5BC, 0x1F5C2, 0x1F5C3, 0x1F5C4, 0x1F5D1, 0x1F5D2, 0x1F5D3, 0x1F5DC, + 0x1F5DD, 0x1F5DE, 0x1F5E1, 0x1F5E3, 0x1F5E8, 0x1F5EF, 0x1F5F3, 0x1F5FA, 0x1F6CB, 0x1F6CD, + 0x1F6CE, 0x1F6CF, 0x1F6E0, 0x1F6E1, 0x1F6E2, 0x1F6E3, 0x1F6E4, 0x1F6E5, 0x1F6E9, 0x1F6F0, + 0x1F6F3, }; static bool isEmojiStyleVSBase(uint32_t cp) { diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index b1ca2df669..dc15549b12 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -33,6 +33,11 @@ void assertMinikinLocked() { } bool isEmoji(uint32_t c) { + // U+2695 U+2640 U+2642 are not in emoji category in Unicode 9 but they are now emoji category. + // TODO: remove once emoji database is updated. + if (c == 0x2695 || c == 0x2640 || c == 0x2642) { + return true; + } const size_t length = sizeof(generated::EMOJI_LIST) / sizeof(generated::EMOJI_LIST[0]); return std::binary_search(generated::EMOJI_LIST, generated::EMOJI_LIST + length, c); } diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index 3f365be083..ef2da66b2b 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -105,6 +105,20 @@ TEST(FontCollectionTest, hasVariationSelectorTest_emoji) { // VS15/VS16 is only for emoji, should return false for not an emoji code point. EXPECT_FALSE(collection->hasVariationSelector(0x2229, 0xFE0E)); EXPECT_FALSE(collection->hasVariationSelector(0x2229, 0xFE0F)); + +} + +TEST(FontCollectionTest, newEmojiTest) { + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + + // U+2695, U+2640, U+2642 are not in emoji catrgory in Unicode 9 but they are now in emoji + // category. Should return true even if U+FE0E was appended. + // These three emojis are only avalilable in TextEmoji.ttf but U+2695 is excluded here since it + // is used in other tests. + EXPECT_TRUE(collection->hasVariationSelector(0x2640, 0xFE0E)); + EXPECT_FALSE(collection->hasVariationSelector(0x2640, 0xFE0F)); + EXPECT_TRUE(collection->hasVariationSelector(0x2642, 0xFE0E)); + EXPECT_FALSE(collection->hasVariationSelector(0x2642, 0xFE0F)); } } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp index 07ddf82ce6..d95fa31b1d 100644 --- a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp @@ -179,6 +179,17 @@ TEST(GraphemeBreak, emojiModifiers) { // rat is not an emoji modifer EXPECT_TRUE(IsBreak("U+1F466 | U+1F400")); // boy + rat + +} + +TEST(GraphemeBreak, genderBalancedEmoji) { + // U+1F469 is WOMAN, U+200D is ZWJ, U+1F4BC is BRIEFCASE. + EXPECT_FALSE(IsBreak("U+1F469 | U+200D U+1F4BC")); + EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+1F4BC")); + + // U+2695 has now emoji property, so should be part of ZWJ sequence. + EXPECT_FALSE(IsBreak("U+1F469 | U+200D U+2695")); + EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+2695")); } TEST(GraphemeBreak, offsets) { From 3d665c82d4b39e9ae44db22ca6569b3505ad3934 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Mon, 11 Jul 2016 17:28:44 +0900 Subject: [PATCH 192/364] Lookup glyph from color emoji font before and after ZWJ. Unicode recommends that the zwj sequences should be emoji presentation even if they don't have the proper U+FE0F. Thus always lookup the glyph for the code point before and after zwj as if they have a U+FE0F variation selector. Bug: 30056627 Change-Id: I03958a92337eaba4a8dd9c5be824b2665aa4a103 --- .../flutter/libs/minikin/FontCollection.cpp | 18 +++++++++++------- .../unittest/FontCollectionItemizeTest.cpp | 12 +++++++++--- 2 files changed, 20 insertions(+), 10 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 97c206881f..687c130268 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -335,18 +335,15 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, } const uint32_t NBSP = 0xa0; -const uint32_t ZWJ = 0x200c; -const uint32_t ZWNJ = 0x200d; +const uint32_t ZWJ = 0x200d; +const uint32_t ZWNJ = 0x200c; const uint32_t HYPHEN = 0x2010; const uint32_t NB_HYPHEN = 0x2011; -const uint32_t FEMALE_SIGN = 0x2640; -const uint32_t MALE_SIGN = 0x2642; -const uint32_t STAFF_OF_AESCULAPIUS = 0x2695; // Characters where we want to continue using existing font run instead of // recomputing the best match in the fallback list. static const uint32_t stickyWhitelist[] = { '!', ',', '-', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, - HYPHEN, NB_HYPHEN, FEMALE_SIGN, MALE_SIGN, STAFF_OF_AESCULAPIUS }; + HYPHEN, NB_HYPHEN }; static bool isStickyWhitelisted(uint32_t c) { for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) { @@ -432,8 +429,15 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } if (!shouldContinueRun) { - FontFamily* family = getFamilyForChar(ch, isVariationSelector(nextCh) ? nextCh : 0, + FontFamily* family; + if ((prevCh == ZWJ || nextCh == ZWJ) && isEmoji(ch)) { + // Treat emoji before and after ZWJ as emoji presentation. + family = getFamilyForChar(ch, EMOJI_STYLE_VS, langListId, variant); + } else { + family = getFamilyForChar(ch, isVariationSelector(nextCh) ? nextCh : 0, langListId, variant); + } + if (utf16Pos == 0 || family != lastFamily) { size_t start = utf16Pos; // Workaround for combining marks and emoji modifiers until we implement diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 367739683d..84415d92e6 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -1217,7 +1217,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); - // U+26FA U+FE0E is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F + // U+26FA U+FE0E is specified but ColorTextMixedEmojiFont has a variation sequence U+26FA U+FE0F // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. itemize(collection.get(), "U+26FA U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); @@ -1299,9 +1299,9 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); - // U+26F9 U+FE0F is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F + // U+26F8 U+FE0F is specified but ColorTextMixedEmojiFont has a variation sequence U+26F8 U+FE0F // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. - itemize(collection.get(), "U+26F9 U+FE0F", kDefaultFontStyle, &runs); + itemize(collection.get(), "U+26F8 U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1390,6 +1390,12 @@ TEST_F(FontCollectionItemizeTest, itemize_genderBalancedEmoji) { EXPECT_EQ(0, runs[0].start); EXPECT_EQ(4, runs[0].end); EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+26F9 U+200D U+2695", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(3, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); } } // namespace minikin From 2fd057eb7048f3739f3135b2cf108ef5aca42a31 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Fri, 8 Jul 2016 15:19:22 +0900 Subject: [PATCH 193/364] Add some gender balanced components in to the sticky whitelist. FEMALE SIGN(U+2640), MALE SIGN(U+2642), StAFF OF AESCULAPIUS(U+2695) will be used as the ZWJ sequenced in gender balanced emoji sequence. To be in the same run with ZWJ, mark these emoji as sticky chracters. With this fix, Female police officer sequence will be shown correctly regardless of VS16. Bug: 30026374 Change-Id: I503fc061eaa943d45208bb69e885151610c430ce --- .../flutter/libs/minikin/FontCollection.cpp | 5 +++- .../tests/FontCollectionItemizeTest.cpp | 25 +++++++++++++++++++ 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index b1b0aaf95f..78f102e17c 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -336,11 +336,14 @@ const uint32_t ZWJ = 0x200c; const uint32_t ZWNJ = 0x200d; const uint32_t HYPHEN = 0x2010; const uint32_t NB_HYPHEN = 0x2011; +const uint32_t FEMALE_SIGN = 0x2640; +const uint32_t MALE_SIGN = 0x2642; +const uint32_t STAFF_OF_AESCULAPIUS = 0x2695; // Characters where we want to continue using existing font run instead of // recomputing the best match in the fallback list. static const uint32_t stickyWhitelist[] = { '!', ',', '-', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, - HYPHEN, NB_HYPHEN }; + HYPHEN, NB_HYPHEN, FEMALE_SIGN, MALE_SIGN, STAFF_OF_AESCULAPIUS }; static bool isStickyWhitelisted(uint32_t c) { for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) { diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 8ad9472490..468b4a28fa 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -1372,3 +1372,28 @@ TEST_F(FontCollectionItemizeTest, itemize_PrivateUseArea) { EXPECT_EQ(4, runs[0].end); EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); } + +TEST_F(FontCollectionItemizeTest, itemize_genderBalancedEmoji) { + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + std::vector runs; + + const FontStyle kDefaultFontStyle; + + itemize(collection.get(), "U+1F469 U+200D U+1F373", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+1F469 U+200D U+2695 U+FE0F", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(5, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+1F469 U+200D U+2695", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(4, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); +} From c5d673d42309ef91429ba5f6356b1fae22b2d680 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 30 Jun 2016 16:48:45 +0900 Subject: [PATCH 194/364] Treat U+2695, U+2640, U+2642 as emoji characters. Bug: 29885295 Change-Id: I1bf191a46d05e7099265d863bae0523c50817d0b --- .../flutter/libs/minikin/FontCollection.cpp | 41 ++++++++++--------- .../flutter/libs/minikin/MinikinInternal.cpp | 5 +++ .../src/flutter/tests/FontCollectionTest.cpp | 14 +++++++ .../src/flutter/tests/GraphemeBreakTests.cpp | 11 +++++ 4 files changed, 52 insertions(+), 19 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 78f102e17c..33418ab1b5 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -40,7 +40,9 @@ static inline T max(T a, T b) { const uint32_t EMOJI_STYLE_VS = 0xFE0F; const uint32_t TEXT_STYLE_VS = 0xFE0E; -// See http://www.unicode.org/Public/9.0.0/ucd/StandardizedVariants-9.0.0d1.txt +// See http://www.unicode.org/Public/9.0.0/ucd/StandardizedVariants.txt +// U+2640, U+2642, U+2695 are now in emoji category but not listed in above file, so added them by +// manual. // Must be sorted. const uint32_t EMOJI_STYLE_VS_BASES[] = { 0x0023, 0x002A, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, @@ -48,24 +50,25 @@ const uint32_t EMOJI_STYLE_VS_BASES[] = { 0x21A9, 0x21AA, 0x231A, 0x231B, 0x2328, 0x23CF, 0x23ED, 0x23EE, 0x23EF, 0x23F1, 0x23F2, 0x23F8, 0x23F9, 0x23FA, 0x24C2, 0x25AA, 0x25AB, 0x25B6, 0x25C0, 0x25FB, 0x25FC, 0x25FD, 0x25FE, 0x2600, 0x2601, 0x2602, 0x2603, 0x2604, 0x260E, 0x2611, 0x2614, 0x2615, 0x2618, 0x261D, 0x2620, 0x2622, - 0x2623, 0x2626, 0x262A, 0x262E, 0x262F, 0x2638, 0x2639, 0x263A, 0x2648, 0x2649, 0x264A, 0x264B, - 0x264C, 0x264D, 0x264E, 0x264F, 0x2650, 0x2651, 0x2652, 0x2653, 0x2660, 0x2663, 0x2665, 0x2666, - 0x2668, 0x267B, 0x267F, 0x2692, 0x2693, 0x2694, 0x2696, 0x2697, 0x2699, 0x269B, 0x269C, 0x26A0, - 0x26A1, 0x26AA, 0x26AB, 0x26B0, 0x26B1, 0x26BD, 0x26BE, 0x26C4, 0x26C5, 0x26C8, 0x26CF, 0x26D1, - 0x26D3, 0x26D4, 0x26E9, 0x26EA, 0x26F0, 0x26F1, 0x26F2, 0x26F3, 0x26F4, 0x26F5, 0x26F7, 0x26F8, - 0x26F9, 0x26FA, 0x26FD, 0x2702, 0x2708, 0x2709, 0x270C, 0x270D, 0x270F, 0x2712, 0x2714, 0x2716, - 0x271D, 0x2721, 0x2733, 0x2734, 0x2744, 0x2747, 0x2757, 0x2763, 0x2764, 0x27A1, 0x2934, 0x2935, - 0x2B05, 0x2B06, 0x2B07, 0x2B1B, 0x2B1C, 0x2B50, 0x2B55, 0x3030, 0x303D, 0x3297, 0x3299, - 0x1F004, 0x1F170, 0x1F171, 0x1F17E, 0x1F17F, 0x1F202, 0x1F21A, 0x1F22F, 0x1F237, 0x1F321, - 0x1F324, 0x1F325, 0x1F326, 0x1F327, 0x1F328, 0x1F329, 0x1F32A, 0x1F32B, 0x1F32C, 0x1F336, - 0x1F37D, 0x1F396, 0x1F397, 0x1F399, 0x1F39A, 0x1F39B, 0x1F39E, 0x1F39F, 0x1F3CB, 0x1F3CC, - 0x1F3CD, 0x1F3CE, 0x1F3D4, 0x1F3D5, 0x1F3D6, 0x1F3D7, 0x1F3D8, 0x1F3D9, 0x1F3DA, 0x1F3DB, - 0x1F3DC, 0x1F3DD, 0x1F3DE, 0x1F3DF, 0x1F3F3, 0x1F3F5, 0x1F3F7, 0x1F43F, 0x1F441, 0x1F4FD, - 0x1F549, 0x1F54A, 0x1F56F, 0x1F570, 0x1F573, 0x1F574, 0x1F575, 0x1F576, 0x1F577, 0x1F578, - 0x1F579, 0x1F587, 0x1F58A, 0x1F58B, 0x1F58C, 0x1F58D, 0x1F590, 0x1F5A5, 0x1F5A8, 0x1F5B1, - 0x1F5B2, 0x1F5BC, 0x1F5C2, 0x1F5C3, 0x1F5C4, 0x1F5D1, 0x1F5D2, 0x1F5D3, 0x1F5DC, 0x1F5DD, - 0x1F5DE, 0x1F5E1, 0x1F5E3, 0x1F5E8, 0x1F5EF, 0x1F5F3, 0x1F5FA, 0x1F6CB, 0x1F6CD, 0x1F6CE, - 0x1F6CF, 0x1F6E0, 0x1F6E1, 0x1F6E2, 0x1F6E3, 0x1F6E4, 0x1F6E5, 0x1F6E9, 0x1F6F0, 0x1F6F3, + 0x2623, 0x2626, 0x262A, 0x262E, 0x262F, 0x2638, 0x2639, 0x263A, 0x2640, 0x2642, 0x2648, 0x2649, + 0x264A, 0x264B, 0x264C, 0x264D, 0x264E, 0x264F, 0x2650, 0x2651, 0x2652, 0x2653, 0x2660, 0x2663, + 0x2665, 0x2666, 0x2668, 0x267B, 0x267F, 0x2692, 0x2693, 0x2694, 0x2695, 0x2696, 0x2697, 0x2699, + 0x269B, 0x269C, 0x26A0, 0x26A1, 0x26AA, 0x26AB, 0x26B0, 0x26B1, 0x26BD, 0x26BE, 0x26C4, 0x26C5, + 0x26C8, 0x26CF, 0x26D1, 0x26D3, 0x26D4, 0x26E9, 0x26EA, 0x26F0, 0x26F1, 0x26F2, 0x26F3, 0x26F4, + 0x26F5, 0x26F7, 0x26F8, 0x26F9, 0x26FA, 0x26FD, 0x2702, 0x2708, 0x2709, 0x270C, 0x270D, 0x270F, + 0x2712, 0x2714, 0x2716, 0x271D, 0x2721, 0x2733, 0x2734, 0x2744, 0x2747, 0x2757, 0x2763, 0x2764, + 0x27A1, 0x2934, 0x2935, 0x2B05, 0x2B06, 0x2B07, 0x2B1B, 0x2B1C, 0x2B50, 0x2B55, 0x3030, 0x303D, + 0x3297, 0x3299, 0x1F004, 0x1F170, 0x1F171, 0x1F17E, 0x1F17F, 0x1F202, 0x1F21A, 0x1F22F, 0x1F237, + 0x1F321, 0x1F324, 0x1F325, 0x1F326, 0x1F327, 0x1F328, 0x1F329, 0x1F32A, 0x1F32B, 0x1F32C, + 0x1F336, 0x1F37D, 0x1F396, 0x1F397, 0x1F399, 0x1F39A, 0x1F39B, 0x1F39E, 0x1F39F, 0x1F3CB, + 0x1F3CC, 0x1F3CD, 0x1F3CE, 0x1F3D4, 0x1F3D5, 0x1F3D6, 0x1F3D7, 0x1F3D8, 0x1F3D9, 0x1F3DA, + 0x1F3DB, 0x1F3DC, 0x1F3DD, 0x1F3DE, 0x1F3DF, 0x1F3F3, 0x1F3F5, 0x1F3F7, 0x1F43F, 0x1F441, + 0x1F4FD, 0x1F549, 0x1F54A, 0x1F56F, 0x1F570, 0x1F573, 0x1F574, 0x1F575, 0x1F576, 0x1F577, + 0x1F578, 0x1F579, 0x1F587, 0x1F58A, 0x1F58B, 0x1F58C, 0x1F58D, 0x1F590, 0x1F5A5, 0x1F5A8, + 0x1F5B1, 0x1F5B2, 0x1F5BC, 0x1F5C2, 0x1F5C3, 0x1F5C4, 0x1F5D1, 0x1F5D2, 0x1F5D3, 0x1F5DC, + 0x1F5DD, 0x1F5DE, 0x1F5E1, 0x1F5E3, 0x1F5E8, 0x1F5EF, 0x1F5F3, 0x1F5FA, 0x1F6CB, 0x1F6CD, + 0x1F6CE, 0x1F6CF, 0x1F6E0, 0x1F6E1, 0x1F6E2, 0x1F6E3, 0x1F6E4, 0x1F6E5, 0x1F6E9, 0x1F6F0, + 0x1F6F3, }; static bool isEmojiStyleVSBase(uint32_t cp) { diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 7fcc7b7f8b..5cb94914c9 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -33,6 +33,11 @@ void assertMinikinLocked() { } bool isEmoji(uint32_t c) { + // U+2695 U+2640 U+2642 are not in emoji category in Unicode 9 but they are now emoji category. + // TODO: remove once emoji database is updated. + if (c == 0x2695 || c == 0x2640 || c == 0x2642) { + return true; + } const size_t length = sizeof(generated::EMOJI_LIST) / sizeof(generated::EMOJI_LIST[0]); return std::binary_search(generated::EMOJI_LIST, generated::EMOJI_LIST + length, c); } diff --git a/engine/src/flutter/tests/FontCollectionTest.cpp b/engine/src/flutter/tests/FontCollectionTest.cpp index 5a03f60d26..fa95242100 100644 --- a/engine/src/flutter/tests/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/FontCollectionTest.cpp @@ -105,6 +105,20 @@ TEST(FontCollectionTest, hasVariationSelectorTest_emoji) { // VS15/VS16 is only for emoji, should return false for not an emoji code point. EXPECT_FALSE(collection->hasVariationSelector(0x2229, 0xFE0E)); EXPECT_FALSE(collection->hasVariationSelector(0x2229, 0xFE0F)); + +} + +TEST(FontCollectionTest, newEmojiTest) { + MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + + // U+2695, U+2640, U+2642 are not in emoji catrgory in Unicode 9 but they are now in emoji + // category. Should return true even if U+FE0E was appended. + // These three emojis are only avalilable in TextEmoji.ttf but U+2695 is excluded here since it + // is used in other tests. + EXPECT_TRUE(collection->hasVariationSelector(0x2640, 0xFE0E)); + EXPECT_FALSE(collection->hasVariationSelector(0x2640, 0xFE0F)); + EXPECT_TRUE(collection->hasVariationSelector(0x2642, 0xFE0E)); + EXPECT_FALSE(collection->hasVariationSelector(0x2642, 0xFE0F)); } } // namespace android diff --git a/engine/src/flutter/tests/GraphemeBreakTests.cpp b/engine/src/flutter/tests/GraphemeBreakTests.cpp index cec5308877..9dfd426bc4 100644 --- a/engine/src/flutter/tests/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/GraphemeBreakTests.cpp @@ -179,6 +179,17 @@ TEST(GraphemeBreak, emojiModifiers) { // rat is not an emoji modifer EXPECT_TRUE(IsBreak("U+1F466 | U+1F400")); // boy + rat + +} + +TEST(GraphemeBreak, genderBalancedEmoji) { + // U+1F469 is WOMAN, U+200D is ZWJ, U+1F4BC is BRIEFCASE. + EXPECT_FALSE(IsBreak("U+1F469 | U+200D U+1F4BC")); + EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+1F4BC")); + + // U+2695 has now emoji property, so should be part of ZWJ sequence. + EXPECT_FALSE(IsBreak("U+1F469 | U+200D U+2695")); + EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+2695")); } TEST(GraphemeBreak, offsets) { From 56bda7e82a59b3fcaa828960deeb2a766f8afdfe Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Mon, 11 Jul 2016 17:28:44 +0900 Subject: [PATCH 195/364] Lookup glyph from color emoji font before and after ZWJ. Unicode recommends that the zwj sequences should be emoji presentation even if they don't have the proper U+FE0F. Thus always lookup the glyph for the code point before and after zwj as if they have a U+FE0F variation selector. Bug: 30056627 Change-Id: I03958a92337eaba4a8dd9c5be824b2665aa4a103 --- .../flutter/libs/minikin/FontCollection.cpp | 18 +++++++++++------- .../tests/FontCollectionItemizeTest.cpp | 12 +++++++++--- 2 files changed, 20 insertions(+), 10 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 33418ab1b5..e665615d93 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -335,18 +335,15 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, } const uint32_t NBSP = 0xa0; -const uint32_t ZWJ = 0x200c; -const uint32_t ZWNJ = 0x200d; +const uint32_t ZWJ = 0x200d; +const uint32_t ZWNJ = 0x200c; const uint32_t HYPHEN = 0x2010; const uint32_t NB_HYPHEN = 0x2011; -const uint32_t FEMALE_SIGN = 0x2640; -const uint32_t MALE_SIGN = 0x2642; -const uint32_t STAFF_OF_AESCULAPIUS = 0x2695; // Characters where we want to continue using existing font run instead of // recomputing the best match in the fallback list. static const uint32_t stickyWhitelist[] = { '!', ',', '-', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, - HYPHEN, NB_HYPHEN, FEMALE_SIGN, MALE_SIGN, STAFF_OF_AESCULAPIUS }; + HYPHEN, NB_HYPHEN }; static bool isStickyWhitelisted(uint32_t c) { for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) { @@ -432,8 +429,15 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } if (!shouldContinueRun) { - FontFamily* family = getFamilyForChar(ch, isVariationSelector(nextCh) ? nextCh : 0, + FontFamily* family; + if ((prevCh == ZWJ || nextCh == ZWJ) && isEmoji(ch)) { + // Treat emoji before and after ZWJ as emoji presentation. + family = getFamilyForChar(ch, EMOJI_STYLE_VS, langListId, variant); + } else { + family = getFamilyForChar(ch, isVariationSelector(nextCh) ? nextCh : 0, langListId, variant); + } + if (utf16Pos == 0 || family != lastFamily) { size_t start = utf16Pos; // Workaround for combining marks and emoji modifiers until we implement diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 468b4a28fa..85d223ceaf 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -1223,7 +1223,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); - // U+26FA U+FE0E is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F + // U+26FA U+FE0E is specified but ColorTextMixedEmojiFont has a variation sequence U+26FA U+FE0F // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. itemize(collection.get(), "U+26FA U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); @@ -1305,9 +1305,9 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); - // U+26F9 U+FE0F is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F + // U+26F8 U+FE0F is specified but ColorTextMixedEmojiFont has a variation sequence U+26F8 U+FE0F // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. - itemize(collection.get(), "U+26F9 U+FE0F", kDefaultFontStyle, &runs); + itemize(collection.get(), "U+26F8 U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1396,4 +1396,10 @@ TEST_F(FontCollectionItemizeTest, itemize_genderBalancedEmoji) { EXPECT_EQ(0, runs[0].start); EXPECT_EQ(4, runs[0].end); EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); + + itemize(collection.get(), "U+26F9 U+200D U+2695", kDefaultFontStyle, &runs); + ASSERT_EQ(1U, runs.size()); + EXPECT_EQ(0, runs[0].start); + EXPECT_EQ(3, runs[0].end); + EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); } From 3ebdaaae864e157985eb9ab60af6d10734c292dd Mon Sep 17 00:00:00 2001 From: Ben Wagner Date: Fri, 5 Aug 2016 12:01:04 -0400 Subject: [PATCH 196/364] Move SkTypeface::CreateXXX to SkTypeface::MakeXXX. Skia is moving to returning smart pointers from its factory methods. This updates uses of SkTypeface::CreateXXX to SkTypeface::MakeXXX and generally updates use of SkTypeface to sk_sp. This will allow for the removal of the SK_SUPPORT_LEGACY_TYPEFACE_PTR define. Change-Id: If3e600c6cb86080576667bc77d427da4f6560afa --- engine/src/flutter/sample/MinikinSkia.cpp | 14 +++++--------- engine/src/flutter/sample/MinikinSkia.h | 6 ++---- engine/src/flutter/sample/example_skia.cpp | 12 ++++++------ .../flutter/tests/util/MinikinFontForTest.cpp | 19 ++++++------------- .../flutter/tests/util/MinikinFontForTest.h | 6 +++--- 5 files changed, 22 insertions(+), 35 deletions(-) diff --git a/engine/src/flutter/sample/MinikinSkia.cpp b/engine/src/flutter/sample/MinikinSkia.cpp index c920ca63e5..ec1e9da78c 100644 --- a/engine/src/flutter/sample/MinikinSkia.cpp +++ b/engine/src/flutter/sample/MinikinSkia.cpp @@ -6,17 +6,13 @@ namespace minikin { -MinikinFontSkia::MinikinFontSkia(SkTypeface *typeface) : +MinikinFontSkia::MinikinFontSkia(sk_sp typeface) : MinikinFont(typeface->uniqueID()), - mTypeface(typeface) { + mTypeface(std::move(typeface)) { } -MinikinFontSkia::~MinikinFontSkia() { - SkSafeUnref(mTypeface); -} - -static void MinikinFontSkia_SetSkiaPaint(SkTypeface* typeface, SkPaint* skPaint, const MinikinPaint& paint) { - skPaint->setTypeface(typeface); +static void MinikinFontSkia_SetSkiaPaint(sk_sp typeface, SkPaint* skPaint, const MinikinPaint& paint) { + skPaint->setTypeface(std::move(typeface)); skPaint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); // TODO: set more paint parameters from Minikin skPaint->setTextSize(paint.size); @@ -65,7 +61,7 @@ const void* MinikinFontSkia::GetTable(uint32_t tag, size_t* size, MinikinDestroy } SkTypeface *MinikinFontSkia::GetSkTypeface() { - return mTypeface; + return mTypeface.get(); } } // namespace minikin diff --git a/engine/src/flutter/sample/MinikinSkia.h b/engine/src/flutter/sample/MinikinSkia.h index 92f5ed2f52..d995f7d279 100644 --- a/engine/src/flutter/sample/MinikinSkia.h +++ b/engine/src/flutter/sample/MinikinSkia.h @@ -17,9 +17,7 @@ namespace minikin { class MinikinFontSkia : public MinikinFont { public: - explicit MinikinFontSkia(SkTypeface *typeface); - - ~MinikinFontSkia(); + explicit MinikinFontSkia(sk_sp typeface); float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const; @@ -32,7 +30,7 @@ public: SkTypeface *GetSkTypeface(); private: - SkTypeface *mTypeface; + sk_sp mTypeface; }; diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index bd2d779b9e..5e15a107c2 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -57,8 +57,8 @@ FontCollection *makeFontCollection() { FontFamily *family = new FontFamily(); for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { const char *fn = fns[i]; - SkTypeface *skFace = SkTypeface::CreateFromFile(fn); - MinikinFont *font = new MinikinFontSkia(skFace); + sk_sp skFace = SkTypeface::MakeFromFile(fn); + MinikinFont *font = new MinikinFontSkia(std::move(skFace)); family->addFont(font); } typefaces.push_back(family); @@ -66,8 +66,8 @@ FontCollection *makeFontCollection() { #if 1 family = new FontFamily(); const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; - SkTypeface *skFace = SkTypeface::CreateFromFile(fn); - MinikinFont *font = new MinikinFontSkia(skFace); + sk_sp skFace = SkTypeface::MakeFromFile(fn); + MinikinFont *font = new MinikinFontSkia(std::move(skFace)); family->addFont(font); typefaces.push_back(family); #endif @@ -93,13 +93,13 @@ void drawToSkia(SkCanvas *canvas, SkPaint *paint, Layout *layout, float x, float pos[i].fX = x + layout->getX(i); pos[i].fY = y + layout->getY(i); if (i > 0 && skFace != lastFace) { - paint->setTypeface(lastFace); + paint->setTypeface(sk_ref_sp(lastFace)); canvas->drawPosText(glyphs + start, (i - start) << 1, pos + start, *paint); start = i; } lastFace = skFace; } - paint->setTypeface(skFace); + paint->setTypeface(sk_ref_sp(skFace)); canvas->drawPosText(glyphs + start, (nGlyphs - start) << 1, pos + start, *paint); delete[] glyphs; delete[] pos; diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index 392d5b2ea5..807b234296 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -26,30 +26,23 @@ namespace minikin { // static MinikinFontForTest* MinikinFontForTest::createFromFile(const std::string& font_path) { - SkTypeface* typeface = SkTypeface::CreateFromFile(font_path.c_str()); - MinikinFontForTest* font = new MinikinFontForTest(font_path, typeface); - SkSafeUnref(typeface); + sk_sp typeface = SkTypeface::MakeFromFile(font_path.c_str()); + MinikinFontForTest* font = new MinikinFontForTest(font_path, std::move(typeface)); return font; } // static MinikinFontForTest* MinikinFontForTest::createFromFileWithIndex(const std::string& font_path, int index) { - SkTypeface* typeface = SkTypeface::CreateFromFile(font_path.c_str(), index); - MinikinFontForTest* font = new MinikinFontForTest(font_path, typeface); - SkSafeUnref(typeface); + sk_sp typeface = SkTypeface::MakeFromFile(font_path.c_str(), index); + MinikinFontForTest* font = new MinikinFontForTest(font_path, std::move(typeface)); return font; } -MinikinFontForTest::MinikinFontForTest(const std::string& font_path, SkTypeface* typeface) : +MinikinFontForTest::MinikinFontForTest(const std::string& font_path, sk_sp typeface) : MinikinFont(typeface->uniqueID()), - mTypeface(typeface), + mTypeface(std::move(typeface)), mFontPath(font_path) { - SkSafeRef(mTypeface); -} - -MinikinFontForTest::~MinikinFontForTest() { - SkSafeUnref(mTypeface); } float MinikinFontForTest::GetHorizontalAdvance(uint32_t /* glyph_id */, diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index 7b5322ca0b..423792f8d5 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -18,6 +18,7 @@ #define MINIKIN_TEST_MINIKIN_FONT_FOR_TEST_H #include +#include class SkTypeface; @@ -25,8 +26,7 @@ namespace minikin { class MinikinFontForTest : public MinikinFont { public: - MinikinFontForTest(const std::string& font_path, SkTypeface* typeface); - ~MinikinFontForTest(); + MinikinFontForTest(const std::string& font_path, sk_sp typeface); // Helper function for creating MinikinFontForTest instance from font file. // Calller need to unref returned object. @@ -45,7 +45,7 @@ private: MinikinFontForTest(const MinikinFontForTest&) = delete; MinikinFontForTest& operator=(MinikinFontForTest&) = delete; - SkTypeface *mTypeface; + sk_sp mTypeface; const std::string mFontPath; }; From 96fa633577dddbdd2b56d4a72382a8a90980d036 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Thu, 11 Aug 2016 21:03:00 +0000 Subject: [PATCH 197/364] Revert "Lookup glyph from color emoji font before and after ZWJ." This reverts commit 56bda7e82a59b3fcaa828960deeb2a766f8afdfe. Bug: 30815709 Change-Id: I057d9bcd05246e58894abb4e9633bd10f6fab211 --- .../flutter/libs/minikin/FontCollection.cpp | 18 +++++++----------- .../tests/FontCollectionItemizeTest.cpp | 12 +++--------- 2 files changed, 10 insertions(+), 20 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index e665615d93..33418ab1b5 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -335,15 +335,18 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, } const uint32_t NBSP = 0xa0; -const uint32_t ZWJ = 0x200d; -const uint32_t ZWNJ = 0x200c; +const uint32_t ZWJ = 0x200c; +const uint32_t ZWNJ = 0x200d; const uint32_t HYPHEN = 0x2010; const uint32_t NB_HYPHEN = 0x2011; +const uint32_t FEMALE_SIGN = 0x2640; +const uint32_t MALE_SIGN = 0x2642; +const uint32_t STAFF_OF_AESCULAPIUS = 0x2695; // Characters where we want to continue using existing font run instead of // recomputing the best match in the fallback list. static const uint32_t stickyWhitelist[] = { '!', ',', '-', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, - HYPHEN, NB_HYPHEN }; + HYPHEN, NB_HYPHEN, FEMALE_SIGN, MALE_SIGN, STAFF_OF_AESCULAPIUS }; static bool isStickyWhitelisted(uint32_t c) { for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) { @@ -429,15 +432,8 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } if (!shouldContinueRun) { - FontFamily* family; - if ((prevCh == ZWJ || nextCh == ZWJ) && isEmoji(ch)) { - // Treat emoji before and after ZWJ as emoji presentation. - family = getFamilyForChar(ch, EMOJI_STYLE_VS, langListId, variant); - } else { - family = getFamilyForChar(ch, isVariationSelector(nextCh) ? nextCh : 0, + FontFamily* family = getFamilyForChar(ch, isVariationSelector(nextCh) ? nextCh : 0, langListId, variant); - } - if (utf16Pos == 0 || family != lastFamily) { size_t start = utf16Pos; // Workaround for combining marks and emoji modifiers until we implement diff --git a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp index 85d223ceaf..468b4a28fa 100644 --- a/engine/src/flutter/tests/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/FontCollectionItemizeTest.cpp @@ -1223,7 +1223,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); - // U+26FA U+FE0E is specified but ColorTextMixedEmojiFont has a variation sequence U+26FA U+FE0F + // U+26FA U+FE0E is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. itemize(collection.get(), "U+26FA U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); @@ -1305,9 +1305,9 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); - // U+26F8 U+FE0F is specified but ColorTextMixedEmojiFont has a variation sequence U+26F8 U+FE0F + // U+26F9 U+FE0F is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. - itemize(collection.get(), "U+26F8 U+FE0F", kDefaultFontStyle, &runs); + itemize(collection.get(), "U+26F9 U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1396,10 +1396,4 @@ TEST_F(FontCollectionItemizeTest, itemize_genderBalancedEmoji) { EXPECT_EQ(0, runs[0].start); EXPECT_EQ(4, runs[0].end); EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); - - itemize(collection.get(), "U+26F9 U+200D U+2695", kDefaultFontStyle, &runs); - ASSERT_EQ(1U, runs.size()); - EXPECT_EQ(0, runs[0].start); - EXPECT_EQ(3, runs[0].end); - EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); } From 85c660fa984c4d3a61136459a74b872ed01ead77 Mon Sep 17 00:00:00 2001 From: Chih-Hung Hsieh Date: Mon, 15 Aug 2016 12:29:41 -0700 Subject: [PATCH 198/364] Fix google-explicit-constructor warnings in minikin * Add explicit keyword to conversion constructors, or add NOLINT(implicit) for implicit converters. Bug: 28341362 Test: build with WITH_TIDY=1 Change-Id: I0c7b90f9bb953a9f2e4f0fb2032fa65ac604b9ca --- engine/src/flutter/include/minikin/FontFamily.h | 4 ++-- engine/src/flutter/include/minikin/MinikinFont.h | 4 ++-- engine/src/flutter/include/minikin/MinikinRefCounted.h | 2 +- engine/src/flutter/libs/minikin/FontLanguage.h | 2 +- engine/src/flutter/libs/minikin/MinikinInternal.h | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index f4b1f468d7..10362c24de 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -37,7 +37,7 @@ class FontStyle { public: FontStyle() : FontStyle(0 /* variant */, 4 /* weight */, false /* italic */) {} FontStyle(int weight, bool italic) : FontStyle(0 /* variant */, weight, italic) {} - FontStyle(uint32_t langListId) + FontStyle(uint32_t langListId) // NOLINT(implicit) : FontStyle(langListId, 0 /* variant */, 4 /* weight */, false /* italic */) {} FontStyle(int variant, int weight, bool italic); @@ -102,7 +102,7 @@ class FontFamily : public MinikinRefCounted { public: FontFamily(); - FontFamily(int variant); + explicit FontFamily(int variant); FontFamily(uint32_t langId, int variant) : mLangId(langId), diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 9d4f937089..ac9235be8d 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -33,7 +33,7 @@ namespace minikin { class HyphenEdit { public: HyphenEdit() : hyphen(0) { } - HyphenEdit(uint32_t hyphenInt) : hyphen(hyphenInt) { } + HyphenEdit(uint32_t hyphenInt) : hyphen(hyphenInt) { } // NOLINT(implicit) bool hasHyphen() const { return hyphen != 0; } bool operator==(const HyphenEdit &other) const { return hyphen == other.hyphen; } private: @@ -99,7 +99,7 @@ typedef void (*MinikinDestroyFunc) (void* data); class MinikinFont : public MinikinRefCounted { public: - MinikinFont(int32_t uniqueId) : mUniqueId(uniqueId) {} + explicit MinikinFont(int32_t uniqueId) : mUniqueId(uniqueId) {} virtual ~MinikinFont(); diff --git a/engine/src/flutter/include/minikin/MinikinRefCounted.h b/engine/src/flutter/include/minikin/MinikinRefCounted.h index 0ee44747c1..960b6cc46d 100644 --- a/engine/src/flutter/include/minikin/MinikinRefCounted.h +++ b/engine/src/flutter/include/minikin/MinikinRefCounted.h @@ -42,7 +42,7 @@ private: template class MinikinAutoUnref { public: - MinikinAutoUnref(T* obj) : mObj(obj) { + explicit MinikinAutoUnref(T* obj) : mObj(obj) { } ~MinikinAutoUnref() { mObj->Unref(); diff --git a/engine/src/flutter/libs/minikin/FontLanguage.h b/engine/src/flutter/libs/minikin/FontLanguage.h index f28a4a8e72..b1bb6eb5f9 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.h +++ b/engine/src/flutter/libs/minikin/FontLanguage.h @@ -98,7 +98,7 @@ private: // An immutable list of languages. class FontLanguages { public: - FontLanguages(std::vector&& languages); + explicit FontLanguages(std::vector&& languages); FontLanguages() : mUnionOfSubScriptBits(0), mIsAllTheSameLanguage(false) {} FontLanguages(FontLanguages&&) = default; diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index 88c0d5f510..88d54d7b11 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -52,7 +52,7 @@ class HbBlob { public: // Takes ownership of hb_blob_t object, caller is no longer // responsible for calling hb_blob_destroy(). - HbBlob(hb_blob_t* blob) : mBlob(blob) { + explicit HbBlob(hb_blob_t* blob) : mBlob(blob) { } ~HbBlob() { From 32252e357f3898baec85bafe076debefd915adfe Mon Sep 17 00:00:00 2001 From: Chih-Hung Hsieh Date: Mon, 15 Aug 2016 12:29:41 -0700 Subject: [PATCH 199/364] Fix google-explicit-constructor warnings in minikin * Add explicit keyword to conversion constructors, or add NOLINT(implicit) for implicit converters. Bug: 28341362 Test: build with WITH_TIDY=1 Change-Id: I0c7b90f9bb953a9f2e4f0fb2032fa65ac604b9ca Merged-In: I0c7b90f9bb953a9f2e4f0fb2032fa65ac604b9ca --- engine/src/flutter/include/minikin/FontFamily.h | 4 ++-- engine/src/flutter/include/minikin/MinikinFont.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 7bdff6eb4f..4d7d08378a 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -65,10 +65,10 @@ private: // so it can be efficiently copied, embedded in other objects, etc. class FontStyle { public: - FontStyle(int weight = 4, bool italic = false) { + explicit FontStyle(int weight = 4, bool italic = false) { bits = (weight & kWeightMask) | (italic ? kItalicMask : 0); } - FontStyle(FontLanguage lang, int variant = 0, int weight = 4, bool italic = false) { + explicit FontStyle(FontLanguage lang, int variant = 0, int weight = 4, bool italic = false) { bits = (weight & kWeightMask) | (italic ? kItalicMask : 0) | (variant << kVariantShift) | (lang.bits() << kLangShift); } diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 7f65cd7b0a..b7e6f87f78 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -33,7 +33,7 @@ namespace android { class HyphenEdit { public: HyphenEdit() : hyphen(0) { } - HyphenEdit(uint32_t hyphenInt) : hyphen(hyphenInt) { } + HyphenEdit(uint32_t hyphenInt) : hyphen(hyphenInt) { } // NOLINT(implicit) bool hasHyphen() const { return hyphen != 0; } bool operator==(const HyphenEdit &other) const { return hyphen == other.hyphen; } private: From b4f4c16d32a6734f163a59cfa404536501d882fb Mon Sep 17 00:00:00 2001 From: Dan Willemsen Date: Mon, 12 Sep 2016 14:37:02 -0700 Subject: [PATCH 200/364] Rename libicuuc-host/libicui18n-host to libicuuc/libicui18n These modules can be named the same between the target and host libraries, which simplifies references to them, particularly in Soong. To prevent accidentally loading the system copy of the library, we still rename the installed name to be libicu*-host.so. But modules do not need to know that in order to build against them. Change-Id: Ic38499bb236ace75333a84f23798af023e14cf5f --- engine/src/flutter/app/Android.mk | 2 +- engine/src/flutter/libs/minikin/Android.mk | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/app/Android.mk b/engine/src/flutter/app/Android.mk index 2038683027..23305b7b4c 100644 --- a/engine/src/flutter/app/Android.mk +++ b/engine/src/flutter/app/Android.mk @@ -28,7 +28,7 @@ LOCAL_STATIC_LIBRARIES := libminikin_host LOCAL_SHARED_LIBRARIES := \ liblog \ - libicuuc-host + libicuuc LOCAL_SRC_FILES += \ HyphTool.cpp diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 9d8257944f..d6c3df7f62 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -109,7 +109,7 @@ LOCAL_MODULE_TAGS := optional LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include LOCAL_C_INCLUDES := $(minikin_c_includes) LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) -LOCAL_SHARED_LIBRARIES := liblog libicuuc-host +LOCAL_SHARED_LIBRARIES := liblog libicuuc LOCAL_SRC_FILES := Hyphenator.cpp From fba88d3b3c5c0640b55effac84b1314760f46bf1 Mon Sep 17 00:00:00 2001 From: Elliott Hughes Date: Sun, 11 Sep 2016 14:47:29 -0700 Subject: [PATCH 201/364] Switch minikin to std::unique_ptr. Bug: http://b/22403888 Change-Id: I9e18496fcc38ad2e6b922455daa9f2a46778ec55 --- engine/src/flutter/include/minikin/SparseBitSet.h | 7 ++++--- engine/src/flutter/libs/minikin/FontFamily.cpp | 1 - engine/src/flutter/libs/minikin/Layout.cpp | 3 ++- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/engine/src/flutter/include/minikin/SparseBitSet.h b/engine/src/flutter/include/minikin/SparseBitSet.h index 72b83057c6..81f67c8f96 100644 --- a/engine/src/flutter/include/minikin/SparseBitSet.h +++ b/engine/src/flutter/include/minikin/SparseBitSet.h @@ -19,7 +19,8 @@ #include #include -#include + +#include // --------------------------------------------------------------------------- @@ -79,8 +80,8 @@ private: static int CountLeadingZeros(element x); uint32_t mMaxVal; - UniquePtr mIndices; - UniquePtr mBitmaps; + std::unique_ptr mIndices; + std::unique_ptr mBitmaps; uint32_t mZeroPageIndex; }; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index e2d86f0bbb..7a8e79f508 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -34,7 +34,6 @@ #include #include #include -#include using std::vector; diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 9c1d6a873a..5ba72a4bb2 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -496,7 +496,8 @@ private: size_t mRunCount; bool mIsRtl; - DISALLOW_COPY_AND_ASSIGN(BidiText); + BidiText(const BidiText&) = delete; + void operator=(const BidiText&) = delete; }; BidiText::Iter::Iter(UBiDi* bidi, size_t start, size_t end, size_t runIndex, size_t runCount, From 5bd8edea610210d041db240a0721a17f58f2a54e Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 23 Jun 2016 13:22:16 +0900 Subject: [PATCH 202/364] Fix lookup order for VS in itemization. This is partial revert of Iced1349e3ca750821d8882c551551f65bb569794. Due to sorting of target family vectors, the font family order from XML settings file is broken. Making unique operation stable doesn't fix the issue completely since some font families are appended for the fallback which also breaks the original order. By this change, itemization becomes 3x slower than before if variation selector is appended. Bug: 29585939 Change-Id: I7c1a8a57f04111a30cd41a5cd5bec25fcfb3972e --- .../flutter/libs/minikin/FontCollection.cpp | 17 +---- engine/src/flutter/tests/unittest/Android.mk | 1 + .../unittest/FontCollectionItemizeTest.cpp | 73 +++++++++++++++++++ 3 files changed, 77 insertions(+), 14 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 97c206881f..19ad7523f7 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -281,22 +281,11 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, return mFamilies[0]; } - const std::vector* familyVec = &mFamilyVec; + const std::vector& familyVec = (vs == 0) ? mFamilyVec : mFamilies; Range range = mRanges[ch >> kLogCharsPerPage]; - std::vector familyVecForVS; if (vs != 0) { - // If variation selector is specified, need to search for both the variation sequence and - // its base codepoint. Compute the union vector of them. - familyVecForVS = mVSFamilyVec; - familyVecForVS.insert(familyVecForVS.end(), - mFamilyVec.begin() + range.start, mFamilyVec.begin() + range.end); - std::sort(familyVecForVS.begin(), familyVecForVS.end()); - auto last = std::unique(familyVecForVS.begin(), familyVecForVS.end()); - familyVecForVS.erase(last, familyVecForVS.end()); - - familyVec = &familyVecForVS; - range = { 0, familyVecForVS.size() }; + range = { 0, mFamilies.size() }; } #ifdef VERBOSE_DEBUG @@ -305,7 +294,7 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, FontFamily* bestFamily = nullptr; uint32_t bestScore = kUnsupportedFontScore; for (size_t i = range.start; i < range.end; i++) { - FontFamily* family = (*familyVec)[i]; + FontFamily* family = familyVec[i]; const uint32_t score = calcFamilyScore(ch, vs, variant, langListId, family); if (score == kFirstFontScore) { // If the first font family supports the given character or variation sequence, always diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index b43e3c8570..a81d17cca7 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -32,6 +32,7 @@ font_src_files := \ data/Italic.ttf \ data/Ja.ttf \ data/Ko.ttf \ + data/NoCmapFormat14.ttf \ data/NoGlyphFont.ttf \ data/Regular.ttf \ data/TextEmojiFont.ttf \ diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 367739683d..978ba9f499 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -44,6 +44,9 @@ const char kColorEmojiFont[] = kTestFontDir "ColorEmojiFont.ttf"; const char kTextEmojiFont[] = kTestFontDir "TextEmojiFont.ttf"; const char kMixedEmojiFont[] = kTestFontDir "ColorTextMixedEmojiFont.ttf"; +const char kHasCmapFormat14Font[] = kTestFontDir "NoCmapFormat14.ttf"; +const char kNoCmapFormat14Font[] = kTestFontDir "VarioationSelectorTest-Regular.ttf"; + typedef ICUTestBase FontCollectionItemizeTest; // Utility function for calling itemize function. @@ -1392,4 +1395,74 @@ TEST_F(FontCollectionItemizeTest, itemize_genderBalancedEmoji) { EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); } +// For b/29585939 +TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS) { + const FontStyle kDefaultFontStyle; + + MinikinAutoUnref dummyFont(MinikinFontForTest::createFromFile(kNoGlyphFont)); + MinikinAutoUnref fontA(MinikinFontForTest::createFromFile(kZH_HansFont)); + MinikinAutoUnref fontB(MinikinFontForTest::createFromFile(kZH_HansFont)); + + MinikinAutoUnref dummyFamily(new FontFamily()); + MinikinAutoUnref familyA(new FontFamily()); + MinikinAutoUnref familyB(new FontFamily()); + + dummyFamily->addFont(dummyFont.get()); + familyA->addFont(fontA.get()); + familyB->addFont(fontB.get()); + + std::vector families = + { dummyFamily.get(), familyA.get(), familyB.get() }; + std::vector reversedFamilies = + { dummyFamily.get(), familyB.get(), familyA.get() }; + + MinikinAutoUnref collection(new FontCollection(families)); + MinikinAutoUnref reversedCollection(new FontCollection(reversedFamilies)); + + // Both fontA/fontB support U+35A8 but don't support U+35A8 U+E0100. The first font should be + // selected. + std::vector runs; + itemize(collection.get(), "U+35A8 U+E0100", kDefaultFontStyle, &runs); + EXPECT_EQ(fontA.get(), runs[0].fakedFont.font); + + itemize(reversedCollection.get(), "U+35A8 U+E0100", kDefaultFontStyle, &runs); + EXPECT_EQ(fontB.get(), runs[0].fakedFont.font); +} + +// For b/29585939 +TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS2) { + const FontStyle kDefaultFontStyle; + + MinikinAutoUnref dummyFont(MinikinFontForTest::createFromFile(kNoGlyphFont)); + MinikinAutoUnref hasCmapFormat14Font( + MinikinFontForTest::createFromFile(kHasCmapFormat14Font)); + MinikinAutoUnref noCmapFormat14Font( + MinikinFontForTest::createFromFile(kNoCmapFormat14Font)); + + MinikinAutoUnref dummyFamily(new FontFamily()); + MinikinAutoUnref hasCmapFormat14Family(new FontFamily()); + MinikinAutoUnref noCmapFormat14Family(new FontFamily()); + + dummyFamily->addFont(dummyFont.get()); + hasCmapFormat14Family->addFont(hasCmapFormat14Font.get()); + noCmapFormat14Family->addFont(noCmapFormat14Font.get()); + + std::vector families = + { dummyFamily.get(), hasCmapFormat14Family.get(), noCmapFormat14Family.get() }; + std::vector reversedFamilies = + { dummyFamily.get(), noCmapFormat14Family.get(), hasCmapFormat14Family.get() }; + + MinikinAutoUnref collection(new FontCollection(families)); + MinikinAutoUnref reversedCollection(new FontCollection(reversedFamilies)); + + // Both hasCmapFormat14Font/noCmapFormat14Font support U+5380 but don't support U+5380 U+E0100. + // The first font should be selected. + std::vector runs; + itemize(collection.get(), "U+5380 U+E0100", kDefaultFontStyle, &runs); + EXPECT_EQ(hasCmapFormat14Font.get(), runs[0].fakedFont.font); + + itemize(reversedCollection.get(), "U+5380 U+E0100", kDefaultFontStyle, &runs); + EXPECT_EQ(noCmapFormat14Font.get(), runs[0].fakedFont.font); +} + } // namespace minikin From 7b02f5e95c4386c250f6f83db1ff61b69177140e Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 18 Oct 2016 11:21:59 +0900 Subject: [PATCH 203/364] Clean Up: Removing unused interface GetTable from MinikinFont. After Id766ab16a8d342bf7322a90e076e801271d527d4, GetTable is no longer used in production due to poor performance and it is now only used in tests. This CL removes GetTable interface from MinikinFont and update tests code to use new interfaces, GetFontData, GetFontSize and GetFontIndex. Bug: 27860101 Test: Manually done Change-Id: Ifcd7a348d7fb5af081192899dbcdfc7fb4eebbf9 --- .../src/flutter/include/minikin/MinikinFont.h | 2 - .../src/flutter/libs/minikin/HbFontCache.cpp | 31 +++-------- .../unittest/FontCollectionItemizeTest.cpp | 8 +-- .../tests/unittest/FontCollectionTest.cpp | 2 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 4 +- .../tests/unittest/HbFontCacheTest.cpp | 8 +-- .../src/flutter/tests/util/FontTestUtils.cpp | 5 +- .../flutter/tests/util/MinikinFontForTest.cpp | 54 +++++++------------ .../flutter/tests/util/MinikinFontForTest.h | 18 +++---- 9 files changed, 47 insertions(+), 85 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index ac9235be8d..253160204e 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -109,8 +109,6 @@ public: virtual void GetBounds(MinikinRect* bounds, uint32_t glyph_id, const MinikinPaint &paint) const = 0; - virtual const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) = 0; - // Override if font can provide access to raw data virtual const void* GetFontData() const { return nullptr; diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index 45c3f5807b..3c6619d10a 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -28,22 +28,6 @@ namespace minikin { -static hb_blob_t* referenceTable(hb_face_t* /* face */, hb_tag_t tag, void* userData) { - MinikinFont* font = reinterpret_cast(userData); - MinikinDestroyFunc destroy = 0; - size_t size = 0; - const void* buffer = font->GetTable(tag, &size, &destroy); - if (buffer == nullptr) { - return nullptr; - } -#ifdef VERBOSE_DEBUG - ALOGD("referenceTable %c%c%c%c length=%zd", - (tag >>24)&0xff, (tag>>16)&0xff, (tag>>8)&0xff, tag&0xff, size); -#endif - return hb_blob_create(reinterpret_cast(buffer), size, - HB_MEMORY_MODE_READONLY, const_cast(buffer), destroy); -} - class HbFontCache : private android::OnEntryRemoved { public: HbFontCache() : mCache(kMaxEntries) { @@ -119,15 +103,12 @@ hb_font_t* getHbFontLocked(MinikinFont* minikinFont) { hb_face_t* face; const void* buf = minikinFont->GetFontData(); - if (buf == nullptr) { - face = hb_face_create_for_tables(referenceTable, minikinFont, nullptr); - } else { - size_t size = minikinFont->GetFontSize(); - hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, - HB_MEMORY_MODE_READONLY, nullptr, nullptr); - face = hb_face_create(blob, minikinFont->GetFontIndex()); - hb_blob_destroy(blob); - } + size_t size = minikinFont->GetFontSize(); + hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, + HB_MEMORY_MODE_READONLY, nullptr, nullptr); + face = hb_face_create(blob, minikinFont->GetFontIndex()); + hb_blob_destroy(blob); + hb_font_t* parent_font = hb_font_create(face); hb_ot_font_set_funcs(parent_font); diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 367739683d..0d2a7cbfa6 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -666,12 +666,12 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { std::vector families; FontFamily* family1 = new FontFamily(VARIANT_DEFAULT); - MinikinAutoUnref font(MinikinFontForTest::createFromFile(kLatinFont)); + MinikinAutoUnref font(new MinikinFontForTest(kLatinFont)); family1->addFont(font.get()); families.push_back(family1); FontFamily* family2 = new FontFamily(VARIANT_DEFAULT); - MinikinAutoUnref font2(MinikinFontForTest::createFromFile(kVSTestFont)); + MinikinAutoUnref font2(new MinikinFontForTest(kVSTestFont)); family2->addFont(font2.get()); families.push_back(family2); @@ -797,7 +797,7 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { FontFamily* firstFamily = new FontFamily( FontStyle::registerLanguageList("und"), 0 /* variant */); MinikinAutoUnref firstFamilyMinikinFont( - MinikinFontForTest::createFromFile(kNoGlyphFont)); + new MinikinFontForTest(kNoGlyphFont)); firstFamily->addFont(firstFamilyMinikinFont.get()); families.push_back(firstFamily); @@ -809,7 +809,7 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { for (size_t i = 0; i < testCase.fontLanguages.size(); ++i) { FontFamily* family = new FontFamily( FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */); - MinikinAutoUnref minikin_font(MinikinFontForTest::createFromFile(kJAFont)); + MinikinAutoUnref minikin_font(new MinikinFontForTest(kJAFont)); family->addFont(minikin_font.get()); families.push_back(family); fontLangIdxMap.insert(std::make_pair(minikin_font.get(), i)); diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index ef2da66b2b..62d2f022fa 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -58,7 +58,7 @@ void expectVSGlyphs(const FontCollection* fc, uint32_t codepoint, const std::set TEST(FontCollectionTest, hasVariationSelectorTest) { MinikinAutoUnref family(new FontFamily()); - MinikinAutoUnref font(MinikinFontForTest::createFromFile(kVsTestFont)); + MinikinAutoUnref font(new MinikinFontForTest(kVsTestFont)); family->addFont(font.get()); std::vector families({family.get()}); MinikinAutoUnref fc(new FontCollection(families)); diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 69fef23da8..4aaa601a23 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -351,7 +351,7 @@ void expectVSGlyphs(FontFamily* family, uint32_t codepoint, const std::set - minikinFont(MinikinFontForTest::createFromFile(kVsTestFont)); + minikinFont(new MinikinFontForTest(kVsTestFont)); MinikinAutoUnref family(new FontFamily); family->addFont(minikinFont.get()); @@ -405,7 +405,7 @@ TEST_F(FontFamilyTest, hasVSTableTest) { "Font " + testCase.fontPath + " shouldn't have a variation sequence table."); MinikinAutoUnref minikinFont( - MinikinFontForTest::createFromFile(testCase.fontPath)); + new MinikinFontForTest(testCase.fontPath)); MinikinAutoUnref family(new FontFamily); family->addFont(minikinFont.get()); android::AutoMutex _l(gMinikinLock); diff --git a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp index aa4cb34c05..5e560430c2 100644 --- a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp @@ -38,13 +38,13 @@ public: TEST_F(HbFontCacheTest, getHbFontLockedTest) { MinikinAutoUnref fontA( - MinikinFontForTest::createFromFile(kTestFontDir "Regular.ttf")); + new MinikinFontForTest(kTestFontDir "Regular.ttf")); MinikinAutoUnref fontB( - MinikinFontForTest::createFromFile(kTestFontDir "Bold.ttf")); + new MinikinFontForTest(kTestFontDir "Bold.ttf")); MinikinAutoUnref fontC( - MinikinFontForTest::createFromFile(kTestFontDir "BoldItalic.ttf")); + new MinikinFontForTest(kTestFontDir "BoldItalic.ttf")); android::AutoMutex _l(gMinikinLock); // Never return NULL. @@ -66,7 +66,7 @@ TEST_F(HbFontCacheTest, getHbFontLockedTest) { TEST_F(HbFontCacheTest, purgeCacheTest) { MinikinAutoUnref minikinFont( - MinikinFontForTest::createFromFile(kTestFontDir "Regular.ttf")); + new MinikinFontForTest(kTestFontDir "Regular.ttf")); android::AutoMutex _l(gMinikinLock); hb_font_t* font = getHbFontLocked(minikinFont.get()); diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index 246c87231a..b675620e25 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -77,12 +77,11 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { if (index == nullptr) { MinikinAutoUnref - minikinFont(MinikinFontForTest::createFromFile(fontPath)); + minikinFont(new MinikinFontForTest(fontPath)); family->addFont(minikinFont.get(), FontStyle(weight, italic)); } else { MinikinAutoUnref - minikinFont(MinikinFontForTest::createFromFileWithIndex(fontPath, - atoi((const char*)index))); + minikinFont(new MinikinFontForTest(fontPath, atoi((const char*)index))); family->addFont(minikinFont.get(), FontStyle(weight, italic)); } } diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index 807b234296..db4b8333f8 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -18,31 +18,31 @@ #include -#include - #include +#include +#include +#include namespace minikin { -// static -MinikinFontForTest* MinikinFontForTest::createFromFile(const std::string& font_path) { - sk_sp typeface = SkTypeface::MakeFromFile(font_path.c_str()); - MinikinFontForTest* font = new MinikinFontForTest(font_path, std::move(typeface)); - return font; +static int uniqueId = 0; // TODO: make thread safe if necessary. + +MinikinFontForTest::MinikinFontForTest(const std::string& font_path, int index) : + MinikinFont(uniqueId++), + mFontPath(font_path), + mFontIndex(index) { + int fd = open(font_path.c_str(), O_RDONLY); + LOG_ALWAYS_FATAL_IF(fd == -1); + struct stat st = {}; + LOG_ALWAYS_FATAL_IF(fstat(fd, &st) != 0); + mFontSize = st.st_size; + mFontData = mmap(NULL, mFontSize, PROT_READ, MAP_SHARED, fd, 0); + LOG_ALWAYS_FATAL_IF(mFontData == nullptr); + close(fd); } -// static -MinikinFontForTest* MinikinFontForTest::createFromFileWithIndex(const std::string& font_path, - int index) { - sk_sp typeface = SkTypeface::MakeFromFile(font_path.c_str(), index); - MinikinFontForTest* font = new MinikinFontForTest(font_path, std::move(typeface)); - return font; -} - -MinikinFontForTest::MinikinFontForTest(const std::string& font_path, sk_sp typeface) : - MinikinFont(typeface->uniqueID()), - mTypeface(std::move(typeface)), - mFontPath(font_path) { +MinikinFontForTest::~MinikinFontForTest() { + munmap(mFontData, mFontSize); } float MinikinFontForTest::GetHorizontalAdvance(uint32_t /* glyph_id */, @@ -56,20 +56,4 @@ void MinikinFontForTest::GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph_ LOG_ALWAYS_FATAL("MinikinFontForTest::GetBounds is not yet implemented"); } -const void* MinikinFontForTest::GetTable(uint32_t tag, size_t* size, - MinikinDestroyFunc* destroy) { - const size_t tableSize = mTypeface->getTableSize(tag); - *size = tableSize; - if (tableSize == 0) { - return nullptr; - } - void* buf = malloc(tableSize); - if (buf == nullptr) { - return nullptr; - } - mTypeface->getTableData(tag, 0, tableSize, buf); - *destroy = free; - return buf; -} - } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index 423792f8d5..ee0eadbe0c 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -18,7 +18,6 @@ #define MINIKIN_TEST_MINIKIN_FONT_FOR_TEST_H #include -#include class SkTypeface; @@ -26,27 +25,28 @@ namespace minikin { class MinikinFontForTest : public MinikinFont { public: - MinikinFontForTest(const std::string& font_path, sk_sp typeface); - - // Helper function for creating MinikinFontForTest instance from font file. - // Calller need to unref returned object. - static MinikinFontForTest* createFromFile(const std::string& font_path); - static MinikinFontForTest* createFromFileWithIndex(const std::string& font_path, int index); + MinikinFontForTest(const std::string& font_path, int index); + MinikinFontForTest(const std::string& font_path) : MinikinFontForTest(font_path, 0) {} + virtual ~MinikinFontForTest(); // MinikinFont overrides. float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const; void GetBounds(MinikinRect* bounds, uint32_t glyph_id, const MinikinPaint& paint) const; - const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy); const std::string& fontPath() const { return mFontPath; } + const void* GetFontData() const { return mFontData; } + size_t GetFontSize() const { return mFontSize; } + int GetFontIndex() const { return mFontIndex; } private: MinikinFontForTest() = delete; MinikinFontForTest(const MinikinFontForTest&) = delete; MinikinFontForTest& operator=(MinikinFontForTest&) = delete; - sk_sp mTypeface; const std::string mFontPath; + const int mFontIndex; + void* mFontData; + size_t mFontSize; }; } // namespace minikin From dc8de001df23f2263bbe2e5e3935f85a2be2ef5e Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 25 Oct 2016 00:49:52 +0000 Subject: [PATCH 204/364] Revert "Clean Up: Removing unused interface GetTable from MinikinFont." This reverts commit 7b02f5e95c4386c250f6f83db1ff61b69177140e. This causes a crash on Android Auto. Bug: 32374752 Change-Id: Ia2ff77bf9a12351c6949f79ef6fa2d8016e3022d --- .../src/flutter/include/minikin/MinikinFont.h | 2 + .../src/flutter/libs/minikin/HbFontCache.cpp | 31 ++++++++--- .../unittest/FontCollectionItemizeTest.cpp | 8 +-- .../tests/unittest/FontCollectionTest.cpp | 2 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 4 +- .../tests/unittest/HbFontCacheTest.cpp | 8 +-- .../src/flutter/tests/util/FontTestUtils.cpp | 5 +- .../flutter/tests/util/MinikinFontForTest.cpp | 54 ++++++++++++------- .../flutter/tests/util/MinikinFontForTest.h | 18 +++---- 9 files changed, 85 insertions(+), 47 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 253160204e..ac9235be8d 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -109,6 +109,8 @@ public: virtual void GetBounds(MinikinRect* bounds, uint32_t glyph_id, const MinikinPaint &paint) const = 0; + virtual const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) = 0; + // Override if font can provide access to raw data virtual const void* GetFontData() const { return nullptr; diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index 3c6619d10a..45c3f5807b 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -28,6 +28,22 @@ namespace minikin { +static hb_blob_t* referenceTable(hb_face_t* /* face */, hb_tag_t tag, void* userData) { + MinikinFont* font = reinterpret_cast(userData); + MinikinDestroyFunc destroy = 0; + size_t size = 0; + const void* buffer = font->GetTable(tag, &size, &destroy); + if (buffer == nullptr) { + return nullptr; + } +#ifdef VERBOSE_DEBUG + ALOGD("referenceTable %c%c%c%c length=%zd", + (tag >>24)&0xff, (tag>>16)&0xff, (tag>>8)&0xff, tag&0xff, size); +#endif + return hb_blob_create(reinterpret_cast(buffer), size, + HB_MEMORY_MODE_READONLY, const_cast(buffer), destroy); +} + class HbFontCache : private android::OnEntryRemoved { public: HbFontCache() : mCache(kMaxEntries) { @@ -103,12 +119,15 @@ hb_font_t* getHbFontLocked(MinikinFont* minikinFont) { hb_face_t* face; const void* buf = minikinFont->GetFontData(); - size_t size = minikinFont->GetFontSize(); - hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, - HB_MEMORY_MODE_READONLY, nullptr, nullptr); - face = hb_face_create(blob, minikinFont->GetFontIndex()); - hb_blob_destroy(blob); - + if (buf == nullptr) { + face = hb_face_create_for_tables(referenceTable, minikinFont, nullptr); + } else { + size_t size = minikinFont->GetFontSize(); + hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, + HB_MEMORY_MODE_READONLY, nullptr, nullptr); + face = hb_face_create(blob, minikinFont->GetFontIndex()); + hb_blob_destroy(blob); + } hb_font_t* parent_font = hb_font_create(face); hb_ot_font_set_funcs(parent_font); diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 0d2a7cbfa6..367739683d 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -666,12 +666,12 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { std::vector families; FontFamily* family1 = new FontFamily(VARIANT_DEFAULT); - MinikinAutoUnref font(new MinikinFontForTest(kLatinFont)); + MinikinAutoUnref font(MinikinFontForTest::createFromFile(kLatinFont)); family1->addFont(font.get()); families.push_back(family1); FontFamily* family2 = new FontFamily(VARIANT_DEFAULT); - MinikinAutoUnref font2(new MinikinFontForTest(kVSTestFont)); + MinikinAutoUnref font2(MinikinFontForTest::createFromFile(kVSTestFont)); family2->addFont(font2.get()); families.push_back(family2); @@ -797,7 +797,7 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { FontFamily* firstFamily = new FontFamily( FontStyle::registerLanguageList("und"), 0 /* variant */); MinikinAutoUnref firstFamilyMinikinFont( - new MinikinFontForTest(kNoGlyphFont)); + MinikinFontForTest::createFromFile(kNoGlyphFont)); firstFamily->addFont(firstFamilyMinikinFont.get()); families.push_back(firstFamily); @@ -809,7 +809,7 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { for (size_t i = 0; i < testCase.fontLanguages.size(); ++i) { FontFamily* family = new FontFamily( FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */); - MinikinAutoUnref minikin_font(new MinikinFontForTest(kJAFont)); + MinikinAutoUnref minikin_font(MinikinFontForTest::createFromFile(kJAFont)); family->addFont(minikin_font.get()); families.push_back(family); fontLangIdxMap.insert(std::make_pair(minikin_font.get(), i)); diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index 62d2f022fa..ef2da66b2b 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -58,7 +58,7 @@ void expectVSGlyphs(const FontCollection* fc, uint32_t codepoint, const std::set TEST(FontCollectionTest, hasVariationSelectorTest) { MinikinAutoUnref family(new FontFamily()); - MinikinAutoUnref font(new MinikinFontForTest(kVsTestFont)); + MinikinAutoUnref font(MinikinFontForTest::createFromFile(kVsTestFont)); family->addFont(font.get()); std::vector families({family.get()}); MinikinAutoUnref fc(new FontCollection(families)); diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 4aaa601a23..69fef23da8 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -351,7 +351,7 @@ void expectVSGlyphs(FontFamily* family, uint32_t codepoint, const std::set - minikinFont(new MinikinFontForTest(kVsTestFont)); + minikinFont(MinikinFontForTest::createFromFile(kVsTestFont)); MinikinAutoUnref family(new FontFamily); family->addFont(minikinFont.get()); @@ -405,7 +405,7 @@ TEST_F(FontFamilyTest, hasVSTableTest) { "Font " + testCase.fontPath + " shouldn't have a variation sequence table."); MinikinAutoUnref minikinFont( - new MinikinFontForTest(testCase.fontPath)); + MinikinFontForTest::createFromFile(testCase.fontPath)); MinikinAutoUnref family(new FontFamily); family->addFont(minikinFont.get()); android::AutoMutex _l(gMinikinLock); diff --git a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp index 5e560430c2..aa4cb34c05 100644 --- a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp @@ -38,13 +38,13 @@ public: TEST_F(HbFontCacheTest, getHbFontLockedTest) { MinikinAutoUnref fontA( - new MinikinFontForTest(kTestFontDir "Regular.ttf")); + MinikinFontForTest::createFromFile(kTestFontDir "Regular.ttf")); MinikinAutoUnref fontB( - new MinikinFontForTest(kTestFontDir "Bold.ttf")); + MinikinFontForTest::createFromFile(kTestFontDir "Bold.ttf")); MinikinAutoUnref fontC( - new MinikinFontForTest(kTestFontDir "BoldItalic.ttf")); + MinikinFontForTest::createFromFile(kTestFontDir "BoldItalic.ttf")); android::AutoMutex _l(gMinikinLock); // Never return NULL. @@ -66,7 +66,7 @@ TEST_F(HbFontCacheTest, getHbFontLockedTest) { TEST_F(HbFontCacheTest, purgeCacheTest) { MinikinAutoUnref minikinFont( - new MinikinFontForTest(kTestFontDir "Regular.ttf")); + MinikinFontForTest::createFromFile(kTestFontDir "Regular.ttf")); android::AutoMutex _l(gMinikinLock); hb_font_t* font = getHbFontLocked(minikinFont.get()); diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index b675620e25..246c87231a 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -77,11 +77,12 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { if (index == nullptr) { MinikinAutoUnref - minikinFont(new MinikinFontForTest(fontPath)); + minikinFont(MinikinFontForTest::createFromFile(fontPath)); family->addFont(minikinFont.get(), FontStyle(weight, italic)); } else { MinikinAutoUnref - minikinFont(new MinikinFontForTest(fontPath, atoi((const char*)index))); + minikinFont(MinikinFontForTest::createFromFileWithIndex(fontPath, + atoi((const char*)index))); family->addFont(minikinFont.get(), FontStyle(weight, italic)); } } diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index db4b8333f8..807b234296 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -18,31 +18,31 @@ #include +#include + #include -#include -#include -#include namespace minikin { -static int uniqueId = 0; // TODO: make thread safe if necessary. - -MinikinFontForTest::MinikinFontForTest(const std::string& font_path, int index) : - MinikinFont(uniqueId++), - mFontPath(font_path), - mFontIndex(index) { - int fd = open(font_path.c_str(), O_RDONLY); - LOG_ALWAYS_FATAL_IF(fd == -1); - struct stat st = {}; - LOG_ALWAYS_FATAL_IF(fstat(fd, &st) != 0); - mFontSize = st.st_size; - mFontData = mmap(NULL, mFontSize, PROT_READ, MAP_SHARED, fd, 0); - LOG_ALWAYS_FATAL_IF(mFontData == nullptr); - close(fd); +// static +MinikinFontForTest* MinikinFontForTest::createFromFile(const std::string& font_path) { + sk_sp typeface = SkTypeface::MakeFromFile(font_path.c_str()); + MinikinFontForTest* font = new MinikinFontForTest(font_path, std::move(typeface)); + return font; } -MinikinFontForTest::~MinikinFontForTest() { - munmap(mFontData, mFontSize); +// static +MinikinFontForTest* MinikinFontForTest::createFromFileWithIndex(const std::string& font_path, + int index) { + sk_sp typeface = SkTypeface::MakeFromFile(font_path.c_str(), index); + MinikinFontForTest* font = new MinikinFontForTest(font_path, std::move(typeface)); + return font; +} + +MinikinFontForTest::MinikinFontForTest(const std::string& font_path, sk_sp typeface) : + MinikinFont(typeface->uniqueID()), + mTypeface(std::move(typeface)), + mFontPath(font_path) { } float MinikinFontForTest::GetHorizontalAdvance(uint32_t /* glyph_id */, @@ -56,4 +56,20 @@ void MinikinFontForTest::GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph_ LOG_ALWAYS_FATAL("MinikinFontForTest::GetBounds is not yet implemented"); } +const void* MinikinFontForTest::GetTable(uint32_t tag, size_t* size, + MinikinDestroyFunc* destroy) { + const size_t tableSize = mTypeface->getTableSize(tag); + *size = tableSize; + if (tableSize == 0) { + return nullptr; + } + void* buf = malloc(tableSize); + if (buf == nullptr) { + return nullptr; + } + mTypeface->getTableData(tag, 0, tableSize, buf); + *destroy = free; + return buf; +} + } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index ee0eadbe0c..423792f8d5 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -18,6 +18,7 @@ #define MINIKIN_TEST_MINIKIN_FONT_FOR_TEST_H #include +#include class SkTypeface; @@ -25,28 +26,27 @@ namespace minikin { class MinikinFontForTest : public MinikinFont { public: - MinikinFontForTest(const std::string& font_path, int index); - MinikinFontForTest(const std::string& font_path) : MinikinFontForTest(font_path, 0) {} - virtual ~MinikinFontForTest(); + MinikinFontForTest(const std::string& font_path, sk_sp typeface); + + // Helper function for creating MinikinFontForTest instance from font file. + // Calller need to unref returned object. + static MinikinFontForTest* createFromFile(const std::string& font_path); + static MinikinFontForTest* createFromFileWithIndex(const std::string& font_path, int index); // MinikinFont overrides. float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const; void GetBounds(MinikinRect* bounds, uint32_t glyph_id, const MinikinPaint& paint) const; + const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy); const std::string& fontPath() const { return mFontPath; } - const void* GetFontData() const { return mFontData; } - size_t GetFontSize() const { return mFontSize; } - int GetFontIndex() const { return mFontIndex; } private: MinikinFontForTest() = delete; MinikinFontForTest(const MinikinFontForTest&) = delete; MinikinFontForTest& operator=(MinikinFontForTest&) = delete; + sk_sp mTypeface; const std::string mFontPath; - const int mFontIndex; - void* mFontData; - size_t mFontSize; }; } // namespace minikin From 6b9c9dec1fbd2f0440ea2a8de06a9827afb2e47e Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 15 Nov 2016 19:02:52 +0900 Subject: [PATCH 205/364] Implement word spacing Add a wordSpacing paint parameter, which will be used for justification. Bug: 31707212 Test: ran minikin_tests Change-Id: I91224ab8ef882ac0c87425c28ab731fead283612 --- engine/src/flutter/include/minikin/Layout.h | 2 +- .../src/flutter/include/minikin/MinikinFont.h | 5 +- engine/src/flutter/libs/minikin/Layout.cpp | 29 +- .../src/flutter/libs/minikin/LayoutUtils.cpp | 15 +- engine/src/flutter/libs/minikin/LayoutUtils.h | 5 + engine/src/flutter/tests/unittest/Android.mk | 2 + .../src/flutter/tests/unittest/LayoutTest.cpp | 343 ++++++++++++++++++ .../flutter/tests/util/MinikinFontForTest.cpp | 12 +- 8 files changed, 395 insertions(+), 18 deletions(-) create mode 100644 engine/src/flutter/tests/unittest/LayoutTest.cpp diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 87d5e0534b..625e05c433 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -145,7 +145,7 @@ private: bool isRtl, LayoutContext* ctx); // Append another layout (for example, cached value) into this one - void appendLayout(Layout* src, size_t start); + void appendLayout(Layout* src, size_t start, float extraAdvance); std::vector mGlyphs; std::vector mAdvances; diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index ac9235be8d..18848535d2 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -45,8 +45,8 @@ class MinikinFont; // Possibly move into own .h file? // Note: if you add a field here, either add it to LayoutCacheKey or to skipCache() struct MinikinPaint { - MinikinPaint() : font(0), size(0), scaleX(0), skewX(0), letterSpacing(0), paintFlags(0), - fakery(), fontFeatureSettings() { } + MinikinPaint() : font(0), size(0), scaleX(0), skewX(0), letterSpacing(0), wordSpacing(0), + paintFlags(0), fakery(), hyphenEdit(), fontFeatureSettings() { } bool skipCache() const { return !fontFeatureSettings.empty(); @@ -57,6 +57,7 @@ struct MinikinPaint { float scaleX; float skewX; float letterSpacing; + float wordSpacing; uint32_t paintFlags; FontFakery fakery; HyphenEdit hyphenEdit; diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 452718217f..a365411d8f 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -653,27 +653,38 @@ float Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size Layout* layout, float* advances) { LayoutCache& cache = LayoutEngine::getInstance().layoutCache; LayoutCacheKey key(collection, ctx->paint, ctx->style, buf, start, count, bufSize, isRtl); - bool skipCache = ctx->paint.skipCache(); - if (skipCache) { + + float wordSpacing = count == 1 && isWordSpace(buf[start]) ? ctx->paint.wordSpacing : 0; + + float advance; + if (ctx->paint.skipCache()) { Layout layoutForWord; key.doLayout(&layoutForWord, ctx, collection); if (layout) { - layout->appendLayout(&layoutForWord, bufStart); + layout->appendLayout(&layoutForWord, bufStart, wordSpacing); } if (advances) { layoutForWord.getAdvances(advances); } - return layoutForWord.getAdvance(); + advance = layoutForWord.getAdvance(); } else { Layout* layoutForWord = cache.get(key, ctx, collection); if (layout) { - layout->appendLayout(layoutForWord, bufStart); + layout->appendLayout(layoutForWord, bufStart, wordSpacing); } if (advances) { layoutForWord->getAdvances(advances); } - return layoutForWord->getAdvance(); + advance = layoutForWord->getAdvance(); } + + if (wordSpacing != 0) { + advance += wordSpacing; + if (advances) { + advances[0] += wordSpacing; + } + } + return advance; } static void addFeatures(const string &str, vector* features) { @@ -855,7 +866,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t mAdvance = x; } -void Layout::appendLayout(Layout* src, size_t start) { +void Layout::appendLayout(Layout* src, size_t start, float extraAdvance) { int fontMapStack[16]; int* fontMap; if (src->mFaces.size() < sizeof(fontMapStack) / sizeof(fontMapStack[0])) { @@ -879,11 +890,13 @@ void Layout::appendLayout(Layout* src, size_t start) { } for (size_t i = 0; i < src->mAdvances.size(); i++) { mAdvances[i + start] = src->mAdvances[i]; + if (i == 0) + mAdvances[i + start] += extraAdvance; } MinikinRect srcBounds(src->mBounds); srcBounds.offset(x0, 0); mBounds.join(srcBounds); - mAdvance += src->mAdvance; + mAdvance += src->mAdvance + extraAdvance; if (fontMap != fontMapStack) { delete[] fontMap; diff --git a/engine/src/flutter/libs/minikin/LayoutUtils.cpp b/engine/src/flutter/libs/minikin/LayoutUtils.cpp index 4e59afd6b2..a3238d448d 100644 --- a/engine/src/flutter/libs/minikin/LayoutUtils.cpp +++ b/engine/src/flutter/libs/minikin/LayoutUtils.cpp @@ -20,13 +20,22 @@ namespace minikin { +const uint16_t CHAR_NBSP = 0x00A0; + +/* + * Determine whether the code unit is a word space for the purposes of justification. + */ +bool isWordSpace(uint16_t code_unit) { + return code_unit == ' ' || code_unit == CHAR_NBSP; +} + /** * For the purpose of layout, a word break is a boundary with no * kerning or complex script processing. This is necessarily a * heuristic, but should be accurate most of the time. */ -static bool isWordBreakAfter(int c) { - if (c == ' ' || (c >= 0x2000 && c <= 0x200a) || c == 0x3000) { +static bool isWordBreakAfter(uint16_t c) { + if (isWordSpace(c) || (c >= 0x2000 && c <= 0x200a) || c == 0x3000) { // spaces return true; } @@ -34,7 +43,7 @@ static bool isWordBreakAfter(int c) { return false; } -static bool isWordBreakBefore(int c) { +static bool isWordBreakBefore(uint16_t c) { // CJK ideographs (and yijing hexagram symbols) return isWordBreakAfter(c) || (c >= 0x3400 && c <= 0x9fff); } diff --git a/engine/src/flutter/libs/minikin/LayoutUtils.h b/engine/src/flutter/libs/minikin/LayoutUtils.h index f35e843cfa..b89004cf19 100644 --- a/engine/src/flutter/libs/minikin/LayoutUtils.h +++ b/engine/src/flutter/libs/minikin/LayoutUtils.h @@ -21,6 +21,11 @@ namespace minikin { +/* + * Determine whether the code unit is a word space for the purposes of justification. + */ +bool isWordSpace(uint16_t code_unit); + /** * Return offset of previous word break. It is either < offset or == 0. * diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index a81d17cca7..61d845b01b 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -81,6 +81,7 @@ LOCAL_SRC_FILES += \ HbFontCacheTest.cpp \ MinikinInternalTest.cpp \ GraphemeBreakTests.cpp \ + LayoutTest.cpp \ LayoutUtilsTest.cpp \ UnicodeUtilsTest.cpp \ WordBreakerTests.cpp @@ -88,6 +89,7 @@ LOCAL_SRC_FILES += \ LOCAL_C_INCLUDES := \ $(LOCAL_PATH)/../../libs/minikin/ \ $(LOCAL_PATH)/../util \ + external/freetype/include \ external/harfbuzz_ng/src \ external/libxml2/include \ external/skia/src/core diff --git a/engine/src/flutter/tests/unittest/LayoutTest.cpp b/engine/src/flutter/tests/unittest/LayoutTest.cpp new file mode 100644 index 0000000000..c023625b16 --- /dev/null +++ b/engine/src/flutter/tests/unittest/LayoutTest.cpp @@ -0,0 +1,343 @@ +/* + * Copyright (C) 2016 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 + +#include "ICUTestBase.h" +#include "minikin/FontCollection.h" +#include "minikin/Layout.h" +#include "../util/FontTestUtils.h" +#include "../util/UnicodeUtils.h" + +const char* SYSTEM_FONT_PATH = "/system/fonts/"; +const char* SYSTEM_FONT_XML = "/system/etc/fonts.xml"; + +namespace minikin { + +const float UNTOUCHED_MARKER = 1e+38; + +static void expectAdvances(std::vector expected, float* advances, size_t length) { + EXPECT_LE(expected.size(), length); + for (size_t i = 0; i < expected.size(); ++i) { + EXPECT_EQ(expected[i], advances[i]) + << i << "th element is different. Expected: " << expected[i] + << ", Actual: " << advances[i]; + } + EXPECT_EQ(UNTOUCHED_MARKER, advances[expected.size()]); +} + +static void resetAdvances(float* advances, size_t length) { + for (size_t i = 0; i < length; ++i) { + advances[i] = UNTOUCHED_MARKER; + } +} + +class LayoutTest : public ICUTestBase { +protected: + LayoutTest() : mCollection(nullptr) { + } + + virtual ~LayoutTest() {} + + virtual void SetUp() override { + mCollection = getFontCollection(SYSTEM_FONT_PATH, SYSTEM_FONT_XML); + } + + virtual void TearDown() override { + mCollection->Unref(); + } + + FontCollection* mCollection; +}; + +TEST_F(LayoutTest, doLayoutTest) { + MinikinPaint paint; + MinikinRect rect; + const size_t kMaxAdvanceLength = 32; + float advances[kMaxAdvanceLength]; + std::vector expectedValues; + + Layout layout; + layout.setFontCollection(mCollection); + std::vector text; + + // The mock implementation returns 10.0f advance and 0,0-10x10 bounds for all glyph. + { + SCOPED_TRACE("one word"); + text = utf8ToUtf16("oneword"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(70.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(70.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } + { + SCOPED_TRACE("two words"); + text = utf8ToUtf16("two words"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(90.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(90.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } + { + SCOPED_TRACE("three words"); + text = utf8ToUtf16("three words test"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(160.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(160.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } + { + SCOPED_TRACE("two spaces"); + text = utf8ToUtf16("two spaces"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(110.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(110.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } +} + +TEST_F(LayoutTest, doLayoutTest_wordSpacing) { + MinikinPaint paint; + MinikinRect rect; + const size_t kMaxAdvanceLength = 32; + float advances[kMaxAdvanceLength]; + std::vector expectedValues; + std::vector text; + + Layout layout; + layout.setFontCollection(mCollection); + + paint.wordSpacing = 5.0f; + + // The mock implementation returns 10.0f advance and 0,0-10x10 bounds for all glyph. + { + SCOPED_TRACE("one word"); + text = utf8ToUtf16("oneword"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(70.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(70.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } + { + SCOPED_TRACE("two words"); + text = utf8ToUtf16("two words"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(95.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(95.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + EXPECT_EQ(UNTOUCHED_MARKER, advances[text.size()]); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectedValues[3] = 15.0f; + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } + { + SCOPED_TRACE("three words test"); + text = utf8ToUtf16("three words test"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(170.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(170.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectedValues[5] = 15.0f; + expectedValues[11] = 15.0f; + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } + { + SCOPED_TRACE("two spaces"); + text = utf8ToUtf16("two spaces"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(120.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(120.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectedValues[3] = 15.0f; + expectedValues[4] = 15.0f; + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } +} + +TEST_F(LayoutTest, doLayoutTest_negativeWordSpacing) { + MinikinPaint paint; + MinikinRect rect; + const size_t kMaxAdvanceLength = 32; + float advances[kMaxAdvanceLength]; + std::vector expectedValues; + + Layout layout; + layout.setFontCollection(mCollection); + std::vector text; + + // Negative word spacing also should work. + paint.wordSpacing = -5.0f; + + { + SCOPED_TRACE("one word"); + text = utf8ToUtf16("oneword"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(70.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(70.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } + { + SCOPED_TRACE("two words"); + text = utf8ToUtf16("two words"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(85.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(85.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectedValues[3] = 5.0f; + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } + { + SCOPED_TRACE("three words"); + text = utf8ToUtf16("three word test"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(140.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(140.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectedValues[5] = 5.0f; + expectedValues[10] = 5.0f; + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } + { + SCOPED_TRACE("two spaces"); + text = utf8ToUtf16("two spaces"); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(100.0f, layout.getAdvance()); + layout.getBounds(&rect); + EXPECT_EQ(0.0f, rect.mLeft); + EXPECT_EQ(0.0f, rect.mTop); + EXPECT_EQ(100.0f, rect.mRight); + EXPECT_EQ(10.0f, rect.mBottom); + resetAdvances(advances, kMaxAdvanceLength); + layout.getAdvances(advances); + expectedValues.resize(text.size()); + for (size_t i = 0; i < expectedValues.size(); ++i) { + expectedValues[i] = 10.0f; + } + expectedValues[3] = 5.0f; + expectedValues[4] = 5.0f; + expectAdvances(expectedValues, advances, kMaxAdvanceLength); + } +} + +// TODO: Add more test cases, e.g. measure text, letter spacing. + +} // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index 807b234296..fd5f564506 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -47,13 +47,17 @@ MinikinFontForTest::MinikinFontForTest(const std::string& font_path, sk_spmLeft = 0.0f; + bounds->mTop = 0.0f; + bounds->mRight = 10.0f; + bounds->mBottom = 10.0f; } const void* MinikinFontForTest::GetTable(uint32_t tag, size_t* size, From 7c620ba62dc2c7e6e055c34967db6e16164468da Mon Sep 17 00:00:00 2001 From: Martijn Coenen Date: Mon, 14 Nov 2016 16:47:18 +0100 Subject: [PATCH 206/364] Fix calls to deprecated range_x. Test: fixes master build. Change-Id: I8b2822d310c0cf423b15834e6d6ae3a9ea64233b --- engine/src/flutter/tests/perftests/FontCollection.cpp | 6 +++--- engine/src/flutter/tests/perftests/GraphemeBreak.cpp | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/engine/src/flutter/tests/perftests/FontCollection.cpp b/engine/src/flutter/tests/perftests/FontCollection.cpp index 490f5d85fe..a54607d183 100644 --- a/engine/src/flutter/tests/perftests/FontCollection.cpp +++ b/engine/src/flutter/tests/perftests/FontCollection.cpp @@ -30,8 +30,8 @@ static void BM_FontCollection_hasVariationSelector(benchmark::State& state) { MinikinAutoUnref collection( getFontCollection(SYSTEM_FONT_PATH, SYSTEM_FONT_XML)); - uint32_t baseCp = state.range_x(); - uint32_t vsCp = state.range_y(); + uint32_t baseCp = state.range(0); + uint32_t vsCp = state.range(1); char titleBuffer[64]; snprintf(titleBuffer, 64, "hasVariationSelector U+%04X,U+%04X", baseCp, vsCp); @@ -66,7 +66,7 @@ static void BM_FontCollection_itemize(benchmark::State& state) { MinikinAutoUnref collection( getFontCollection(SYSTEM_FONT_PATH, SYSTEM_FONT_XML)); - size_t testIndex = state.range_x(); + size_t testIndex = state.range(0); state.SetLabel("Itemize: " + ITEMIZE_TEST_CASES[testIndex].labelText); uint16_t buffer[64]; diff --git a/engine/src/flutter/tests/perftests/GraphemeBreak.cpp b/engine/src/flutter/tests/perftests/GraphemeBreak.cpp index 4db8f75d3d..cfee7c642c 100644 --- a/engine/src/flutter/tests/perftests/GraphemeBreak.cpp +++ b/engine/src/flutter/tests/perftests/GraphemeBreak.cpp @@ -36,7 +36,7 @@ static void BM_GraphemeBreak_Ascii(benchmark::State& state) { uint16_t buffer[12]; ParseUnicode(buffer, 12, ASCII_TEST_STR, &result_size, nullptr); LOG_ALWAYS_FATAL_IF(result_size != 12); - const size_t testIndex = state.range_x(); + const size_t testIndex = state.range(0); while (state.KeepRunning()) { GraphemeBreak::isGraphemeBreak(buffer, 0, result_size, testIndex); } @@ -51,7 +51,7 @@ static void BM_GraphemeBreak_Emoji(benchmark::State& state) { uint16_t buffer[12]; ParseUnicode(buffer, 12, EMOJI_TEST_STR, &result_size, nullptr); LOG_ALWAYS_FATAL_IF(result_size != 12); - const size_t testIndex = state.range_x(); + const size_t testIndex = state.range(0); while (state.KeepRunning()) { GraphemeBreak::isGraphemeBreak(buffer, 0, result_size, testIndex); } @@ -66,7 +66,7 @@ static void BM_GraphemeBreak_Emoji_Flags(benchmark::State& state) { uint16_t buffer[12]; ParseUnicode(buffer, 12, FLAGS_TEST_STR, &result_size, nullptr); LOG_ALWAYS_FATAL_IF(result_size != 12); - const size_t testIndex = state.range_x(); + const size_t testIndex = state.range(0); while (state.KeepRunning()) { GraphemeBreak::isGraphemeBreak(buffer, 0, result_size, testIndex); } From 964f053ea478eb5c7441f43c0d49996353e0211f Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 18 Oct 2016 11:21:59 +0900 Subject: [PATCH 207/364] Clean Up: Removing unused interface GetTable from MinikinFont. This is 2nd attempt of Ifcd7a348d7fb5af081192899dbcdfc7fb4eebbf9 After Id766ab16a8d342bf7322a90e076e801271d527d4, GetTable is no longer used in production due to poor performance and it is now only used in tests. This CL removes GetTable interface from MinikinFont and update tests code to use new interfaces, GetFontData, GetFontSize and GetFontIndex. Bug: 27860101 Test: Manually done Change-Id: Ib48973ff25cdc61a4c666d28128266df0aaea83e --- .../src/flutter/include/minikin/MinikinFont.h | 2 - .../src/flutter/libs/minikin/HbFontCache.cpp | 31 +++-------- .../unittest/FontCollectionItemizeTest.cpp | 20 +++---- .../tests/unittest/FontCollectionTest.cpp | 2 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 4 +- .../tests/unittest/HbFontCacheTest.cpp | 8 +-- .../src/flutter/tests/util/FontTestUtils.cpp | 5 +- .../flutter/tests/util/MinikinFontForTest.cpp | 54 +++++++------------ .../flutter/tests/util/MinikinFontForTest.h | 18 +++---- 9 files changed, 53 insertions(+), 91 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 18848535d2..353edd6566 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -110,8 +110,6 @@ public: virtual void GetBounds(MinikinRect* bounds, uint32_t glyph_id, const MinikinPaint &paint) const = 0; - virtual const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) = 0; - // Override if font can provide access to raw data virtual const void* GetFontData() const { return nullptr; diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index 45c3f5807b..3c6619d10a 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -28,22 +28,6 @@ namespace minikin { -static hb_blob_t* referenceTable(hb_face_t* /* face */, hb_tag_t tag, void* userData) { - MinikinFont* font = reinterpret_cast(userData); - MinikinDestroyFunc destroy = 0; - size_t size = 0; - const void* buffer = font->GetTable(tag, &size, &destroy); - if (buffer == nullptr) { - return nullptr; - } -#ifdef VERBOSE_DEBUG - ALOGD("referenceTable %c%c%c%c length=%zd", - (tag >>24)&0xff, (tag>>16)&0xff, (tag>>8)&0xff, tag&0xff, size); -#endif - return hb_blob_create(reinterpret_cast(buffer), size, - HB_MEMORY_MODE_READONLY, const_cast(buffer), destroy); -} - class HbFontCache : private android::OnEntryRemoved { public: HbFontCache() : mCache(kMaxEntries) { @@ -119,15 +103,12 @@ hb_font_t* getHbFontLocked(MinikinFont* minikinFont) { hb_face_t* face; const void* buf = minikinFont->GetFontData(); - if (buf == nullptr) { - face = hb_face_create_for_tables(referenceTable, minikinFont, nullptr); - } else { - size_t size = minikinFont->GetFontSize(); - hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, - HB_MEMORY_MODE_READONLY, nullptr, nullptr); - face = hb_face_create(blob, minikinFont->GetFontIndex()); - hb_blob_destroy(blob); - } + size_t size = minikinFont->GetFontSize(); + hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, + HB_MEMORY_MODE_READONLY, nullptr, nullptr); + face = hb_face_create(blob, minikinFont->GetFontIndex()); + hb_blob_destroy(blob); + hb_font_t* parent_font = hb_font_create(face); hb_ot_font_set_funcs(parent_font); diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 978ba9f499..02bc03bbe6 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -669,12 +669,12 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { std::vector families; FontFamily* family1 = new FontFamily(VARIANT_DEFAULT); - MinikinAutoUnref font(MinikinFontForTest::createFromFile(kLatinFont)); + MinikinAutoUnref font(new MinikinFontForTest(kLatinFont)); family1->addFont(font.get()); families.push_back(family1); FontFamily* family2 = new FontFamily(VARIANT_DEFAULT); - MinikinAutoUnref font2(MinikinFontForTest::createFromFile(kVSTestFont)); + MinikinAutoUnref font2(new MinikinFontForTest(kVSTestFont)); family2->addFont(font2.get()); families.push_back(family2); @@ -800,7 +800,7 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { FontFamily* firstFamily = new FontFamily( FontStyle::registerLanguageList("und"), 0 /* variant */); MinikinAutoUnref firstFamilyMinikinFont( - MinikinFontForTest::createFromFile(kNoGlyphFont)); + new MinikinFontForTest(kNoGlyphFont)); firstFamily->addFont(firstFamilyMinikinFont.get()); families.push_back(firstFamily); @@ -812,7 +812,7 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { for (size_t i = 0; i < testCase.fontLanguages.size(); ++i) { FontFamily* family = new FontFamily( FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */); - MinikinAutoUnref minikin_font(MinikinFontForTest::createFromFile(kJAFont)); + MinikinAutoUnref minikin_font(new MinikinFontForTest(kJAFont)); family->addFont(minikin_font.get()); families.push_back(family); fontLangIdxMap.insert(std::make_pair(minikin_font.get(), i)); @@ -1399,9 +1399,9 @@ TEST_F(FontCollectionItemizeTest, itemize_genderBalancedEmoji) { TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS) { const FontStyle kDefaultFontStyle; - MinikinAutoUnref dummyFont(MinikinFontForTest::createFromFile(kNoGlyphFont)); - MinikinAutoUnref fontA(MinikinFontForTest::createFromFile(kZH_HansFont)); - MinikinAutoUnref fontB(MinikinFontForTest::createFromFile(kZH_HansFont)); + MinikinAutoUnref dummyFont(new MinikinFontForTest(kNoGlyphFont)); + MinikinAutoUnref fontA(new MinikinFontForTest(kZH_HansFont)); + MinikinAutoUnref fontB(new MinikinFontForTest(kZH_HansFont)); MinikinAutoUnref dummyFamily(new FontFamily()); MinikinAutoUnref familyA(new FontFamily()); @@ -1433,11 +1433,11 @@ TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS) { TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS2) { const FontStyle kDefaultFontStyle; - MinikinAutoUnref dummyFont(MinikinFontForTest::createFromFile(kNoGlyphFont)); + MinikinAutoUnref dummyFont(new MinikinFontForTest(kNoGlyphFont)); MinikinAutoUnref hasCmapFormat14Font( - MinikinFontForTest::createFromFile(kHasCmapFormat14Font)); + new MinikinFontForTest(kHasCmapFormat14Font)); MinikinAutoUnref noCmapFormat14Font( - MinikinFontForTest::createFromFile(kNoCmapFormat14Font)); + new MinikinFontForTest(kNoCmapFormat14Font)); MinikinAutoUnref dummyFamily(new FontFamily()); MinikinAutoUnref hasCmapFormat14Family(new FontFamily()); diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index ef2da66b2b..62d2f022fa 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -58,7 +58,7 @@ void expectVSGlyphs(const FontCollection* fc, uint32_t codepoint, const std::set TEST(FontCollectionTest, hasVariationSelectorTest) { MinikinAutoUnref family(new FontFamily()); - MinikinAutoUnref font(MinikinFontForTest::createFromFile(kVsTestFont)); + MinikinAutoUnref font(new MinikinFontForTest(kVsTestFont)); family->addFont(font.get()); std::vector families({family.get()}); MinikinAutoUnref fc(new FontCollection(families)); diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 69fef23da8..4aaa601a23 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -351,7 +351,7 @@ void expectVSGlyphs(FontFamily* family, uint32_t codepoint, const std::set - minikinFont(MinikinFontForTest::createFromFile(kVsTestFont)); + minikinFont(new MinikinFontForTest(kVsTestFont)); MinikinAutoUnref family(new FontFamily); family->addFont(minikinFont.get()); @@ -405,7 +405,7 @@ TEST_F(FontFamilyTest, hasVSTableTest) { "Font " + testCase.fontPath + " shouldn't have a variation sequence table."); MinikinAutoUnref minikinFont( - MinikinFontForTest::createFromFile(testCase.fontPath)); + new MinikinFontForTest(testCase.fontPath)); MinikinAutoUnref family(new FontFamily); family->addFont(minikinFont.get()); android::AutoMutex _l(gMinikinLock); diff --git a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp index aa4cb34c05..5e560430c2 100644 --- a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp @@ -38,13 +38,13 @@ public: TEST_F(HbFontCacheTest, getHbFontLockedTest) { MinikinAutoUnref fontA( - MinikinFontForTest::createFromFile(kTestFontDir "Regular.ttf")); + new MinikinFontForTest(kTestFontDir "Regular.ttf")); MinikinAutoUnref fontB( - MinikinFontForTest::createFromFile(kTestFontDir "Bold.ttf")); + new MinikinFontForTest(kTestFontDir "Bold.ttf")); MinikinAutoUnref fontC( - MinikinFontForTest::createFromFile(kTestFontDir "BoldItalic.ttf")); + new MinikinFontForTest(kTestFontDir "BoldItalic.ttf")); android::AutoMutex _l(gMinikinLock); // Never return NULL. @@ -66,7 +66,7 @@ TEST_F(HbFontCacheTest, getHbFontLockedTest) { TEST_F(HbFontCacheTest, purgeCacheTest) { MinikinAutoUnref minikinFont( - MinikinFontForTest::createFromFile(kTestFontDir "Regular.ttf")); + new MinikinFontForTest(kTestFontDir "Regular.ttf")); android::AutoMutex _l(gMinikinLock); hb_font_t* font = getHbFontLocked(minikinFont.get()); diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index 246c87231a..b675620e25 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -77,12 +77,11 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { if (index == nullptr) { MinikinAutoUnref - minikinFont(MinikinFontForTest::createFromFile(fontPath)); + minikinFont(new MinikinFontForTest(fontPath)); family->addFont(minikinFont.get(), FontStyle(weight, italic)); } else { MinikinAutoUnref - minikinFont(MinikinFontForTest::createFromFileWithIndex(fontPath, - atoi((const char*)index))); + minikinFont(new MinikinFontForTest(fontPath, atoi((const char*)index))); family->addFont(minikinFont.get(), FontStyle(weight, italic)); } } diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index fd5f564506..a6abc1e167 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -18,31 +18,31 @@ #include -#include - #include +#include +#include +#include namespace minikin { -// static -MinikinFontForTest* MinikinFontForTest::createFromFile(const std::string& font_path) { - sk_sp typeface = SkTypeface::MakeFromFile(font_path.c_str()); - MinikinFontForTest* font = new MinikinFontForTest(font_path, std::move(typeface)); - return font; +static int uniqueId = 0; // TODO: make thread safe if necessary. + +MinikinFontForTest::MinikinFontForTest(const std::string& font_path, int index) : + MinikinFont(uniqueId++), + mFontPath(font_path), + mFontIndex(index) { + int fd = open(font_path.c_str(), O_RDONLY); + LOG_ALWAYS_FATAL_IF(fd == -1); + struct stat st = {}; + LOG_ALWAYS_FATAL_IF(fstat(fd, &st) != 0); + mFontSize = st.st_size; + mFontData = mmap(NULL, mFontSize, PROT_READ, MAP_SHARED, fd, 0); + LOG_ALWAYS_FATAL_IF(mFontData == nullptr); + close(fd); } -// static -MinikinFontForTest* MinikinFontForTest::createFromFileWithIndex(const std::string& font_path, - int index) { - sk_sp typeface = SkTypeface::MakeFromFile(font_path.c_str(), index); - MinikinFontForTest* font = new MinikinFontForTest(font_path, std::move(typeface)); - return font; -} - -MinikinFontForTest::MinikinFontForTest(const std::string& font_path, sk_sp typeface) : - MinikinFont(typeface->uniqueID()), - mTypeface(std::move(typeface)), - mFontPath(font_path) { +MinikinFontForTest::~MinikinFontForTest() { + munmap(mFontData, mFontSize); } float MinikinFontForTest::GetHorizontalAdvance(uint32_t /* glyph_id */, @@ -60,20 +60,4 @@ void MinikinFontForTest::GetBounds(MinikinRect* bounds, uint32_t /* glyph_id */, bounds->mBottom = 10.0f; } -const void* MinikinFontForTest::GetTable(uint32_t tag, size_t* size, - MinikinDestroyFunc* destroy) { - const size_t tableSize = mTypeface->getTableSize(tag); - *size = tableSize; - if (tableSize == 0) { - return nullptr; - } - void* buf = malloc(tableSize); - if (buf == nullptr) { - return nullptr; - } - mTypeface->getTableData(tag, 0, tableSize, buf); - *destroy = free; - return buf; -} - } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index 423792f8d5..ee0eadbe0c 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -18,7 +18,6 @@ #define MINIKIN_TEST_MINIKIN_FONT_FOR_TEST_H #include -#include class SkTypeface; @@ -26,27 +25,28 @@ namespace minikin { class MinikinFontForTest : public MinikinFont { public: - MinikinFontForTest(const std::string& font_path, sk_sp typeface); - - // Helper function for creating MinikinFontForTest instance from font file. - // Calller need to unref returned object. - static MinikinFontForTest* createFromFile(const std::string& font_path); - static MinikinFontForTest* createFromFileWithIndex(const std::string& font_path, int index); + MinikinFontForTest(const std::string& font_path, int index); + MinikinFontForTest(const std::string& font_path) : MinikinFontForTest(font_path, 0) {} + virtual ~MinikinFontForTest(); // MinikinFont overrides. float GetHorizontalAdvance(uint32_t glyph_id, const MinikinPaint &paint) const; void GetBounds(MinikinRect* bounds, uint32_t glyph_id, const MinikinPaint& paint) const; - const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy); const std::string& fontPath() const { return mFontPath; } + const void* GetFontData() const { return mFontData; } + size_t GetFontSize() const { return mFontSize; } + int GetFontIndex() const { return mFontIndex; } private: MinikinFontForTest() = delete; MinikinFontForTest(const MinikinFontForTest&) = delete; MinikinFontForTest& operator=(MinikinFontForTest&) = delete; - sk_sp mTypeface; const std::string mFontPath; + const int mFontIndex; + void* mFontData; + size_t mFontSize; }; } // namespace minikin From 9bc8f531178afecfeb5b9de35118b8574b10f488 Mon Sep 17 00:00:00 2001 From: yirui Date: Mon, 12 Sep 2016 10:37:11 +0900 Subject: [PATCH 208/364] Parse Emoji subtag and store it to FontLanguage Parse Emoji subtag and store into 4 different styles: default, text, color and empty. Replace hasEmojiFlag function with getEmojiStyle to get effective status according to script and subtag. However, score calculation for the font selection needs to be completed in the next stage. No performance regression is observed with this CL. Bug: 31608997 Test: Done by unittests. Change-Id: I923243641c946248dd5a0aa9fb9c940515310d34 --- .../flutter/libs/minikin/FontCollection.cpp | 2 +- .../src/flutter/libs/minikin/FontFamily.cpp | 2 +- .../src/flutter/libs/minikin/FontLanguage.cpp | 45 ++++++- .../src/flutter/libs/minikin/FontLanguage.h | 40 ++++-- .../flutter/tests/perftests/FontLanguage.cpp | 7 ++ .../flutter/tests/unittest/FontFamilyTest.cpp | 119 +++++++++++++++++- .../src/flutter/tests/unittest/how_to_run.txt | 2 +- 7 files changed, 194 insertions(+), 23 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 19ad7523f7..5bc3634e82 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -219,7 +219,7 @@ uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* const FontLanguages& langs = FontLanguageListCache::getById(fontFamily->langId()); bool hasEmojiFlag = false; for (size_t i = 0; i < langs.size(); ++i) { - if (langs[i].hasEmojiFlag()) { + if (langs[i].getEmojiStyle() == FontLanguage::EMSTYLE_EMOJI) { hasEmojiFlag = true; break; } diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index f41a20a4f9..f5f397681a 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -161,7 +161,7 @@ FontStyle FontFamily::getStyle(size_t index) const { bool FontFamily::isColorEmojiFamily() const { const FontLanguages& languageList = FontLanguageListCache::getById(mLangId); for (size_t i = 0; i < languageList.size(); ++i) { - if (languageList[i].hasEmojiFlag()) { + if (languageList[i].getEmojiStyle() == FontLanguage::EMSTYLE_EMOJI) { return true; } } diff --git a/engine/src/flutter/libs/minikin/FontLanguage.cpp b/engine/src/flutter/libs/minikin/FontLanguage.cpp index 9cfa0aa664..fca4cdbfcd 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguage.cpp @@ -18,7 +18,9 @@ #include "FontLanguage.h" +#include #include +#include #include namespace minikin { @@ -27,6 +29,18 @@ namespace minikin { (((uint32_t)(c1)) << 24 | ((uint32_t)(c2)) << 16 | ((uint32_t)(c3)) << 8 | \ ((uint32_t)(c4))) +// Check if a language code supports emoji according to its subtag +static bool isEmojiSubtag(const char* buf, size_t bufLen, const char* subtag, size_t subtagLen) { + if (bufLen < subtagLen) { + return false; + } + if (strncmp(buf, subtag, subtagLen) != 0) { + return false; // no match between two strings + } + return (bufLen == subtagLen || buf[subtagLen] == '\0' || + buf[subtagLen] == '-' || buf[subtagLen] == '_'); +} + // Parse BCP 47 language identifier into internal structure FontLanguage::FontLanguage(const char* buf, size_t length) : FontLanguage() { size_t i; @@ -53,8 +67,34 @@ FontLanguage::FontLanguage(const char* buf, size_t length) : FontLanguage() { mScript = SCRIPT_TAG(buf[i], buf[i + 1], buf[i + 2], buf[i + 3]); } } - mSubScriptBits = scriptToSubScriptBits(mScript); + + if (mScript == SCRIPT_TAG('Z', 's', 'y', 'e')) { + mEmojiStyle = EMSTYLE_EMOJI; + } else if (mScript == SCRIPT_TAG('Z', 's', 'y', 'm')) { + mEmojiStyle = EMSTYLE_TEXT; + } + // 10 is the length of "-u-em-text", which is the shortest emoji subtag, + // unnecessary comparison can be avoided if total length is smaller than 10. + const size_t kMinSubtagLength = 10; + if (length < kMinSubtagLength) { + return; + } + + static const char kPrefix[] = "-u-em-"; + const char *pos = std::search(buf, buf + length, kPrefix, kPrefix + strlen(kPrefix)); + if (pos == buf + length) { + return; + } + pos += strlen(kPrefix); + const size_t remainingLength = length - (pos - buf); + if (isEmojiSubtag(pos, remainingLength, "emoji", 5)){ + mEmojiStyle = EMSTYLE_EMOJI; + } else if (isEmojiSubtag(pos, remainingLength, "text", 4)){ + mEmojiStyle = EMSTYLE_TEXT; + } else if (isEmojiSubtag(pos, remainingLength, "default", 7)){ + mEmojiStyle = EMSTYLE_DEFAULT; + } } //static @@ -95,9 +135,6 @@ uint8_t FontLanguage::scriptToSubScriptBits(uint32_t script) { case SCRIPT_TAG('K', 'o', 'r', 'e'): subScriptBits = kHanFlag | kHangulFlag; break; - case SCRIPT_TAG('Z', 's', 'y', 'e'): - subScriptBits = kEmojiFlag; - break; } return subScriptBits; } diff --git a/engine/src/flutter/libs/minikin/FontLanguage.h b/engine/src/flutter/libs/minikin/FontLanguage.h index b1bb6eb5f9..25a5cc3dfa 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.h +++ b/engine/src/flutter/libs/minikin/FontLanguage.h @@ -34,14 +34,25 @@ class FontLanguages; // font rendering. struct FontLanguage { public: + enum EmojiStyle : uint8_t { + EMSTYLE_EMPTY = 0, + EMSTYLE_DEFAULT = 1, + EMSTYLE_EMOJI = 2, + EMSTYLE_TEXT = 3, + }; // Default constructor creates the unsupported language. - FontLanguage() : mScript(0ul), mLanguage(0ul), mSubScriptBits(0ul) {} + FontLanguage() + : mScript(0ul), + mLanguage(0ul), + mSubScriptBits(0ul), + mEmojiStyle(EMSTYLE_EMPTY) {} // Parse from string FontLanguage(const char* buf, size_t length); bool operator==(const FontLanguage other) const { - return !isUnsupported() && isEqualScript(other) && mLanguage == other.mLanguage; + return !isUnsupported() && isEqualScript(other) && mLanguage == other.mLanguage && + mEmojiStyle == other.mEmojiStyle; } bool operator!=(const FontLanguage other) const { @@ -49,7 +60,7 @@ public: } bool isUnsupported() const { return mLanguage == 0ul; } - bool hasEmojiFlag() const { return mSubScriptBits & kEmojiFlag; } + EmojiStyle getEmojiStyle() const { return mEmojiStyle; } bool isEqualScript(const FontLanguage& other) const; @@ -64,7 +75,9 @@ public: // 0 = no match, 1 = script match, 2 = script and primary language match. int calcScoreFor(const FontLanguages& supported) const; - uint64_t getIdentifier() const { return (uint64_t)mScript << 32 | (uint64_t)mLanguage; } + uint64_t getIdentifier() const { + return (uint64_t)mScript << 32 | (uint64_t)mEmojiStyle << 24 | (uint64_t)mLanguage; + } private: friend class FontLanguages; // for FontLanguages constructor @@ -73,21 +86,22 @@ private: uint32_t mScript; // ISO 639-1 or ISO 639-2 compliant language code. - // The two or three letter language code is packed into 32 bit integer. + // The two or three letter language code is packed into 24 bit integer. // mLanguage = 0 means the FontLanguage is unsupported. uint32_t mLanguage; - // For faster comparing, use 8 bits for specific scripts. + // For faster comparing, use 7 bits for specific scripts. static const uint8_t kBopomofoFlag = 1u; - static const uint8_t kEmojiFlag = 1u << 1; - static const uint8_t kHanFlag = 1u << 2; - static const uint8_t kHangulFlag = 1u << 3; - static const uint8_t kHiraganaFlag = 1u << 4; - static const uint8_t kKatakanaFlag = 1u << 5; - static const uint8_t kSimplifiedChineseFlag = 1u << 6; - static const uint8_t kTraditionalChineseFlag = 1u << 7; + static const uint8_t kHanFlag = 1u << 1; + static const uint8_t kHangulFlag = 1u << 2; + static const uint8_t kHiraganaFlag = 1u << 3; + static const uint8_t kKatakanaFlag = 1u << 4; + static const uint8_t kSimplifiedChineseFlag = 1u << 5; + static const uint8_t kTraditionalChineseFlag = 1u << 6; uint8_t mSubScriptBits; + EmojiStyle mEmojiStyle; + static uint8_t scriptToSubScriptBits(uint32_t script); // Returns true if the provide subscript bits has the requested subscript bits. diff --git a/engine/src/flutter/tests/perftests/FontLanguage.cpp b/engine/src/flutter/tests/perftests/FontLanguage.cpp index 8f77e12b75..6c9c84de88 100644 --- a/engine/src/flutter/tests/perftests/FontLanguage.cpp +++ b/engine/src/flutter/tests/perftests/FontLanguage.cpp @@ -33,4 +33,11 @@ static void BM_FontLanguage_en_Latn_US(benchmark::State& state) { } BENCHMARK(BM_FontLanguage_en_Latn_US); +static void BM_FontLanguage_en_Latn_US_u_em_emoji(benchmark::State& state) { + while (state.KeepRunning()) { + FontLanguage language("en-Latn-US-u-em-emoji", 21); + } +} +BENCHMARK(BM_FontLanguage_en_Latn_US_u_em_emoji); + } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 4aaa601a23..95151a2163 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -269,17 +269,130 @@ TEST_F(FontLanguagesTest, repeatedLanguageTests) { TEST_F(FontLanguagesTest, undEmojiTests) { FontLanguage emoji = createFontLanguage("und-Zsye"); - EXPECT_TRUE(emoji.hasEmojiFlag()); + EXPECT_EQ(FontLanguage::EMSTYLE_EMOJI, emoji.getEmojiStyle()); FontLanguage und = createFontLanguage("und"); - EXPECT_FALSE(und.hasEmojiFlag()); + EXPECT_EQ(FontLanguage::EMSTYLE_EMPTY, und.getEmojiStyle()); EXPECT_FALSE(emoji == und); FontLanguage undExample = createFontLanguage("und-example"); - EXPECT_FALSE(undExample.hasEmojiFlag()); + EXPECT_EQ(FontLanguage::EMSTYLE_EMPTY, undExample.getEmojiStyle()); EXPECT_FALSE(emoji == undExample); } +TEST_F(FontLanguagesTest, subtagEmojiTest) { + std::string subtagEmojiStrings[] = { + // Duplicate subtag case. + "und-Latn-u-em-emoji-u-em-text", + + // Strings that contain language. + "und-u-em-emoji", + "en-u-em-emoji", + + // Strings that contain the script. + "und-Jpan-u-em-emoji", + "en-Latn-u-em-emoji", + "und-Zsym-u-em-emoji", + "und-Zsye-u-em-emoji", + "en-Zsym-u-em-emoji", + "en-Zsye-u-em-emoji", + + // Strings that contain the county. + "und-US-u-em-emoji", + "en-US-u-em-emoji", + "und-Latn-US-u-em-emoji", + "en-Zsym-US-u-em-emoji", + "en-Zsye-US-u-em-emoji", + }; + + for (auto subtagEmojiString : subtagEmojiStrings) { + SCOPED_TRACE("Test for \"" + subtagEmojiString + "\""); + FontLanguage subtagEmoji = createFontLanguage(subtagEmojiString); + EXPECT_EQ(FontLanguage::EMSTYLE_EMOJI, subtagEmoji.getEmojiStyle()); + } +} + +TEST_F(FontLanguagesTest, subtagTextTest) { + std::string subtagTextStrings[] = { + // Duplicate subtag case. + "und-Latn-u-em-text-u-em-emoji", + + // Strings that contain language. + "und-u-em-text", + "en-u-em-text", + + // Strings that contain the script. + "und-Latn-u-em-text", + "en-Jpan-u-em-text", + "und-Zsym-u-em-text", + "und-Zsye-u-em-text", + "en-Zsym-u-em-text", + "en-Zsye-u-em-text", + + // Strings that contain the county. + "und-US-u-em-text", + "en-US-u-em-text", + "und-Latn-US-u-em-text", + "en-Zsym-US-u-em-text", + "en-Zsye-US-u-em-text", + }; + + for (auto subtagTextString : subtagTextStrings) { + SCOPED_TRACE("Test for \"" + subtagTextString + "\""); + FontLanguage subtagText = createFontLanguage(subtagTextString); + EXPECT_EQ(FontLanguage::EMSTYLE_TEXT, subtagText.getEmojiStyle()); + } +} + +// TODO: add more "und" language cases whose language and script are +// unexpectedly translated to en-Latn by ICU. +TEST_F(FontLanguagesTest, subtagDefaultTest) { + std::string subtagDefaultStrings[] = { + // Duplicate subtag case. + "en-Latn-u-em-default-u-em-emoji", + "en-Latn-u-em-default-u-em-text", + + // Strings that contain language. + "und-u-em-default", + "en-u-em-default", + + // Strings that contain the script. + "en-Latn-u-em-default", + "en-Zsym-u-em-default", + "en-Zsye-u-em-default", + + // Strings that contain the county. + "en-US-u-em-default", + "en-Latn-US-u-em-default", + "en-Zsym-US-u-em-default", + "en-Zsye-US-u-em-default", + }; + + for (auto subtagDefaultString : subtagDefaultStrings) { + SCOPED_TRACE("Test for \"" + subtagDefaultString + "\""); + FontLanguage subtagDefault = createFontLanguage(subtagDefaultString); + EXPECT_EQ(FontLanguage::EMSTYLE_DEFAULT, subtagDefault.getEmojiStyle()); + } +} + +TEST_F(FontLanguagesTest, subtagEmptyTest) { + std::string subtagEmptyStrings[] = { + "und", + "jp", + "en-US", + "en-Latn", + "en-Latn-US", + "en-Latn-US-u-em", + "en-Latn-US-u-em-defaultemoji", + }; + + for (auto subtagEmptyString : subtagEmptyStrings) { + SCOPED_TRACE("Test for \"" + subtagEmptyString + "\""); + FontLanguage subtagEmpty = createFontLanguage(subtagEmptyString); + EXPECT_EQ(FontLanguage::EMSTYLE_EMPTY, subtagEmpty.getEmojiStyle()); + } +} + TEST_F(FontLanguagesTest, registerLanguageListTest) { EXPECT_EQ(0UL, FontStyle::registerLanguageList("")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en")); diff --git a/engine/src/flutter/tests/unittest/how_to_run.txt b/engine/src/flutter/tests/unittest/how_to_run.txt index c90c6640bd..4adfcb8d05 100644 --- a/engine/src/flutter/tests/unittest/how_to_run.txt +++ b/engine/src/flutter/tests/unittest/how_to_run.txt @@ -1,4 +1,4 @@ -mmm -j8 frameworks/minikin/tests/unittests && +mmm -j8 frameworks/minikin/tests/unittest && adb push $OUT/data/nativetest/minikin_tests/minikin_tests \ /data/nativetest/minikin_tests/minikin_tests && adb push frameworks/minikin/tests/data /data/nativetest/minikin_tests/ && From ccce2fd909ad4086c6fc1a7ffc09659646bdd4fb Mon Sep 17 00:00:00 2001 From: Hal Canary Date: Thu, 24 Nov 2016 12:06:33 -0500 Subject: [PATCH 209/364] SkImageEncoder->SkEncodeImage Test: none Change-Id: I9115c41f1699ab5d9d677251d96ea8f4fb844845 --- engine/src/flutter/sample/example_skia.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index 5e15a107c2..b04c8abcbc 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -141,7 +141,8 @@ int runMinikinTest() { paint.setStyle(SkPaint::kFill_Style); drawToSkia(&canvas, &paint, &layout, 10, 300); - SkImageEncoder::EncodeFile("/data/local/tmp/foo.png", bitmap, SkImageEncoder::kPNG_Type, 100); + SkFILEWStream file("/data/local/tmp/foo.png"); + SkEncodeImage(&file, bitmap, SkEncodedImageFormat::kPNG, 100); return 0; } From be7c33a74ed7a8a30d4ff6d8cbfa1308050256a7 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Fri, 2 Dec 2016 18:04:42 -0800 Subject: [PATCH 210/364] Move LOCAL_PICKUP_FILES out of $OUT/data minikin_tests was copying its test data to $OUT/data/DATA/nativetest/minikin_test, and then packaging that with LOCAL_PICKUP_FILES=$OUT/data/DATA, which would also pick up anything any other module copyied to $OUT/data/DATA. $OUT/data/DATA isn't where the tests expect to find their data, they look in /data/nativetest/minikin_test. Copy the files to the intermediates directory instead. A future change will install LOCAL_PICKUP_FILES for local builds to the correct place, so adb sync and adb shell /data/nativetest/minikin_tests/minikin_tests will run the tests. Test: mma -j Change-Id: I808ce743f51e5ccac711e22821e7e0d7cd94ffdf --- engine/src/flutter/tests/Android.mk | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index b33631eb28..bcc49193d5 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -18,11 +18,6 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) -data_root_for_test_zip := $(TARGET_OUT_DATA)/DATA/ -minikin_tests_subpath_from_data := nativetest/minikin_tests -minikin_tests_root_in_device := /data/$(minikin_tests_subpath_from_data) -minikin_tests_root_for_test_zip := $(data_root_for_test_zip)/$(minikin_tests_subpath_from_data) - font_src_files := \ data/BoldItalic.ttf \ data/Bold.ttf \ @@ -43,6 +38,12 @@ font_src_files := \ LOCAL_MODULE := minikin_tests LOCAL_MODULE_TAGS := tests +LOCAL_MODULE_CLASS := NATIVE_TESTS + +data_root_for_test_zip := $(local-intermediates-dir)/DATA +minikin_tests_subpath_from_data := nativetest/minikin_tests +minikin_tests_root_in_device := /data/$(minikin_tests_subpath_from_data) +minikin_tests_root_for_test_zip := $(data_root_for_test_zip)/$(minikin_tests_subpath_from_data) GEN := $(addprefix $(minikin_tests_root_for_test_zip)/, $(font_src_files)) $(GEN): PRIVATE_PATH := $(LOCAL_PATH) From f20a2ef2715ef026763e7b639788ccdad4ed5dc4 Mon Sep 17 00:00:00 2001 From: Yirui Huang Date: Thu, 15 Sep 2016 18:04:34 +0900 Subject: [PATCH 211/364] Change language score calculation Change language score calculation in the calculation of the font family. Instead of language and script matching, a match in subtag is added. In addition, a match in subtag has a higher priority than a match in script. The score levels are divided into 5 score levels and the limit of the number of font languages is changed to 12 from 17. Multiple languages selection rule could to be added in the future. Bug: 31608997 Test: Done by unittests. Change-Id: I1e7177095f604fd1794bc99ca36c705dcb4c56e7 --- .../flutter/libs/minikin/FontCollection.cpp | 20 ++++++----- .../src/flutter/libs/minikin/FontLanguage.cpp | 35 +++++++++++++------ .../src/flutter/libs/minikin/FontLanguage.h | 4 +-- .../unittest/FontCollectionItemizeTest.cpp | 14 ++++++++ 4 files changed, 51 insertions(+), 22 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 5bc3634e82..291833c553 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -234,22 +234,24 @@ uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* return 1; } -// Calculates font scores based on the script matching and primary langauge matching. +// Calculate font scores based on the script matching, subtag matching and primary langauge matching. // -// If the font's script doesn't support the requested script, the font gets a score of 0. If the -// font's script supports the requested script and the font has the same primary language as the -// requested one, the font gets a score of 2. If the font's script supports the requested script -// but the primary language is different from the requested one, the font gets a score of 1. +// 1. If only the font's language matches or there is no matches between requested font and +// supported font, then the font obtains a score of 0. +// 2. Without a match in language, considering subtag may change font's EmojiStyle over script, +// a match in subtag gets a score of 2 and a match in scripts gains a score of 1. +// 3. Regarding to two elements matchings, language-and-subtag matching has a score of 4, while +// language-and-script obtains a socre of 3 with the same reason above. // // If two languages in the requested list have the same language score, the font matching with // higher priority language gets a higher score. For example, in the case the user requested // language list is "ja-Jpan,en-Latn". The score of for the font of "ja-Jpan" gets a higher score // than the font of "en-Latn". // -// To achieve the above two conditions, the language score is determined as follows: -// LanguageScore = s(0) * 3^(m - 1) + s(1) * 3^(m - 2) + ... + s(m - 2) * 3 + s(m - 1) +// To achieve score calculation with priorities, the language score is determined as follows: +// LanguageScore = s(0) * 5^(m - 1) + s(1) * 5^(m - 2) + ... + s(m - 2) * 5 + s(m - 1) // Here, m is the maximum number of languages to be compared, and s(i) is the i-th language's -// matching score. The possible values of s(i) are 0, 1 and 2. +// matching score. The possible values of s(i) are 0, 1, 2, 3 and 4. uint32_t FontCollection::calcLanguageMatchingScore( uint32_t userLangListId, const FontFamily& fontFamily) { const FontLanguages& langList = FontLanguageListCache::getById(userLangListId); @@ -258,7 +260,7 @@ uint32_t FontCollection::calcLanguageMatchingScore( const size_t maxCompareNum = std::min(langList.size(), FONT_LANGUAGES_LIMIT); uint32_t score = 0; for (size_t i = 0; i < maxCompareNum; ++i) { - score = score * 3u + langList[i].calcScoreFor(fontLanguages); + score = score * 5u + langList[i].calcScoreFor(fontLanguages); } return score; } diff --git a/engine/src/flutter/libs/minikin/FontLanguage.cpp b/engine/src/flutter/libs/minikin/FontLanguage.cpp index fca4cdbfcd..c6ddda5ae9 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguage.cpp @@ -176,28 +176,41 @@ bool FontLanguage::supportsHbScript(hb_script_t script) const { } int FontLanguage::calcScoreFor(const FontLanguages& supported) const { - int score = 0; + bool languageScriptMatch = false; + bool subtagMatch = false; + bool scriptMatch = false; + for (size_t i = 0; i < supported.size(); ++i) { + if (mEmojiStyle != EMSTYLE_EMPTY && + mEmojiStyle == supported[i].mEmojiStyle) { + subtagMatch = true; + if (mLanguage == supported[i].mLanguage) { + return 4; + } + } if (isEqualScript(supported[i]) || supportsScript(supported[i].mSubScriptBits, mSubScriptBits)) { + scriptMatch = true; if (mLanguage == supported[i].mLanguage) { - return 2; - } else { - score = 1; + languageScriptMatch = true; } } } - if (score == 1) { - return score; - } - if (supportsScript(supported.getUnionOfSubScriptBits(), mSubScriptBits)) { - // Gives score of 2 only if the language matches all of the font languages except for the - // exact match case handled above. - return (mLanguage == supported[0].mLanguage && supported.isAllTheSameLanguage()) ? 2 : 1; + scriptMatch = true; + if (mLanguage == supported[0].mLanguage && supported.isAllTheSameLanguage()) { + return 3; + } } + if (languageScriptMatch) { + return 3; + } else if (subtagMatch) { + return 2; + } else if (scriptMatch) { + return 1; + } return 0; } diff --git a/engine/src/flutter/libs/minikin/FontLanguage.h b/engine/src/flutter/libs/minikin/FontLanguage.h index 25a5cc3dfa..1bebdfeeb9 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.h +++ b/engine/src/flutter/libs/minikin/FontLanguage.h @@ -24,9 +24,9 @@ namespace minikin { -// Due to the limits in font fallback score calculation, we can't use anything more than 17 +// Due to the limits in font fallback score calculation, we can't use anything more than 12 // languages. -const size_t FONT_LANGUAGES_LIMIT = 17; +const size_t FONT_LANGUAGES_LIMIT = 12; class FontLanguages; // FontLanguage is a compact representation of a BCP 47 language tag. It diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 02bc03bbe6..52786d0c7e 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -780,6 +780,20 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { // Language match with unified subscript bits. { "zh-Hanb", { "zh-Hant", "zh-Bopo", "ja-Hant,ja-Bopo", "zh-Hant,zh-Bopo"}, 3 }, { "zh-Hanb", { "zh-Hant", "zh-Bopo", "ja-Hant,zh-Bopo", "zh-Hant,zh-Bopo"}, 3 }, + + // Two elements subtag matching: language and subtag or language or script. + { "ja-Kana-u-em-emoji", { "zh-Hant", "ja-Kana"}, 1 }, + { "ja-Kana-u-em-emoji", { "zh-Hant", "ja-Kana", "ja-Zsye"}, 2 }, + { "ja-Zsym-u-em-emoji", { "ja-Kana", "ja-Zsym", "ja-Zsye"}, 2 }, + + // One element subtag matching: subtag only or script only. + { "en-Latn-u-em-emoji", { "ja-Latn", "ja-Zsye"}, 1 }, + { "en-Zsym-u-em-emoji", { "ja-Zsym", "ja-Zsye"}, 1 }, + { "en-Zsye-u-em-text", { "ja-Zsym", "ja-Zsye"}, 0 }, + + // Multiple languages list with subtags. + { "en-Latn,ja-Jpan-u-em-text", { "en-Latn", "en-Zsye", "en-Zsym"}, 0 }, + { "en-Latn,en-Zsye,ja-Jpan-u-em-text", { "zh", "en-Zsye", "en-Zsym"}, 1 }, }; for (auto testCase : testCases) { From 6c5e3f184469787c7ab3d580092d8a9ef0fd5ffe Mon Sep 17 00:00:00 2001 From: Dan Willemsen Date: Fri, 9 Dec 2016 16:31:40 -0800 Subject: [PATCH 212/364] Use LOCAL_TEST_DATA to install test data This will handle installation for local builds as well as for the test bundles. Test: m -j minikin_tests; ls $OUT/data/nativetest*/minikin_tests Test: m -j continous_native_tests dist; zipinfo -1 out/dist/*continuous_native_tests*.zip Test: /data/nativetest{,64}/minikin_tests/minikin_tests Change-Id: Iafd31fa119e7c4d92937ca8ae8346e268a6c1f38 --- engine/src/flutter/tests/unittest/Android.mk | 23 ++++++------------- .../src/flutter/tests/unittest/how_to_run.txt | 4 +--- 2 files changed, 8 insertions(+), 19 deletions(-) diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index b88f1e70fc..cced545737 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -18,7 +18,7 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) -font_src_files := \ +LOCAL_TEST_DATA := \ data/BoldItalic.ttf \ data/Bold.ttf \ data/ColorEmojiFont.ttf \ @@ -37,24 +37,13 @@ font_src_files := \ data/itemize.xml \ data/emoji.xml +LOCAL_TEST_DATA := $(foreach f,$(LOCAL_TEST_DATA),frameworks/minikin/tests:$(f)) + LOCAL_MODULE := minikin_tests LOCAL_MODULE_TAGS := tests LOCAL_MODULE_CLASS := NATIVE_TESTS -data_root_for_test_zip := $(local-intermediates-dir)/DATA -minikin_tests_subpath_from_data := nativetest/minikin_tests -minikin_tests_root_in_device := /data/$(minikin_tests_subpath_from_data) -minikin_tests_root_for_test_zip := $(data_root_for_test_zip)/$(minikin_tests_subpath_from_data) - -GEN := $(addprefix $(minikin_tests_root_for_test_zip)/, $(font_src_files)) -$(GEN): PRIVATE_PATH := $(LOCAL_PATH)/../ -$(GEN): PRIVATE_CUSTOM_TOOL = cp $< $@ -$(GEN): $(minikin_tests_root_for_test_zip)/data/% : $(LOCAL_PATH)/../data/% - $(transform-generated-source) -LOCAL_GENERATED_SOURCES += $(GEN) - LOCAL_STATIC_LIBRARIES := libminikin -LOCAL_PICKUP_FILES := $(data_root_for_test_zip) # Shared libraries which are dependencies of minikin; these are not automatically # pulled in by the build system (and thus sadly must be repeated). @@ -95,7 +84,9 @@ LOCAL_C_INCLUDES := \ external/libxml2/include \ external/skia/src/core -LOCAL_CPPFLAGS += -Werror -Wall -Wextra \ - -DkTestFontDir="\"$(minikin_tests_root_in_device)/data/\"" +LOCAL_CPPFLAGS += -Werror -Wall -Wextra + +LOCAL_CPPFLAGS_32 += -DkTestFontDir="\"/data/nativetest/minikin_tests/data/\"" +LOCAL_CPPFLAGS_64 += -DkTestFontDir="\"/data/nativetest64/minikin_tests/data/\"" include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/unittest/how_to_run.txt b/engine/src/flutter/tests/unittest/how_to_run.txt index 4adfcb8d05..e94c904bec 100644 --- a/engine/src/flutter/tests/unittest/how_to_run.txt +++ b/engine/src/flutter/tests/unittest/how_to_run.txt @@ -1,5 +1,3 @@ mmm -j8 frameworks/minikin/tests/unittest && -adb push $OUT/data/nativetest/minikin_tests/minikin_tests \ - /data/nativetest/minikin_tests/minikin_tests && -adb push frameworks/minikin/tests/data /data/nativetest/minikin_tests/ && +adb push $OUT/data/nativetest/minikin_tests /data/nativetest/ && adb shell /data/nativetest/minikin_tests/minikin_tests From 7e38090b575faaebc1193291bd114dc885650087 Mon Sep 17 00:00:00 2001 From: Dan Willemsen Date: Fri, 9 Dec 2016 16:31:40 -0800 Subject: [PATCH 213/364] Use LOCAL_TEST_DATA to install test data This will handle installation for local builds as well as for the test bundles. Test: m -j minikin_tests; ls $OUT/data/nativetest*/minikin_tests Test: m -j continous_native_tests dist; zipinfo -1 out/dist/*continuous_native_tests*.zip Test: /data/nativetest{,64}/minikin_tests/minikin_tests Change-Id: Iafd31fa119e7c4d92937ca8ae8346e268a6c1f38 Merged-In: Iafd31fa119e7c4d92937ca8ae8346e268a6c1f38 --- engine/src/flutter/tests/Android.mk | 21 +++++---------------- engine/src/flutter/tests/how_to_run.txt | 4 +--- 2 files changed, 6 insertions(+), 19 deletions(-) diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk index bcc49193d5..2f21532377 100644 --- a/engine/src/flutter/tests/Android.mk +++ b/engine/src/flutter/tests/Android.mk @@ -18,7 +18,7 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) -font_src_files := \ +LOCAL_TEST_DATA := \ data/BoldItalic.ttf \ data/Bold.ttf \ data/ColorEmojiFont.ttf \ @@ -40,20 +40,7 @@ LOCAL_MODULE := minikin_tests LOCAL_MODULE_TAGS := tests LOCAL_MODULE_CLASS := NATIVE_TESTS -data_root_for_test_zip := $(local-intermediates-dir)/DATA -minikin_tests_subpath_from_data := nativetest/minikin_tests -minikin_tests_root_in_device := /data/$(minikin_tests_subpath_from_data) -minikin_tests_root_for_test_zip := $(data_root_for_test_zip)/$(minikin_tests_subpath_from_data) - -GEN := $(addprefix $(minikin_tests_root_for_test_zip)/, $(font_src_files)) -$(GEN): PRIVATE_PATH := $(LOCAL_PATH) -$(GEN): PRIVATE_CUSTOM_TOOL = cp $< $@ -$(GEN): $(minikin_tests_root_for_test_zip)/data/% : $(LOCAL_PATH)/data/% - $(transform-generated-source) -LOCAL_GENERATED_SOURCES += $(GEN) - LOCAL_STATIC_LIBRARIES := libminikin -LOCAL_PICKUP_FILES := $(data_root_for_test_zip) # Shared libraries which are dependencies of minikin; these are not automatically # pulled in by the build system (and thus sadly must be repeated). @@ -90,7 +77,9 @@ LOCAL_C_INCLUDES := \ external/libxml2/include \ external/skia/src/core -LOCAL_CPPFLAGS += -Werror -Wall -Wextra \ - -DkTestFontDir="\"$(minikin_tests_root_in_device)/data/\"" +LOCAL_CPPFLAGS += -Werror -Wall -Wextra + +LOCAL_CPPFLAGS_32 += -DkTestFontDir="\"/data/nativetest/minikin_tests/data/\"" +LOCAL_CPPFLAGS_64 += -DkTestFontDir="\"/data/nativetest64/minikin_tests/data/\"" include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/how_to_run.txt b/engine/src/flutter/tests/how_to_run.txt index bee367bd17..03a55244b3 100644 --- a/engine/src/flutter/tests/how_to_run.txt +++ b/engine/src/flutter/tests/how_to_run.txt @@ -1,5 +1,3 @@ mmm -j8 frameworks/minikin/tests && -adb push $OUT/data/nativetest/minikin_tests/minikin_tests \ - /data/nativetest/minikin_tests/minikin_tests && -adb push frameworks/minikin/tests/data /data/nativetest/minikin_tests/ && +adb push $OUT/data/nativetest/minikin_tests /data/nativetest/ && adb shell /data/nativetest/minikin_tests/minikin_tests From ff6cd90494440d28b2f755c3e9f46fae22b2f92f Mon Sep 17 00:00:00 2001 From: Mark Salyzyn Date: Wed, 28 Sep 2016 15:23:30 -0700 Subject: [PATCH 214/364] minikin: Replace cutils/log.h with android/log.h or log/log.h - replace cutils/log.h with android/log.h (main buffer logging) - replace cutils/log.h with log.log.h (+SafetyNet logging) - define LOG_TAG before use. Test: compile Bug: 26552300 Bug: 31289077 Change-Id: I7a4803dd66f31b7103e09e5ff5b8fa523fa0fd60 --- engine/src/flutter/libs/minikin/CmapCoverage.cpp | 3 ++- engine/src/flutter/libs/minikin/FontCollection.cpp | 3 ++- engine/src/flutter/libs/minikin/FontFamily.cpp | 10 +++++----- .../src/flutter/libs/minikin/FontLanguageListCache.cpp | 5 +++-- engine/src/flutter/libs/minikin/HbFontCache.cpp | 5 +++-- engine/src/flutter/libs/minikin/Layout.cpp | 9 ++++----- engine/src/flutter/libs/minikin/LineBreaker.cpp | 5 +++-- engine/src/flutter/libs/minikin/Measurement.cpp | 3 ++- engine/src/flutter/libs/minikin/MinikinInternal.cpp | 3 ++- engine/src/flutter/libs/minikin/SparseBitSet.cpp | 6 +++++- engine/src/flutter/libs/minikin/WordBreaker.cpp | 3 ++- engine/src/flutter/tests/FontFamilyTest.cpp | 5 ++--- engine/src/flutter/tests/FontTestUtils.cpp | 10 ++++++---- engine/src/flutter/tests/HbFontCacheTest.cpp | 8 ++++---- engine/src/flutter/tests/MinikinFontForTest.cpp | 4 +++- engine/src/flutter/tests/WordBreakerTests.cpp | 7 ++++--- 16 files changed, 52 insertions(+), 37 deletions(-) diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index 2961d2ffa8..86d8981c8b 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -17,11 +17,12 @@ // Determine coverage of font given its raw "cmap" OpenType table #define LOG_TAG "Minikin" -#include #include using std::vector; +#include + #include #include diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 33418ab1b5..ddda7bc09a 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -17,9 +17,10 @@ // #define VERBOSE_DEBUG #define LOG_TAG "Minikin" -#include + #include +#include #include "unicode/unistr.h" #include "unicode/unorm2.h" diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 7a8e79f508..6d45c67126 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -16,24 +16,24 @@ #define LOG_TAG "Minikin" -#include -#include #include +#include #include +#include +#include + #include #include -#include - #include "FontLanguage.h" #include "FontLanguageListCache.h" #include "HbFontCache.h" #include "MinikinInternal.h" -#include #include #include #include +#include using std::vector; diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp index 6b661f0384..9a409e658b 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp @@ -18,12 +18,13 @@ #include "FontLanguageListCache.h" -#include #include #include -#include "MinikinInternal.h" +#include + #include "FontLanguage.h" +#include "MinikinInternal.h" namespace android { diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index 3be942d7b9..08687571ba 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -18,10 +18,11 @@ #include "HbFontCache.h" -#include +#include +#include + #include #include -#include #include #include "MinikinInternal.h" diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 5ba72a4bb2..45cb06680f 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -15,29 +15,28 @@ */ #define LOG_TAG "Minikin" -#include - -#include #include #include #include // for debugging +#include #include +#include #include +#include #include #include #include #include -#include #include #include #include "FontLanguage.h" #include "FontLanguageListCache.h" -#include "LayoutUtils.h" #include "HbFontCache.h" +#include "LayoutUtils.h" #include "MinikinInternal.h" #include #include diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 2a71f044d2..bc8cb800ee 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -16,10 +16,11 @@ #define VERBOSE_DEBUG 0 +#define LOG_TAG "Minikin" + #include -#define LOG_TAG "Minikin" -#include +#include #include #include diff --git a/engine/src/flutter/libs/minikin/Measurement.cpp b/engine/src/flutter/libs/minikin/Measurement.cpp index 1ba6678373..b292c9aba9 100644 --- a/engine/src/flutter/libs/minikin/Measurement.cpp +++ b/engine/src/flutter/libs/minikin/Measurement.cpp @@ -15,11 +15,12 @@ */ #define LOG_TAG "Minikin" -#include #include #include +#include + #include #include diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 5cb94914c9..5900c1852c 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -15,12 +15,13 @@ */ // Definitions internal to Minikin +#define LOG_TAG "Minikin" #include "MinikinInternal.h" #include "HbFontCache.h" #include "generated/UnicodeData.h" -#include +#include namespace android { diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp index de0791445c..aa73c12670 100644 --- a/engine/src/flutter/libs/minikin/SparseBitSet.cpp +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -14,9 +14,13 @@ * limitations under the License. */ -#include +#define LOG_TAG "SparseBitSet" + #include #include + +#include + #include namespace android { diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index 38f03caf6a..7fc5824b6d 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -15,7 +15,8 @@ */ #define LOG_TAG "Minikin" -#include + +#include #include #include "MinikinInternal.h" diff --git a/engine/src/flutter/tests/FontFamilyTest.cpp b/engine/src/flutter/tests/FontFamilyTest.cpp index 1b2457695c..1975b7e7fd 100644 --- a/engine/src/flutter/tests/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/FontFamilyTest.cpp @@ -14,11 +14,10 @@ * limitations under the License. */ -#include - #include -#include +#include +#include #include "FontLanguageListCache.h" #include "ICUTestBase.h" diff --git a/engine/src/flutter/tests/FontTestUtils.cpp b/engine/src/flutter/tests/FontTestUtils.cpp index fdc3ed6ee9..9d36d2f6cb 100644 --- a/engine/src/flutter/tests/FontTestUtils.cpp +++ b/engine/src/flutter/tests/FontTestUtils.cpp @@ -14,15 +14,17 @@ * limitations under the License. */ +#define LOG_TAG "Minikin" + #include +#include -#include -#include - -#include +#include #include "FontLanguage.h" #include "MinikinFontForTest.h" +#include +#include android::FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { xmlDoc* doc = xmlReadFile(fontXml, NULL, 0); diff --git a/engine/src/flutter/tests/HbFontCacheTest.cpp b/engine/src/flutter/tests/HbFontCacheTest.cpp index 2dee61aff0..f1b1d31119 100644 --- a/engine/src/flutter/tests/HbFontCacheTest.cpp +++ b/engine/src/flutter/tests/HbFontCacheTest.cpp @@ -14,14 +14,14 @@ * limitations under the License. */ -#include - #include "HbFontCache.h" -#include -#include +#include +#include #include +#include + #include "MinikinInternal.h" #include "MinikinFontForTest.h" #include diff --git a/engine/src/flutter/tests/MinikinFontForTest.cpp b/engine/src/flutter/tests/MinikinFontForTest.cpp index 66dd4ea473..7933d2457e 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/MinikinFontForTest.cpp @@ -14,13 +14,15 @@ * limitations under the License. */ +#define LOG_TAG "Minikin" + #include "MinikinFontForTest.h" #include #include -#include +#include MinikinFontForTest::MinikinFontForTest(const std::string& font_path) : MinikinFontForTest(font_path, SkTypeface::CreateFromFile(font_path.c_str())) { diff --git a/engine/src/flutter/tests/WordBreakerTests.cpp b/engine/src/flutter/tests/WordBreakerTests.cpp index 8ed87cc506..0bb614732a 100644 --- a/engine/src/flutter/tests/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/WordBreakerTests.cpp @@ -14,7 +14,11 @@ * limitations under the License. */ +#define LOG_TAG "Minikin" + +#include #include + #include "ICUTestBase.h" #include "UnicodeUtils.h" #include @@ -22,9 +26,6 @@ #include #include -#define LOG_TAG "Minikin" -#include - #ifndef NELEM #define NELEM(x) ((sizeof(x) / sizeof((x)[0]))) #endif From 311d94f4161f17e80a86c646b9111a3fe1b4de48 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 24 Nov 2016 13:24:53 +0900 Subject: [PATCH 215/364] Tune line breaking for justification Add an "mJustified" for justification, and tune the line breaking to produce good results. Major differences for fully justified text include: - Space can be shrunk in justified text. - Hyphenation should be more aggressive in justified text. Also adds a penalty for the last line being very short. This is tuned to be more aggressive for ragged right than for justified text. This is based on a patch by Raph Levien (raph@google.com). Bug: 31707212 Test: Manually tested with Icbfab2faa11a6a0b52e6f0a77a9c9b5ef6e191da Change-Id: If366f82800831ccc247ec07b7bc28ca4c6ae0ed6 --- .../src/flutter/include/minikin/LineBreaker.h | 12 +++- .../src/flutter/libs/minikin/LineBreaker.cpp | 69 ++++++++++++++++--- 2 files changed, 71 insertions(+), 10 deletions(-) diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index feaffe74e3..75e54b05f1 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -147,6 +147,8 @@ class LineBreaker { void setStrategy(BreakStrategy strategy) { mStrategy = strategy; } + void setJustified(bool justified) { mJustified = justified; } + HyphenationFrequency getHyphenationFrequency() const { return mHyphenationFrequency; } void setHyphenationFrequency(HyphenationFrequency frequency) { @@ -194,19 +196,23 @@ class LineBreaker { float penalty; // penalty of this break (for example, hyphen penalty) float score; // best score found for this break size_t lineNumber; // only updated for non-constant line widths + size_t preSpaceCount; // preceding space count before breaking + size_t postSpaceCount; // preceding space count after breaking uint8_t hyphenEdit; }; float currentLineWidth() const; - void addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, float penalty, - uint8_t hyph); + void addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, + size_t preSpaceCount, size_t postSpaceCount, float penalty, uint8_t hyph); void addCandidate(Candidate cand); // push an actual break to the output. Takes care of setting flags for tab void pushBreak(int offset, float width, uint8_t hyph); + float getSpaceWidth() const; + void computeBreaksGreedy(); void computeBreaksOptimal(bool isRectangular); @@ -223,6 +229,7 @@ class LineBreaker { // layout parameters BreakStrategy mStrategy = kBreakStrategy_Greedy; HyphenationFrequency mHyphenationFrequency = kHyphenationFrequency_Normal; + bool mJustified; LineWidths mLineWidths; TabStops mTabStops; @@ -241,6 +248,7 @@ class LineBreaker { float mBestScore; ParaWidth mPreBreak; // prebreak of last break int mFirstTabIndex; + size_t mSpaceCount; }; } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 5ed6ab28fc..f7d1fd9214 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -22,6 +22,7 @@ #include +#include "LayoutUtils.h" #include #include @@ -44,6 +45,9 @@ const float LAST_LINE_PENALTY_MULTIPLIER = 4.0f; // probably not the most appropriate method. const float LINE_PENALTY_MULTIPLIER = 2.0f; +// Penalty assigned to shrinking the whitepsace. +const float SHRINK_PENALTY_MULTIPLIER = 4.0f; + // Very long words trigger O(n^2) behavior in hyphenation, so we disable hyphenation for // unreasonably long words. This is somewhat of a heuristic because extremely long words // are possible in some languages. This does mean that very long real words can get @@ -54,6 +58,9 @@ const size_t LONGEST_HYPHENATED_WORD = 45; // to avoid allocation. const size_t MAX_TEXT_BUF_RETAIN = 32678; +// Maximum amount that spaces can shrink, in justified text. +const float SHRINKABILITY = 1.0 / 3.0; + void LineBreaker::setLocale(const icu::Locale& locale, Hyphenator* hyphenator) { mWordBreaker.setLocale(locale); @@ -66,7 +73,7 @@ void LineBreaker::setText() { // handle initial break here because addStyleRun may never be called mWordBreaker.next(); mCandidates.clear(); - Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0, 0, 0}; + Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0, 0, 0, 0, 0}; mCandidates.push_back(cand); // reset greedy breaker state @@ -78,6 +85,7 @@ void LineBreaker::setText() { mBestScore = SCORE_INFTY; mPreBreak = 0; mFirstTabIndex = INT_MAX; + mSpaceCount = 0; } void LineBreaker::setLineWidths(float firstWidth, int firstWidthLineCount, float restWidth) { @@ -137,7 +145,14 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa hyphenPenalty *= 4.0; // TODO: Replace with a better value after some testing } - mLinePenalty = std::max(mLinePenalty, hyphenPenalty * LINE_PENALTY_MULTIPLIER); + if (mJustified) { + // Make hyphenation more aggressive for fully justified text (so that "normal" in + // justified mode is the same as "full" in ragged-right). + hyphenPenalty *= 0.25; + } else { + // Line penalty is zero for justified text. + mLinePenalty = std::max(mLinePenalty, hyphenPenalty * LINE_PENALTY_MULTIPLIER); + } } size_t current = (size_t)mWordBreaker.current(); @@ -145,6 +160,7 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa size_t lastBreak = start; ParaWidth lastBreakWidth = mWidth; ParaWidth postBreak = mWidth; + size_t postSpaceCount = mSpaceCount; bool temporarilySkipHyphenation = false; for (size_t i = start; i < end; i++) { uint16_t c = mTextBuf[i]; @@ -156,9 +172,11 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa // fall back to greedy; other modes don't know how to deal with tabs mStrategy = kBreakStrategy_Greedy; } else { + if (isWordSpace(c)) mSpaceCount += 1; mWidth += mCharWidths[i]; if (!isLineEndSpace(c)) { postBreak = mWidth; + postSpaceCount = mSpaceCount; afterWord = i + 1; } } @@ -196,11 +214,12 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa ParaWidth hyphPostBreak = lastBreakWidth + firstPartWidth; paint->hyphenEdit = 0; - const float secondPartWith = Layout::measureText(mTextBuf.data(), j, + const float secondPartWidth = Layout::measureText(mTextBuf.data(), j, afterWord - j, mTextBuf.size(), bidiFlags, style, *paint, typeface, nullptr); - ParaWidth hyphPreBreak = postBreak - secondPartWith; - addWordBreak(j, hyphPreBreak, hyphPostBreak, hyphenPenalty, hyph); + ParaWidth hyphPreBreak = postBreak - secondPartWidth; + addWordBreak(j, hyphPreBreak, hyphPostBreak, postSpaceCount, postSpaceCount, + hyphenPenalty, hyph); } } } @@ -210,7 +229,7 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa // Skip break for zero-width characters inside replacement span if (paint != nullptr || current == end || mCharWidths[current] > 0) { float penalty = hyphenPenalty * mWordBreaker.breakBadness(); - addWordBreak(current, mWidth, postBreak, penalty, 0); + addWordBreak(current, mWidth, postBreak, mSpaceCount, postSpaceCount, penalty, 0); } lastBreak = current; lastBreakWidth = mWidth; @@ -224,7 +243,7 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typefa // add a word break (possibly for a hyphenated fragment), and add desperate breaks if // needed (ie when word exceeds current line width) void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, - float penalty, uint8_t hyph) { + size_t preSpaceCount, size_t postSpaceCount, float penalty, uint8_t hyph) { Candidate cand; ParaWidth width = mCandidates.back().preBreak; if (postBreak - width > currentLineWidth()) { @@ -239,6 +258,9 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.offset = i; cand.preBreak = width; cand.postBreak = width; + // postSpaceCount doesn't include trailing spaces + cand.preSpaceCount = postSpaceCount; + cand.postSpaceCount = postSpaceCount; cand.penalty = SCORE_DESPERATE; cand.hyphenEdit = 0; #if VERBOSE_DEBUG @@ -255,6 +277,8 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.preBreak = preBreak; cand.postBreak = postBreak; cand.penalty = penalty; + cand.preSpaceCount = preSpaceCount; + cand.postSpaceCount = postSpaceCount; cand.hyphenEdit = hyph; #if VERBOSE_DEBUG ALOGD("cand: %zd %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); @@ -301,6 +325,18 @@ void LineBreaker::addReplacement(size_t start, size_t end, float width) { addStyleRun(nullptr, nullptr, FontStyle(), start, end, false); } +// Get the width of a space. May return 0 if there are no spaces. +// Note: if there are multiple different widths for spaces (for example, because of mixing of +// fonts), it's only guaranteed to pick one. +float LineBreaker::getSpaceWidth() const { + for (size_t i = 0; i < mTextBuf.size(); i++) { + if (isWordSpace(mTextBuf[i])) { + return mCharWidths[i]; + } + } + return 0.0f; +} + float LineBreaker::currentLineWidth() const { return mLineWidths.getLineWidth(mBreaks.size()); } @@ -340,6 +376,10 @@ void LineBreaker::computeBreaksOptimal(bool isRectangle) { size_t active = 0; size_t nCand = mCandidates.size(); float width = mLineWidths.getLineWidth(0); + float shortLineFactor = mJustified ? 0.75f : 0.5f; + float maxShrink = mJustified ? SHRINKABILITY * getSpaceWidth() : 0.0f; + + // "i" iterates through candidates for the end of the line. for (size_t i = 1; i < nCand; i++) { bool atEnd = i == nCand - 1; float best = SCORE_INFTY; @@ -353,6 +393,7 @@ void LineBreaker::computeBreaksOptimal(bool isRectangle) { ParaWidth leftEdge = mCandidates[i].postBreak - width; float bestHope = 0; + // "j" iterates through candidates for the beginning of the line. for (size_t j = active; j < i; j++) { if (!isRectangle) { size_t lineNumber = mCandidates[j].lineNumber; @@ -377,13 +418,24 @@ void LineBreaker::computeBreaksOptimal(bool isRectangle) { // breaks are considered. float widthScore = 0.0f; float additionalPenalty = 0.0f; - if (delta < 0) { + if ((atEnd || !mJustified) && delta < 0) { widthScore = SCORE_OVERFULL; } else if (atEnd && mStrategy != kBreakStrategy_Balanced) { // increase penalty for hyphen on last line additionalPenalty = LAST_LINE_PENALTY_MULTIPLIER * mCandidates[j].penalty; + // Penalize very short (< 1 - shortLineFactor of total width) lines. + float underfill = delta - shortLineFactor * width; + widthScore = underfill > 0 ? underfill * underfill : 0; } else { widthScore = delta * delta; + if (delta < 0) { + if (-delta < maxShrink * + (mCandidates[i].postSpaceCount - mCandidates[j].preSpaceCount)) { + widthScore *= SHRINK_PENALTY_MULTIPLIER; + } else { + widthScore = SCORE_OVERFULL; + } + } } if (delta < 0) { @@ -440,6 +492,7 @@ void LineBreaker::finish() { mStrategy = kBreakStrategy_Greedy; mHyphenationFrequency = kHyphenationFrequency_Normal; mLinePenalty = 0.0f; + mJustified = false; } } // namespace minikin From 41ef8b376f4616ba13e13096f7c03a4caa0c695a Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 13 Dec 2016 16:29:16 +0900 Subject: [PATCH 216/364] Reduce memory usage of FontCollection. Since switching to 64-bit devices, size_t is now a 64-bit integer. FontCollection::Range uses two size_t integers but they just point to an index in mFamilies. To reduce the memory usage, this CL changes the size_t integers to uint8_t. The maximum size of each integer in Range is the size of FontCollection::mFamilies. The largest this can go is the system font list plus a user defined family, which has 91 families. So an 8-bit integer should be enough. With this change, about 84 KiB of memory will be saved per font collection. Since eight font collections are created during bootstrap, about 670 KiB of memory will be saved with this CL. Bug: 33562608 Test: Ran FontCollection.collectionAllocationSizeTest on a 64-bit device. On my Nexus 5X, it changed from 327358 to 241342. Change-Id: I9e01d237c9adcb05e200932401cb1a4780049f86 --- engine/src/flutter/include/minikin/FontCollection.h | 10 +++++----- engine/src/flutter/libs/minikin/FontCollection.cpp | 13 +++++++------ 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index c9c8520be6..f6312dcea5 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -58,8 +58,8 @@ private: static const int kPageMask = (1 << kLogCharsPerPage) - 1; struct Range { - size_t start; - size_t end; + uint8_t start; + uint8_t end; }; FontFamily* getFamilyForChar(uint32_t ch, uint32_t vs, uint32_t langListId, int variant) const; @@ -87,14 +87,14 @@ private: // This vector can't be empty. std::vector mFamilies; - // This vector contains pointers into mInstances + // This vector contains indices into mFamilies. // This vector can't be empty. - std::vector mFamilyVec; + std::vector mFamilyVec; // This vector has pointers to the font family instance which has cmap 14 subtable. std::vector mVSFamilyVec; - // These are offsets into mInstanceVec, one range per page + // These are offsets into mFamilyVec, one range per page std::vector mRanges; }; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 365d7752b0..7ad2f48565 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -111,6 +111,8 @@ FontCollection::FontCollection(const vector& typefaces) : nTypefaces = mFamilies.size(); LOG_ALWAYS_FATAL_IF(nTypefaces == 0, "Font collection must have at least one valid typeface"); + LOG_ALWAYS_FATAL_IF(nTypefaces > 254, + "Up to 254 font families can be registered to collection."); size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage; size_t offset = 0; // TODO: Use variation selector map for mRanges construction. @@ -124,11 +126,11 @@ FontCollection::FontCollection(const vector& typefaces) : #ifdef VERBOSE_DEBUG ALOGD("i=%zd: range start = %zd\n", i, offset); #endif - range->start = offset; + range->start = (uint8_t)offset; for (size_t j = 0; j < nTypefaces; j++) { if (lastChar[j] < (i + 1) << kLogCharsPerPage) { FontFamily* family = mFamilies[j]; - mFamilyVec.push_back(family); + mFamilyVec.push_back((uint8_t)j); offset++; uint32_t nextChar = family->getCoverage()->nextSetBit((i + 1) << kLogCharsPerPage); #ifdef VERBOSE_DEBUG @@ -137,7 +139,7 @@ FontCollection::FontCollection(const vector& typefaces) : lastChar[j] = nextChar; } } - range->end = offset; + range->end = (uint8_t)offset; } } @@ -284,11 +286,10 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, return mFamilies[0]; } - const std::vector& familyVec = (vs == 0) ? mFamilyVec : mFamilies; Range range = mRanges[ch >> kLogCharsPerPage]; if (vs != 0) { - range = { 0, mFamilies.size() }; + range = { 0, (uint8_t)mFamilies.size() }; } #ifdef VERBOSE_DEBUG @@ -297,7 +298,7 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, FontFamily* bestFamily = nullptr; uint32_t bestScore = kUnsupportedFontScore; for (size_t i = range.start; i < range.end; i++) { - FontFamily* family = familyVec[i]; + FontFamily* family = vs == 0 ? mFamilies[mFamilyVec[i]] : mFamilies[i]; const uint32_t score = calcFamilyScore(ch, vs, variant, langListId, family); if (score == kFirstFontScore) { // If the first font family supports the given character or variation sequence, always From 707bbae8ffe73ecc96a1937113ed596de6633d56 Mon Sep 17 00:00:00 2001 From: Mark Salyzyn Date: Mon, 9 Jan 2017 13:33:48 -0800 Subject: [PATCH 217/364] minikin: use log/log.h when utilizing ALOG macros Use log/log.h to harden code against liblog changes. Test: compile Bug: 30465923 Change-Id: I3dea82e76d28d9ef52d7c0f11e038c4298863eb9 --- engine/src/flutter/libs/minikin/FontCollection.cpp | 2 +- engine/src/flutter/libs/minikin/FontFamily.cpp | 2 +- engine/src/flutter/libs/minikin/FontLanguageListCache.cpp | 2 +- engine/src/flutter/libs/minikin/HbFontCache.cpp | 2 +- engine/src/flutter/libs/minikin/Layout.cpp | 2 +- engine/src/flutter/libs/minikin/LineBreaker.cpp | 2 +- engine/src/flutter/libs/minikin/MinikinInternal.cpp | 2 +- engine/src/flutter/libs/minikin/SparseBitSet.cpp | 2 +- engine/src/flutter/tests/FontTestUtils.cpp | 2 +- engine/src/flutter/tests/MinikinFontForTest.cpp | 2 +- 10 files changed, 10 insertions(+), 10 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index ddda7bc09a..f5e2290318 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -20,7 +20,7 @@ #include -#include +#include #include "unicode/unistr.h" #include "unicode/unorm2.h" diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 6d45c67126..cbfa1cfffc 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include #include #include diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp index 9a409e658b..b5c40f1ddb 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp @@ -21,7 +21,7 @@ #include #include -#include +#include #include "FontLanguage.h" #include "MinikinInternal.h" diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index 08687571ba..3137125a26 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -18,7 +18,7 @@ #include "HbFontCache.h" -#include +#include #include #include diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 45cb06680f..d63cda0d30 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -24,7 +24,7 @@ #include #include -#include +#include #include #include #include diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index bc8cb800ee..21d1d8df6c 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -20,7 +20,7 @@ #include -#include +#include #include #include diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 5900c1852c..a5d1eada1f 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -21,7 +21,7 @@ #include "HbFontCache.h" #include "generated/UnicodeData.h" -#include +#include namespace android { diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp index aa73c12670..ac21bb8f0c 100644 --- a/engine/src/flutter/libs/minikin/SparseBitSet.cpp +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -19,7 +19,7 @@ #include #include -#include +#include #include diff --git a/engine/src/flutter/tests/FontTestUtils.cpp b/engine/src/flutter/tests/FontTestUtils.cpp index 9d36d2f6cb..f799f199e0 100644 --- a/engine/src/flutter/tests/FontTestUtils.cpp +++ b/engine/src/flutter/tests/FontTestUtils.cpp @@ -19,7 +19,7 @@ #include #include -#include +#include #include "FontLanguage.h" #include "MinikinFontForTest.h" diff --git a/engine/src/flutter/tests/MinikinFontForTest.cpp b/engine/src/flutter/tests/MinikinFontForTest.cpp index 7933d2457e..9330a652dd 100644 --- a/engine/src/flutter/tests/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/MinikinFontForTest.cpp @@ -22,7 +22,7 @@ #include -#include +#include MinikinFontForTest::MinikinFontForTest(const std::string& font_path) : MinikinFontForTest(font_path, SkTypeface::CreateFromFile(font_path.c_str())) { From d1c5b172cb9638daab6864b0cade9ed3eab6d6f0 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Sun, 4 Dec 2016 08:52:34 -0800 Subject: [PATCH 218/364] Use HarfBuzz metric implementation for emoji font. To avoid lock contention in Skia, use HarfBuzz implementation for retrieving boundary box and advance information from font. Bug: 21705974 Test: Manually done Change-Id: Ia88cb670ca9e0bb352bccef22c5ea3a789bcc1da --- engine/src/flutter/libs/minikin/Layout.cpp | 54 +++++++++++++++---- .../flutter/libs/minikin/MinikinInternal.h | 4 +- 2 files changed, 45 insertions(+), 13 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 15441a2d66..874002c18b 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -294,16 +294,36 @@ static hb_bool_t harfbuzzGetGlyphHorizontalOrigin(hb_font_t* /* hbFont */, void* return true; } -hb_font_funcs_t* getHbFontFuncs() { - static hb_font_funcs_t* hbFontFuncs = 0; +hb_font_funcs_t* getHbFontFuncs(bool forColorBitmapFont) { + assertMinikinLocked(); - if (hbFontFuncs == 0) { - hbFontFuncs = hb_font_funcs_create(); - hb_font_funcs_set_glyph_h_advance_func(hbFontFuncs, harfbuzzGetGlyphHorizontalAdvance, 0, 0); - hb_font_funcs_set_glyph_h_origin_func(hbFontFuncs, harfbuzzGetGlyphHorizontalOrigin, 0, 0); - hb_font_funcs_make_immutable(hbFontFuncs); + static hb_font_funcs_t* hbFuncs = nullptr; + static hb_font_funcs_t* hbFuncsForColorBitmap = nullptr; + + hb_font_funcs_t** funcs = forColorBitmapFont ? &hbFuncs : &hbFuncsForColorBitmap; + if (*funcs == nullptr) { + *funcs = hb_font_funcs_create(); + if (forColorBitmapFont) { + // Override the h_advance function since we can't use HarfBuzz's implemenation. It may + // return the wrong value if the font uses hinting aggressively. + hb_font_funcs_set_glyph_h_advance_func(*funcs, harfbuzzGetGlyphHorizontalAdvance, 0, 0); + } else { + // Don't override the h_advance function since we use HarfBuzz's implementation for + // emoji for performance reasons. + // Note that it is technically possible for a TrueType font to have outline and embedded + // bitmap at the same time. We ignore modified advances of hinted outline glyphs in that + // case. + } + hb_font_funcs_set_glyph_h_origin_func(*funcs, harfbuzzGetGlyphHorizontalOrigin, 0, 0); + hb_font_funcs_make_immutable(*funcs); } - return hbFontFuncs; + return *funcs; +} + +static bool isColorBitmapFont(hb_font_t* font) { + hb_face_t* face = hb_font_get_face(font); + HbBlob cbdt(hb_face_reference_table(face, HB_TAG('C', 'B', 'D', 'T'))); + return cbdt.size() > 0; } static float HBFixedToFloat(hb_position_t v) @@ -335,7 +355,7 @@ int Layout::findFace(FakedFont face, LayoutContext* ctx) { // corresponding hb_font object. if (ctx != NULL) { hb_font_t* font = getHbFontLocked(face.font); - hb_font_set_funcs(font, getHbFontFuncs(), &ctx->paint, 0); + hb_font_set_funcs(font, getHbFontFuncs(isColorBitmapFont(font)), &ctx->paint, 0); ctx->hbFonts.push_back(font); } return ix; @@ -753,6 +773,8 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_font_set_ppem(hbFont, size * scaleX, size); hb_font_set_scale(hbFont, 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. @@ -844,7 +866,19 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t xAdvance = roundf(xAdvance); } MinikinRect glyphBounds; - ctx->paint.font->GetBounds(&glyphBounds, glyph_ix, ctx->paint); + hb_glyph_extents_t extents = {}; + if (is_color_bitmap_font && hb_font_get_glyph_extents(hbFont, 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 { + ctx->paint.font->GetBounds(&glyphBounds, glyph_ix, ctx->paint); + } glyphBounds.offset(x + xoff, y + yoff); mBounds.join(glyphBounds); if (info[i].cluster - start < count) { diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index 88d54d7b11..9557d827df 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -65,9 +65,7 @@ public: } size_t size() const { - unsigned int length = 0; - hb_blob_get_data(mBlob, &length); - return (size_t)length; + return (size_t)hb_blob_get_length(mBlob); } private: From 16768d72e08177581af129e6846555948d883b53 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Fri, 6 Jan 2017 15:25:59 +0900 Subject: [PATCH 219/364] Fix GraphemeBreak test failures. GraphemeBreak.tailoring/GraphemeBreak.genderBalancedEmoji start failing after ICU update to 58. The failure is around Rule GB9 in Unicode Standard Annex #29. GB9 forbids breaks before extending characters and before ZWJ. However the implementation in minikin only checks for extending characters. It used to work with Unicode 8.0 since ZWJ had the Grapheme_Cluster_Break property of Extend in Unicode 8.0 but it no longer has that property in Uniocde 9.0. Thus, we need to check for ZWJ explicitly. At the same time, this removes manually added PREPEND characters case from tailoredGraphemeClusterBreak which is already supported in ICU 58. Test: minikin_tests passes Bug: 34117643 Change-Id: Ib46d48bebe4a866208e050d7defc715c61fcbeb1 --- .../flutter/libs/minikin/GraphemeBreak.cpp | 23 +++++++------------ 1 file changed, 8 insertions(+), 15 deletions(-) diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index dc5a761937..1b3d1ab33b 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -39,17 +39,6 @@ int32_t tailoredGraphemeClusterBreak(uint32_t c) { || c == 0xFEFF // BOM || ((c | 0x7F) == 0xE007F)) // recently undeprecated tag characters in Plane 14 return U_GCB_EXTEND; - // UTC-approved characters for the Prepend class, per - // http://www.unicode.org/L2/L2015/15183r-graph-cluster-brk.txt - // These should be removed when our copy of ICU gets updated to Unicode 9.0 (~2016 or 2017). - else if ((0x0600 <= c && c <= 0x0605) // Arabic subtending marks - || c == 0x06DD // ARABIC SUBTENDING MARK - || c == 0x070F // SYRIAC ABBREVIATION MARK - || c == 0x0D4E // MALAYALAM LETTER DOT REPH - || c == 0x110BD // KAITHI NUMBER SIGN - || c == 0x111C2 // SHARADA SIGN JIHVAMULIYA - || c == 0x111C3) // SHARADA SIGN UPADHMANIYA - return U_GCB_PREPEND; // THAI CHARACTER SARA AM is treated as a normal letter by most other implementations: they // allow a grapheme break before it. else if (c == 0x0E33) @@ -59,7 +48,7 @@ int32_t tailoredGraphemeClusterBreak(uint32_t c) { } // Returns true for all characters whose IndicSyllabicCategory is Pure_Killer. -// From http://www.unicode.org/Public/8.0.0/ucd/IndicSyllabicCategory.txt +// From http://www.unicode.org/Public/9.0.0/ucd/IndicSyllabicCategory.txt bool isPureKiller(uint32_t c) { return (c == 0x0E3A || c == 0x0E4E || c == 0x0F84 || c == 0x103A || c == 0x1714 || c == 0x1734 || c == 0x17D1 || c == 0x1BAA || c == 0x1BF2 || c == 0x1BF3 || c == 0xA806 @@ -132,8 +121,8 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co // The number 4 comes from the number of code units in a whole flag. return (offset - 2 - offset_back) % 4 == 0; } - // Rule GB9, x Extend; Rule GB9a, x SpacingMark; Rule GB9b, Prepend x - if (p2 == U_GCB_EXTEND || p2 == U_GCB_SPACING_MARK || p1 == U_GCB_PREPEND) { + // Rule GB9, x (Extend | ZWJ); Rule GB9a, x SpacingMark; Rule GB9b, Prepend x + if (p2 == U_GCB_EXTEND || p2 == U_GCB_ZWJ || p2 == U_GCB_SPACING_MARK || p1 == U_GCB_PREPEND) { return false; } // Cluster indic syllables together (tailoring of UAX #29) @@ -150,7 +139,7 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co return false; } // Tailoring: make emoji sequences with ZWJ a single grapheme cluster - if (c1 == 0x200D && isEmoji(c2) && offset_back > start) { + if (p1 == U_GCB_ZWJ && isEmoji(c2) && offset_back > start) { // look at character before ZWJ to see that both can participate in an emoji zwj sequence uint32_t c0 = 0; U16_PREV(buf, start, offset_back, c0); @@ -164,6 +153,10 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co } // Proposed Rule GB9c from http://www.unicode.org/L2/L2016/16011r3-break-prop-emoji.pdf // E_Base x E_Modifier + // TODO: Migrate to Rule GB10 and Rule GB11 with fixing following test cases in + // GraphemeBreak.tailoring and GraphemeBreak.emojiModifiers (Bug: 34211654) + // U+0628 U+200D U+2764 is expected to have grapheme boundary after U+200D. + // U+270C U+FE0E U+1F3FB is expected to have grapheme boundary after U+200D. if (isEmojiModifier(c2)) { if (c1 == 0xFE0F && offset_back > start) { // skip over emoji variation selector From 0470cdb3e41f0ae603f6a3e89efabdc196424652 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 29 Dec 2016 00:36:30 +0900 Subject: [PATCH 220/364] Remove FontFamily.addFont and make FontFamily immutable. This lays the groundwork for making SparseBitSet serializable. FontFamily.addFont is only used when the FontFamily is constructed. Thus, instead of calling FontFamily.addFont multiple time, passes Font list to the constructor. By this change, FontFamily can be immutable now. By making FontFamily immutable, We can create FontFamily with pre-calculated SparseBitSet. Bug: 34042446 Test: minikin_tests has passed Change-Id: I2576789fba6cb27687e920e2488e8bedbcf7d36f --- .../src/flutter/include/minikin/FontFamily.h | 57 ++++----- .../flutter/libs/minikin/FontCollection.cpp | 18 ++- .../src/flutter/libs/minikin/FontFamily.cpp | 115 ++++++++---------- engine/src/flutter/sample/example.cpp | 8 +- engine/src/flutter/sample/example_skia.cpp | 8 +- .../unittest/FontCollectionItemizeTest.cpp | 46 ++++--- .../tests/unittest/FontCollectionTest.cpp | 4 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 22 ++-- .../src/flutter/tests/util/FontTestUtils.cpp | 25 ++-- 9 files changed, 139 insertions(+), 164 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 10362c24de..bdf00e9f7c 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -98,64 +98,61 @@ struct FakedFont { FontFakery fakery; }; +struct Font { + Font(MinikinFont* typeface, FontStyle style); + Font(Font&& o); + Font(const Font& o); + ~Font(); + + MinikinFont* typeface; + FontStyle style; +}; + class FontFamily : public MinikinRefCounted { public: - FontFamily(); - - explicit FontFamily(int variant); - - FontFamily(uint32_t langId, int variant) - : mLangId(langId), - mVariant(variant), - mHasVSTable(false), - mCoverageValid(false) { - } + explicit FontFamily(std::vector&& fonts); + FontFamily(int variant, std::vector&& fonts); + FontFamily(uint32_t langId, int variant, std::vector&& fonts); ~FontFamily(); - // Add font to family, extracting style information from the font - bool addFont(MinikinFont* typeface); + // TODO: Good to expose FontUtil.h. + static bool analyzeStyle(MinikinFont* typeface, int* weight, bool* italic); - void addFont(MinikinFont* typeface, FontStyle style); FakedFont getClosestMatch(FontStyle style) const; uint32_t langId() const { return mLangId; } int variant() const { return mVariant; } // API's for enumerating the fonts in a family. These don't guarantee any particular order - size_t getNumFonts() const; - MinikinFont* getFont(size_t index) const; - FontStyle getStyle(size_t index) const; + size_t getNumFonts() const { return mFonts.size(); } + MinikinFont* getFont(size_t index) const { return mFonts[index].typeface; } + FontStyle getStyle(size_t index) const { return mFonts[index].style; } bool isColorEmojiFamily() const; - // Get Unicode coverage. Lifetime of returned bitset is same as receiver. May return nullptr on - // error. - const SparseBitSet* getCoverage(); + // Get Unicode coverage. + const SparseBitSet& getCoverage() const { return mCoverage; } // Returns true if the font has a glyph for the code point and variation selector pair. // Caller should acquire a lock before calling the method. - bool hasGlyph(uint32_t codepoint, uint32_t variationSelector); + bool hasGlyph(uint32_t codepoint, uint32_t variationSelector) const; // Returns true if this font family has a variaion sequence table (cmap format 14 subtable). - bool hasVSTable() const; + bool hasVSTable() const { return mHasVSTable; } private: - void addFontLocked(MinikinFont* typeface, FontStyle style); + void computeCoverage(); - class Font { - public: - Font(MinikinFont* typeface, FontStyle style) : - typeface(typeface), style(style) { } - MinikinFont* typeface; - FontStyle style; - }; uint32_t mLangId; int mVariant; std::vector mFonts; SparseBitSet mCoverage; bool mHasVSTable; - bool mCoverageValid; + + // Forbid copying and assignment. + FontFamily(const FontFamily&) = delete; + void operator=(const FontFamily&) = delete; }; } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 9d26377e6d..4688520699 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -96,17 +96,13 @@ FontCollection::FontCollection(const vector& typefaces) : continue; } family->RefLocked(); - const SparseBitSet* coverage = family->getCoverage(); - if (coverage == nullptr) { - family->UnrefLocked(); - continue; - } + const SparseBitSet& coverage = family->getCoverage(); mFamilies.push_back(family); // emplace_back would be better if (family->hasVSTable()) { mVSFamilyVec.push_back(family); } - mMaxChar = max(mMaxChar, coverage->length()); - lastChar.push_back(coverage->nextSetBit(0)); + mMaxChar = max(mMaxChar, coverage.length()); + lastChar.push_back(coverage.nextSetBit(0)); } nTypefaces = mFamilies.size(); LOG_ALWAYS_FATAL_IF(nTypefaces == 0, @@ -130,7 +126,7 @@ FontCollection::FontCollection(const vector& typefaces) : FontFamily* family = mFamilies[j]; mFamilyVec.push_back(family); offset++; - uint32_t nextChar = family->getCoverage()->nextSetBit((i + 1) << kLogCharsPerPage); + uint32_t nextChar = family->getCoverage().nextSetBit((i + 1) << kLogCharsPerPage); #ifdef VERBOSE_DEBUG ALOGD("nextChar = %d (j = %zd)\n", nextChar, j); #endif @@ -197,7 +193,7 @@ uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, // variation sequence's base character. uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* fontFamily) const { const bool hasVSGlyph = (vs != 0) && fontFamily->hasGlyph(ch, vs); - if (!hasVSGlyph && !fontFamily->getCoverage()->get(ch)) { + if (!hasVSGlyph && !fontFamily->getCoverage().get(ch)) { // The font doesn't support either variation sequence or even the base character. return kUnsupportedFontScore; } @@ -416,7 +412,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty if (lastFamily != nullptr) { if (isStickyWhitelisted(ch)) { // Continue using existing font as long as it has coverage and is whitelisted - shouldContinueRun = lastFamily->getCoverage()->get(ch); + shouldContinueRun = lastFamily->getCoverage().get(ch); } else if (isVariationSelector(ch)) { // Always continue if the character is a variation selector. shouldContinueRun = true; @@ -436,7 +432,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty if (utf16Pos != 0 && ((U_GET_GC_MASK(ch) & U_GC_M_MASK) != 0 || (isEmojiModifier(ch) && isEmojiBase(prevCh))) && - family && family->getCoverage()->get(prevCh)) { + family && family->getCoverage().get(prevCh)) { const size_t prevChLength = U16_LENGTH(prevCh); run->end -= prevChLength; if (run->start == run->end) { diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 8efa32a937..164cc7d8ad 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -64,45 +64,51 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { return (weight & kWeightMask) | (italic ? kItalicMask : 0) | (variant << kVariantShift); } -FontFamily::FontFamily() : FontFamily(0 /* variant */) { +Font::Font(MinikinFont* typeface, FontStyle style) + : typeface(typeface), style(style) { + typeface->Ref(); } -FontFamily::FontFamily(int variant) : FontFamily(FontLanguageListCache::kEmptyListId, variant) { +Font::Font(Font&& o) { + typeface = o.typeface; + style = o.style; + o.typeface = nullptr; +} + +Font::Font(const Font& o) { + typeface = o.typeface; + typeface->Ref(); + style = o.style; +} + +Font::~Font() { + if (typeface == nullptr) { + return; + } + typeface->UnrefLocked(); +} + +FontFamily::FontFamily(std::vector&& fonts) : FontFamily(0 /* variant */, std::move(fonts)) { +} + +FontFamily::FontFamily(int variant, std::vector&& fonts) + : FontFamily(FontLanguageListCache::kEmptyListId, variant, std::move(fonts)) { +} + +FontFamily::FontFamily(uint32_t langId, int variant, std::vector&& fonts) + : mLangId(langId), mVariant(variant), mFonts(std::move(fonts)), mHasVSTable(false) { + computeCoverage(); } FontFamily::~FontFamily() { - for (size_t i = 0; i < mFonts.size(); i++) { - mFonts[i].typeface->UnrefLocked(); - } } -bool FontFamily::addFont(MinikinFont* typeface) { +bool FontFamily::analyzeStyle(MinikinFont* typeface, int* weight, bool* italic) { android::AutoMutex _l(gMinikinLock); const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); HbBlob os2Table(getFontTable(typeface, os2Tag)); if (os2Table.get() == nullptr) return false; - int weight; - bool italic; - if (analyzeStyle(os2Table.get(), os2Table.size(), &weight, &italic)) { - //ALOGD("analyzed weight = %d, italic = %s", weight, italic ? "true" : "false"); - FontStyle style(weight, italic); - addFontLocked(typeface, style); - return true; - } else { - ALOGD("failed to analyze style"); - } - return false; -} - -void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { - android::AutoMutex _l(gMinikinLock); - addFontLocked(typeface, style); -} - -void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { - typeface->RefLocked(); - mFonts.push_back(Font(typeface, style)); - mCoverageValid = false; + return ::minikin::analyzeStyle(os2Table.get(), os2Table.size(), weight, italic); } // Compute a matching metric between two styles - 0 is an exact match @@ -146,18 +152,6 @@ FakedFont FontFamily::getClosestMatch(FontStyle style) const { return result; } -size_t FontFamily::getNumFonts() const { - return mFonts.size(); -} - -MinikinFont* FontFamily::getFont(size_t index) const { - return mFonts[index].typeface; -} - -FontStyle FontFamily::getStyle(size_t index) const { - return mFonts[index].style; -} - bool FontFamily::isColorEmojiFamily() const { const FontLanguages& languageList = FontLanguageListCache::getById(mLangId); for (size_t i = 0; i < languageList.size(); ++i) { @@ -168,30 +162,24 @@ bool FontFamily::isColorEmojiFamily() const { return false; } -const SparseBitSet* FontFamily::getCoverage() { - if (!mCoverageValid) { - const FontStyle defaultStyle; - MinikinFont* typeface = getClosestMatch(defaultStyle).font; - const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); - HbBlob cmapTable(getFontTable(typeface, cmapTag)); - if (cmapTable.get() == nullptr) { - ALOGE("Could not get cmap table size!\n"); - // Note: This means we will retry on the next call to getCoverage, as we can't store - // the failure. This is fine, as we assume this doesn't really happen in practice. - return nullptr; - } - // TODO: Error check? - CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); -#ifdef VERBOSE_DEBUG - ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), - mCoverage.nextSetBit(0)); -#endif - mCoverageValid = true; +void FontFamily::computeCoverage() { + android::AutoMutex _l(gMinikinLock); + const FontStyle defaultStyle; + MinikinFont* typeface = getClosestMatch(defaultStyle).font; + const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); + HbBlob cmapTable(getFontTable(typeface, cmapTag)); + if (cmapTable.get() == nullptr) { + ALOGE("Could not get cmap table size!\n"); + return; } - return &mCoverage; + // TODO: Error check? + CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); +#ifdef VERBOSE_DEBUG + ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), mCoverage.nextSetBit(0)); +#endif } -bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) { +bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const { assertMinikinLocked(); if (variationSelector != 0 && !mHasVSTable) { // Early exit if the variation selector is specified but the font doesn't have a cmap format @@ -208,9 +196,4 @@ bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) { return result; } -bool FontFamily::hasVSTable() const { - LOG_ALWAYS_FATAL_IF(!mCoverageValid, "Do not call this method before getCoverage() call"); - return mHasVSTable; -} - } // namespace minikin diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index a27918ea75..1c9c322d23 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -45,9 +45,9 @@ FontCollection *makeFontCollection() { "/system/fonts/Roboto-LightItalic.ttf" }; - FontFamily *family = new FontFamily(); FT_Face face; FT_Error error; + std::vector fonts; for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { const char *fn = fns[i]; printf("adding %s\n", fn); @@ -56,16 +56,16 @@ FontCollection *makeFontCollection() { printf("error loading %s, %d\n", fn, error); } MinikinFont *font = new MinikinFontFreeType(face); - family->addFont(font); + fonts.push_back(Font(font, FontStyle())); } + FontFamily *family = new FontFamily(std::move(fonts)); typefaces.push_back(family); #if 1 - family = new FontFamily(); const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; error = FT_New_Face(library, fn, 0, &face); MinikinFont *font = new MinikinFontFreeType(face); - family->addFont(font); + family = new FontFamily(std::vector({ Font(font, FontStyle()) })); typefaces.push_back(family); #endif diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index b04c8abcbc..6e6f868051 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -54,21 +54,21 @@ FontCollection *makeFontCollection() { "/system/fonts/Roboto-LightItalic.ttf" }; - FontFamily *family = new FontFamily(); + std::vector fonts; for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { const char *fn = fns[i]; sk_sp skFace = SkTypeface::MakeFromFile(fn); MinikinFont *font = new MinikinFontSkia(std::move(skFace)); - family->addFont(font); + fonts.push_back(Font(font, FontStyle())); } + FontFamily *family = new FontFamily(std::move(fonts)); typefaces.push_back(family); #if 1 - family = new FontFamily(); const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; sk_sp skFace = SkTypeface::MakeFromFile(fn); MinikinFont *font = new MinikinFontSkia(std::move(skFace)); - family->addFont(font); + family = new FontFamily(std::vector({ Font(font, FontStyle()) })); typefaces.push_back(family); #endif diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 52786d0c7e..5c5a5d343c 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -668,14 +668,14 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { const std::string kVSTestFont = kTestFontDir "VarioationSelectorTest-Regular.ttf"; std::vector families; - FontFamily* family1 = new FontFamily(VARIANT_DEFAULT); MinikinAutoUnref font(new MinikinFontForTest(kLatinFont)); - family1->addFont(font.get()); + FontFamily* family1 = new FontFamily(VARIANT_DEFAULT, + std::vector{ Font(font.get(), FontStyle()) }); families.push_back(family1); - FontFamily* family2 = new FontFamily(VARIANT_DEFAULT); MinikinAutoUnref font2(new MinikinFontForTest(kVSTestFont)); - family2->addFont(font2.get()); + FontFamily* family2 = new FontFamily(VARIANT_DEFAULT, + std::vector{ Font(font2.get(), FontStyle()) }); families.push_back(family2); FontCollection collection(families); @@ -811,11 +811,11 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { std::vector families; // Prepare first font which doesn't supports U+9AA8 - FontFamily* firstFamily = new FontFamily( - FontStyle::registerLanguageList("und"), 0 /* variant */); MinikinAutoUnref firstFamilyMinikinFont( new MinikinFontForTest(kNoGlyphFont)); - firstFamily->addFont(firstFamilyMinikinFont.get()); + FontFamily* firstFamily = new FontFamily( + FontStyle::registerLanguageList("und"), 0 /* variant */, + std::vector({ Font(firstFamilyMinikinFont.get(), FontStyle()) })); families.push_back(firstFamily); // Prepare font families @@ -824,10 +824,10 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { std::unordered_map fontLangIdxMap; for (size_t i = 0; i < testCase.fontLanguages.size(); ++i) { - FontFamily* family = new FontFamily( - FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */); MinikinAutoUnref minikin_font(new MinikinFontForTest(kJAFont)); - family->addFont(minikin_font.get()); + FontFamily* family = new FontFamily( + FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */, + std::vector({ Font(minikin_font.get(), FontStyle()) })); families.push_back(family); fontLangIdxMap.insert(std::make_pair(minikin_font.get(), i)); } @@ -1417,13 +1417,12 @@ TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS) { MinikinAutoUnref fontA(new MinikinFontForTest(kZH_HansFont)); MinikinAutoUnref fontB(new MinikinFontForTest(kZH_HansFont)); - MinikinAutoUnref dummyFamily(new FontFamily()); - MinikinAutoUnref familyA(new FontFamily()); - MinikinAutoUnref familyB(new FontFamily()); - - dummyFamily->addFont(dummyFont.get()); - familyA->addFont(fontA.get()); - familyB->addFont(fontB.get()); + MinikinAutoUnref dummyFamily(new FontFamily( + std::vector({ Font(dummyFont.get(), FontStyle()) }))); + MinikinAutoUnref familyA(new FontFamily( + std::vector({ Font(fontA.get(), FontStyle()) }))); + MinikinAutoUnref familyB(new FontFamily( + std::vector({ Font(fontB.get(), FontStyle()) }))); std::vector families = { dummyFamily.get(), familyA.get(), familyB.get() }; @@ -1453,13 +1452,12 @@ TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS2) { MinikinAutoUnref noCmapFormat14Font( new MinikinFontForTest(kNoCmapFormat14Font)); - MinikinAutoUnref dummyFamily(new FontFamily()); - MinikinAutoUnref hasCmapFormat14Family(new FontFamily()); - MinikinAutoUnref noCmapFormat14Family(new FontFamily()); - - dummyFamily->addFont(dummyFont.get()); - hasCmapFormat14Family->addFont(hasCmapFormat14Font.get()); - noCmapFormat14Family->addFont(noCmapFormat14Font.get()); + MinikinAutoUnref dummyFamily(new FontFamily( + std::vector({ Font(dummyFont.get(), FontStyle()) }))); + MinikinAutoUnref hasCmapFormat14Family(new FontFamily( + std::vector({ Font(hasCmapFormat14Font.get(), FontStyle()) }))); + MinikinAutoUnref noCmapFormat14Family(new FontFamily( + std::vector({ Font(noCmapFormat14Font.get(), FontStyle()) }))); std::vector families = { dummyFamily.get(), hasCmapFormat14Family.get(), noCmapFormat14Family.get() }; diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index 62d2f022fa..c0b6b526b7 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -57,9 +57,9 @@ void expectVSGlyphs(const FontCollection* fc, uint32_t codepoint, const std::set } TEST(FontCollectionTest, hasVariationSelectorTest) { - MinikinAutoUnref family(new FontFamily()); MinikinAutoUnref font(new MinikinFontForTest(kVsTestFont)); - family->addFont(font.get()); + MinikinAutoUnref family(new FontFamily( + std::vector({ Font(font.get(), FontStyle()) }))); std::vector families({family.get()}); MinikinAutoUnref fc(new FontCollection(families)); diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 4409801892..ddc36e4570 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -464,8 +464,10 @@ void expectVSGlyphs(FontFamily* family, uint32_t codepoint, const std::set minikinFont(new MinikinFontForTest(kVsTestFont)); - MinikinAutoUnref family(new FontFamily); - family->addFont(minikinFont.get()); + MinikinAutoUnref family( + new FontFamily(std::vector{ + Font(minikinFont.get(), FontStyle()) + })); android::AutoMutex _l(gMinikinLock); @@ -478,23 +480,23 @@ TEST_F(FontFamilyTest, hasVariationSelectorTest) { const uint32_t kVS20 = 0xE0103; const uint32_t kSupportedChar1 = 0x82A6; - EXPECT_TRUE(family->getCoverage()->get(kSupportedChar1)); + EXPECT_TRUE(family->getCoverage().get(kSupportedChar1)); expectVSGlyphs(family.get(), kSupportedChar1, std::set({kVS1, kVS17, kVS18, kVS19})); const uint32_t kSupportedChar2 = 0x845B; - EXPECT_TRUE(family->getCoverage()->get(kSupportedChar2)); + EXPECT_TRUE(family->getCoverage().get(kSupportedChar2)); expectVSGlyphs(family.get(), kSupportedChar2, std::set({kVS2, kVS18, kVS19, kVS20})); const uint32_t kNoVsSupportedChar = 0x537F; - EXPECT_TRUE(family->getCoverage()->get(kNoVsSupportedChar)); + EXPECT_TRUE(family->getCoverage().get(kNoVsSupportedChar)); expectVSGlyphs(family.get(), kNoVsSupportedChar, std::set()); const uint32_t kVsOnlySupportedChar = 0x717D; - EXPECT_FALSE(family->getCoverage()->get(kVsOnlySupportedChar)); + EXPECT_FALSE(family->getCoverage().get(kVsOnlySupportedChar)); expectVSGlyphs(family.get(), kVsOnlySupportedChar, std::set({kVS3, kVS19, kVS20})); const uint32_t kNotSupportedChar = 0x845C; - EXPECT_FALSE(family->getCoverage()->get(kNotSupportedChar)); + EXPECT_FALSE(family->getCoverage().get(kNotSupportedChar)); expectVSGlyphs(family.get(), kNotSupportedChar, std::set()); } @@ -518,11 +520,9 @@ TEST_F(FontFamilyTest, hasVSTableTest) { MinikinAutoUnref minikinFont( new MinikinFontForTest(testCase.fontPath)); - MinikinAutoUnref family(new FontFamily); - family->addFont(minikinFont.get()); + MinikinAutoUnref family(new FontFamily( + std::vector{ Font(minikinFont.get(), FontStyle()) })); android::AutoMutex _l(gMinikinLock); - family->getCoverage(); - EXPECT_EQ(testCase.hasVSTable, family->hasVSTable()); } } diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index 0c7b2ba032..e29a2fe534 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -48,16 +48,7 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { } } - xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); - FontFamily* family; - if (lang == nullptr) { - family = new FontFamily(variant); - } else { - uint32_t langId = FontStyle::registerLanguageList( - std::string((const char*)lang, xmlStrlen(lang))); - family = new FontFamily(langId, variant); - } - + std::vector fonts; for (xmlNode* fontNode = familyNode->children; fontNode; fontNode = fontNode->next) { if (xmlStrcmp(fontNode->name, (const xmlChar*)"font") != 0) { continue; @@ -80,13 +71,23 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { if (index == nullptr) { MinikinAutoUnref minikinFont(new MinikinFontForTest(fontPath)); - family->addFont(minikinFont.get(), FontStyle(weight, italic)); + fonts.push_back(Font(minikinFont.get(), FontStyle(weight, italic))); } else { MinikinAutoUnref minikinFont(new MinikinFontForTest(fontPath, atoi((const char*)index))); - family->addFont(minikinFont.get(), FontStyle(weight, italic)); + fonts.push_back(Font(minikinFont.get(), FontStyle(weight, italic))); } } + + xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); + FontFamily* family; + if (lang == nullptr) { + family = new FontFamily(variant, std::move(fonts)); + } else { + uint32_t langId = FontStyle::registerLanguageList( + std::string((const char*)lang, xmlStrlen(lang))); + family = new FontFamily(langId, variant, std::move(fonts)); + } families.push_back(family); } xmlFreeDoc(doc); From ed8318e4e860e7e542fa5143c399c3d1328bc25e Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 22 Nov 2016 18:10:57 +0900 Subject: [PATCH 221/364] Introduce createCollectionWithVariation. This lays the groundwork for variation settings support. Since we should regard different variations of a font as different fonts, we need to create new typefaces. To reuse the same instance of MinikinFont, as much as possible, FontFamily::createFamilyWithVariation now reuses an existence instance, while incrementing the reference count. Test: minikin_tests Bug: 33062398 Change-Id: I08e9b74192f8af1d045f1276498fa4e60d73863e --- .../flutter/include/minikin/FontCollection.h | 8 ++ .../src/flutter/include/minikin/FontFamily.h | 17 +++- .../src/flutter/include/minikin/MinikinFont.h | 4 + .../src/flutter/libs/minikin/AnalyzeStyle.cpp | 43 ----------- engine/src/flutter/libs/minikin/Android.mk | 2 +- .../flutter/libs/minikin/FontCollection.cpp | 39 ++++++++++ .../src/flutter/libs/minikin/FontFamily.cpp | 67 ++++++++++++++-- engine/src/flutter/libs/minikin/FontUtils.cpp | 77 +++++++++++++++++++ .../minikin/FontUtils.h} | 9 ++- engine/src/flutter/tests/unittest/Android.mk | 1 + .../tests/unittest/FontCollectionTest.cpp | 72 +++++++++++++++++ .../flutter/tests/unittest/FontFamilyTest.cpp | 63 +++++++++++++++ .../flutter/tests/util/MinikinFontForTest.cpp | 9 ++- .../flutter/tests/util/MinikinFontForTest.h | 9 ++- 14 files changed, 365 insertions(+), 55 deletions(-) delete mode 100644 engine/src/flutter/libs/minikin/AnalyzeStyle.cpp create mode 100644 engine/src/flutter/libs/minikin/FontUtils.cpp rename engine/src/flutter/{include/minikin/AnalyzeStyle.h => libs/minikin/FontUtils.h} (75%) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index f6312dcea5..eaebcbcf93 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -18,6 +18,7 @@ #define MINIKIN_FONT_COLLECTION_H #include +#include #include #include @@ -51,6 +52,10 @@ public: // Get base font with fakery information (fake bold could affect metrics) FakedFont baseFontFaked(FontStyle style); + // Creates new FontCollection based on this collection while applying font variations. Returns + // nullptr if none of variations apply to this collection. + FontCollection* createCollectionWithVariation(const std::vector& variations); + uint32_t getId() const; private: @@ -96,6 +101,9 @@ private: // These are offsets into mFamilyVec, one range per page std::vector mRanges; + + // Set of supported axes in this collection. + std::unordered_set mSupportedAxes; }; } // namespace minikin diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index bdf00e9f7c..b848a04630 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -19,6 +19,7 @@ #include #include +#include #include #include @@ -98,6 +99,8 @@ struct FakedFont { FontFakery fakery; }; +typedef uint32_t AxisTag; + struct Font { Font(MinikinFont* typeface, FontStyle style); Font(Font&& o); @@ -106,6 +109,13 @@ struct Font { MinikinFont* typeface; FontStyle style; + std::unordered_set supportedAxes; +}; + +struct FontVariation { + FontVariation(AxisTag axisTag, float value) : axisTag(axisTag), value(value) {} + AxisTag axisTag; + float value; }; class FontFamily : public MinikinRefCounted { @@ -129,6 +139,7 @@ public: MinikinFont* getFont(size_t index) const { return mFonts[index].typeface; } FontStyle getStyle(size_t index) const { return mFonts[index].style; } bool isColorEmojiFamily() const; + const std::unordered_set& supportedAxes() const { return mSupportedAxes; } // Get Unicode coverage. const SparseBitSet& getCoverage() const { return mCoverage; } @@ -140,12 +151,16 @@ public: // Returns true if this font family has a variaion sequence table (cmap format 14 subtable). bool hasVSTable() const { return mHasVSTable; } + // Creates new FontFamily based on this family while applying font variations. Returns nullptr + // if none of variations apply to this family. + FontFamily* createFamilyWithVariation(const std::vector& variations) const; + private: void computeCoverage(); - uint32_t mLangId; int mVariant; std::vector mFonts; + std::unordered_set mSupportedAxes; SparseBitSet mCoverage; bool mHasVSTable; diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 353edd6566..57b939788a 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -126,6 +126,10 @@ public: return 0; } + virtual MinikinFont* createFontWithVariation(const std::vector&) const { + return nullptr; + } + 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; diff --git a/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp b/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp deleted file mode 100644 index 333f008f7f..0000000000 --- a/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (C) 2013 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include - -#include - -namespace minikin { - -// should we have a single FontAnalyzer class this stuff lives in, to avoid dup? -static int32_t readU16(const uint8_t* data, size_t offset) { - return data[offset] << 8 | data[offset + 1]; -} - -bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic) { - const size_t kUsWeightClassOffset = 4; - const size_t kFsSelectionOffset = 62; - const uint16_t kItalicFlag = (1 << 0); - if (os2_size < kFsSelectionOffset + 2) { - return false; - } - uint16_t weightClass = readU16(os2_data, kUsWeightClassOffset); - *weight = weightClass / 100; - uint16_t fsSelection = readU16(os2_data, kFsSelectionOffset); - *italic = (fsSelection & kItalicFlag) != 0; - return true; -} - -} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index d6c3df7f62..44abb88532 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -30,12 +30,12 @@ $(UNICODE_EMOJI_H): include $(CLEAR_VARS) minikin_src_files := \ - AnalyzeStyle.cpp \ CmapCoverage.cpp \ FontCollection.cpp \ FontFamily.cpp \ FontLanguage.cpp \ FontLanguageListCache.cpp \ + FontUtils.cpp \ GraphemeBreak.cpp \ HbFontCache.cpp \ Hyphenator.cpp \ diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 9e9223fd2e..ac6f8f336d 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -103,6 +103,9 @@ FontCollection::FontCollection(const vector& typefaces) : } mMaxChar = max(mMaxChar, coverage.length()); lastChar.push_back(coverage.nextSetBit(0)); + + const std::unordered_set& supportedAxes = family->supportedAxes(); + mSupportedAxes.insert(supportedAxes.begin(), supportedAxes.end()); } nTypefaces = mFamilies.size(); LOG_ALWAYS_FATAL_IF(nTypefaces == 0, @@ -462,6 +465,42 @@ FakedFont FontCollection::baseFontFaked(FontStyle style) { return mFamilies[0]->getClosestMatch(style); } +FontCollection* FontCollection::createCollectionWithVariation( + const std::vector& variations) { + if (variations.empty() || mSupportedAxes.empty()) { + return nullptr; + } + + bool hasSupportedAxis = false; + for (const FontVariation& variation : variations) { + if (mSupportedAxes.find(variation.axisTag) != mSupportedAxes.end()) { + hasSupportedAxis = true; + break; + } + } + if (!hasSupportedAxis) { + // None of variation axes are supported by this font collection. + return nullptr; + } + + std::vector families; + for (FontFamily* family : mFamilies) { + FontFamily* newFamily = family->createFamilyWithVariation(variations); + if (newFamily) { + families.push_back(newFamily); + } else { + family->Ref(); + families.push_back(family); + } + } + + FontCollection* result = new FontCollection(families); + for (FontFamily* family : families) { + family->Unref(); + } + return result; +} + uint32_t FontCollection::getId() const { return mId; } diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 164cc7d8ad..5a277f7810 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -28,10 +28,11 @@ #include "FontLanguage.h" #include "FontLanguageListCache.h" +#include "FontUtils.h" #include "HbFontCache.h" #include "MinikinInternal.h" -#include #include +#include #include #include @@ -66,19 +67,30 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { Font::Font(MinikinFont* typeface, FontStyle style) : typeface(typeface), style(style) { - typeface->Ref(); + android::AutoMutex _l(gMinikinLock); + typeface->RefLocked(); + + const uint32_t fvarTag = MinikinFont::MakeTag('f', 'v', 'a', 'r'); + HbBlob fvarTable(getFontTable(typeface, fvarTag)); + if (fvarTable.size() == 0) { + return; + } + + analyzeAxes(fvarTable.get(), fvarTable.size(), &supportedAxes); } Font::Font(Font&& o) { typeface = o.typeface; style = o.style; o.typeface = nullptr; + supportedAxes = std::move(o.supportedAxes); } Font::Font(const Font& o) { typeface = o.typeface; typeface->Ref(); style = o.style; + supportedAxes = o.supportedAxes; } Font::~Font() { @@ -174,9 +186,10 @@ void FontFamily::computeCoverage() { } // TODO: Error check? CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); -#ifdef VERBOSE_DEBUG - ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), mCoverage.nextSetBit(0)); -#endif + + for (size_t i = 0; i < mFonts.size(); ++i) { + mSupportedAxes.insert(mFonts[i].supportedAxes.begin(), mFonts[i].supportedAxes.end()); + } } bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const { @@ -196,4 +209,48 @@ bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const return result; } +FontFamily* FontFamily::createFamilyWithVariation( + const std::vector& variations) const { + if (variations.empty() || mSupportedAxes.empty()) { + return nullptr; + } + + bool hasSupportedAxis = false; + for (const FontVariation& variation : variations) { + if (mSupportedAxes.find(variation.axisTag) != mSupportedAxes.end()) { + hasSupportedAxis = true; + break; + } + } + if (!hasSupportedAxis) { + // None of variation axes are suppored by this family. + return nullptr; + } + + std::vector fonts; + for (const Font& font : mFonts) { + bool supportedVariations = false; + if (!font.supportedAxes.empty()) { + for (const FontVariation& variation : variations) { + if (font.supportedAxes.find(variation.axisTag) != font.supportedAxes.end()) { + supportedVariations = true; + break; + } + } + } + MinikinFont* minikinFont = nullptr; + if (supportedVariations) { + minikinFont = font.typeface->createFontWithVariation(variations); + } + if (minikinFont == nullptr) { + minikinFont = font.typeface; + minikinFont->Ref(); + } + fonts.push_back(Font(minikinFont, font.style)); + minikinFont->Unref(); + } + + return new FontFamily(mLangId, mVariant, std::move(fonts)); +} + } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontUtils.cpp b/engine/src/flutter/libs/minikin/FontUtils.cpp new file mode 100644 index 0000000000..56be16d696 --- /dev/null +++ b/engine/src/flutter/libs/minikin/FontUtils.cpp @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2016 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 +#include + +#include "FontUtils.h" + +namespace minikin { + +static uint16_t readU16(const uint8_t* data, size_t offset) { + return data[offset] << 8 | data[offset + 1]; +} + +static uint32_t readU32(const uint8_t* data, size_t offset) { + return ((uint32_t)data[offset]) << 24 | ((uint32_t)data[offset + 1]) << 16 | + ((uint32_t)data[offset + 2]) << 8 | ((uint32_t)data[offset + 3]); +} + +bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic) { + const size_t kUsWeightClassOffset = 4; + const size_t kFsSelectionOffset = 62; + const uint16_t kItalicFlag = (1 << 0); + if (os2_size < kFsSelectionOffset + 2) { + return false; + } + uint16_t weightClass = readU16(os2_data, kUsWeightClassOffset); + *weight = weightClass / 100; + uint16_t fsSelection = readU16(os2_data, kFsSelectionOffset); + *italic = (fsSelection & kItalicFlag) != 0; + return true; +} + +void analyzeAxes(const uint8_t* fvar_data, size_t fvar_size, std::unordered_set* axes) { + const size_t kMajorVersionOffset = 0; + const size_t kMinorVersionOffset = 2; + const size_t kOffsetToAxesArrayOffset = 4; + const size_t kAxisCountOffset = 8; + const size_t kAxisSizeOffset = 10; + + axes->clear(); + + if (fvar_size < kAxisSizeOffset + 2) { + return; + } + const uint16_t majorVersion = readU16(fvar_data, kMajorVersionOffset); + const uint16_t minorVersion = readU16(fvar_data, kMinorVersionOffset); + const uint32_t axisOffset = readU16(fvar_data, kOffsetToAxesArrayOffset); + const uint32_t axisCount = readU16(fvar_data, kAxisCountOffset); + const uint32_t axisSize = readU16(fvar_data, kAxisSizeOffset); + + if (majorVersion != 1 || minorVersion != 0 || axisOffset != 0x10 || axisSize != 0x14) { + return; // Unsupported version. + } + if (fvar_size < axisOffset + axisOffset * axisCount) { + return; // Invalid table size. + } + for (uint32_t i = 0; i < axisCount; ++i) { + size_t axisRecordOffset = axisOffset + i * axisSize; + uint32_t tag = readU32(fvar_data, axisRecordOffset); + axes->insert(tag); + } +} +} // namespace minikin diff --git a/engine/src/flutter/include/minikin/AnalyzeStyle.h b/engine/src/flutter/libs/minikin/FontUtils.h similarity index 75% rename from engine/src/flutter/include/minikin/AnalyzeStyle.h rename to engine/src/flutter/libs/minikin/FontUtils.h index b4cd915108..fa2051b409 100644 --- a/engine/src/flutter/include/minikin/AnalyzeStyle.h +++ b/engine/src/flutter/libs/minikin/FontUtils.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2013 The Android Open Source Project + * Copyright (C) 2016 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. @@ -14,12 +14,15 @@ * limitations under the License. */ -#ifndef MINIKIN_ANALYZE_STYLE_H -#define MINIKIN_ANALYZE_STYLE_H +#ifndef MINIKIN_FONT_UTILS_H +#define MINIKIN_FONT_UTILS_H + +#include namespace minikin { bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic); +void analyzeAxes(const uint8_t* fvar_data, size_t fvar_size, std::unordered_set* axes); } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index cced545737..7b3f60f8f9 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -27,6 +27,7 @@ LOCAL_TEST_DATA := \ data/Italic.ttf \ data/Ja.ttf \ data/Ko.ttf \ + data/MultiAxis.ttf \ data/NoCmapFormat14.ttf \ data/NoGlyphFont.ttf \ data/Regular.ttf \ diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index c0b6b526b7..02e861c903 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -121,4 +121,76 @@ TEST(FontCollectionTest, newEmojiTest) { EXPECT_FALSE(collection->hasVariationSelector(0x2642, 0xFE0F)); } +TEST(FontCollectionTest, createWithVariations) { + // This font has 'wdth' and 'wght' axes. + const char kMultiAxisFont[] = kTestFontDir "/MultiAxis.ttf"; + const char kNoAxisFont[] = kTestFontDir "/Regular.ttf"; + + MinikinAutoUnref multiAxisFont(new MinikinFontForTest(kMultiAxisFont)); + MinikinAutoUnref multiAxisFamily(new FontFamily( + std::vector({ Font(multiAxisFont.get(), FontStyle()) }))); + std::vector multiAxisFamilies({multiAxisFamily.get()}); + MinikinAutoUnref multiAxisFc(new FontCollection(multiAxisFamilies)); + + MinikinAutoUnref noAxisFont(new MinikinFontForTest(kNoAxisFont)); + MinikinAutoUnref noAxisFamily(new FontFamily( + std::vector({ Font(noAxisFont.get(), FontStyle()) }))); + std::vector noAxisFamilies({noAxisFamily.get()}); + MinikinAutoUnref noAxisFc(new FontCollection(noAxisFamilies)); + + { + // Do not ceate new instance if none of variations are specified. + EXPECT_EQ(nullptr, + multiAxisFc->createCollectionWithVariation(std::vector())); + EXPECT_EQ(nullptr, + noAxisFc->createCollectionWithVariation(std::vector())); + } + { + // New instance should be used for supported variation. + std::vector variations = { + { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f } + }; + MinikinAutoUnref newFc( + multiAxisFc->createCollectionWithVariation(variations)); + EXPECT_NE(nullptr, newFc.get()); + EXPECT_NE(multiAxisFc.get(), newFc.get()); + + EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); + } + { + // New instance should be used for supported variation (multiple variations case). + std::vector variations = { + { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, + { MinikinFont::MakeTag('w', 'g', 'h', 't'), 1.0f } + }; + MinikinAutoUnref newFc( + multiAxisFc->createCollectionWithVariation(variations)); + EXPECT_NE(nullptr, newFc.get()); + EXPECT_NE(multiAxisFc.get(), newFc.get()); + + EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); + } + { + // Do not ceate new instance if none of variations are supported. + std::vector variations = { + { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } + }; + EXPECT_EQ(nullptr, multiAxisFc->createCollectionWithVariation(variations)); + EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); + } + { + // At least one axis is supported, should create new instance. + std::vector variations = { + { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, + { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } + }; + MinikinAutoUnref newFc( + multiAxisFc->createCollectionWithVariation(variations)); + EXPECT_NE(nullptr, newFc.get()); + EXPECT_NE(multiAxisFc.get(), newFc.get()); + + EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); + } +} + } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index ddc36e4570..35f387304b 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -527,4 +527,67 @@ TEST_F(FontFamilyTest, hasVSTableTest) { } } +TEST_F(FontFamilyTest, createFamilyWithVariationTest) { + // This font has 'wdth' and 'wght' axes. + const char kMultiAxisFont[] = kTestFontDir "/MultiAxis.ttf"; + const char kNoAxisFont[] = kTestFontDir "/Regular.ttf"; + + MinikinAutoUnref multiAxisFont(new MinikinFontForTest(kMultiAxisFont)); + MinikinAutoUnref multiAxisFamily(new FontFamily( + std::vector({Font(multiAxisFont.get(), FontStyle())}))); + + MinikinAutoUnref noAxisFont(new MinikinFontForTest(kNoAxisFont)); + MinikinAutoUnref noAxisFamily(new FontFamily( + std::vector({Font(noAxisFont.get(), FontStyle())}))); + + { + // Do not ceate new instance if none of variations are specified. + EXPECT_EQ(nullptr, + multiAxisFamily->createFamilyWithVariation(std::vector())); + EXPECT_EQ(nullptr, + noAxisFamily->createFamilyWithVariation(std::vector())); + } + { + // New instance should be used for supported variation. + std::vector variations = {{MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f}}; + MinikinAutoUnref newFamily( + multiAxisFamily->createFamilyWithVariation(variations)); + EXPECT_NE(nullptr, newFamily.get()); + EXPECT_NE(multiAxisFamily.get(), newFamily.get()); + EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); + } + { + // New instance should be used for supported variation. (multiple variations case) + std::vector variations = { + { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, + { MinikinFont::MakeTag('w', 'g', 'h', 't'), 1.0f } + }; + MinikinAutoUnref newFamily( + multiAxisFamily->createFamilyWithVariation(variations)); + EXPECT_NE(nullptr, newFamily.get()); + EXPECT_NE(multiAxisFamily.get(), newFamily.get()); + EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); + } + { + // Do not ceate new instance if none of variations are supported. + std::vector variations = { + { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } + }; + EXPECT_EQ(nullptr, multiAxisFamily->createFamilyWithVariation(variations)); + EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); + } + { + // At least one axis is supported, should create new instance. + std::vector variations = { + { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, + { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } + }; + MinikinAutoUnref newFamily( + multiAxisFamily->createFamilyWithVariation(variations)); + EXPECT_NE(nullptr, newFamily.get()); + EXPECT_NE(multiAxisFamily.get(), newFamily.get()); + EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); + } +} + } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index a4132e5178..f191f07d6e 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -34,9 +34,11 @@ namespace minikin { static int uniqueId = 0; // TODO: make thread safe if necessary. -MinikinFontForTest::MinikinFontForTest(const std::string& font_path, int index) : +MinikinFontForTest::MinikinFontForTest(const std::string& font_path, int index, + const std::vector& variations) : MinikinFont(uniqueId++), mFontPath(font_path), + mVariations(variations), mFontIndex(index) { int fd = open(font_path.c_str(), O_RDONLY); LOG_ALWAYS_FATAL_IF(fd == -1); @@ -67,4 +69,9 @@ void MinikinFontForTest::GetBounds(MinikinRect* bounds, uint32_t /* glyph_id */, bounds->mBottom = 10.0f; } +MinikinFont* MinikinFontForTest::createFontWithVariation( + const std::vector& variations) const { + return new MinikinFontForTest(mFontPath, mFontIndex, variations); +} + } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index ee0eadbe0c..2a107036ed 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -25,7 +25,10 @@ namespace minikin { class MinikinFontForTest : public MinikinFont { public: - MinikinFontForTest(const std::string& font_path, int index); + MinikinFontForTest(const std::string& font_path, int index, + const std::vector& variations); + MinikinFontForTest(const std::string& font_path, int index) + : MinikinFontForTest(font_path, index, std::vector()) {} MinikinFontForTest(const std::string& font_path) : MinikinFontForTest(font_path, 0) {} virtual ~MinikinFontForTest(); @@ -35,15 +38,19 @@ public: const MinikinPaint& paint) const; const std::string& fontPath() const { return mFontPath; } + const std::vector& variations() const { return mVariations; } + const void* GetFontData() const { return mFontData; } size_t GetFontSize() const { return mFontSize; } int GetFontIndex() const { return mFontIndex; } + MinikinFont* createFontWithVariation(const std::vector& variations) const; private: MinikinFontForTest() = delete; MinikinFontForTest(const MinikinFontForTest&) = delete; MinikinFontForTest& operator=(MinikinFontForTest&) = delete; const std::string mFontPath; + const std::vector mVariations; const int mFontIndex; void* mFontData; size_t mFontSize; From 7235e8c11d78d8ade2cb92a3ce6bf631154d7fe6 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 12 Jan 2017 18:33:44 +0900 Subject: [PATCH 222/364] Fix inverse condition of forColorEmoji. We should override the advance function only when the glyph is came from color bitmap. This was introduced by Ia88cb670ca9e0bb352bccef22c5ea3a789bcc1da. Bug: 21705974 Test: ran minikin_tests Change-Id: I3489d75ace8bffdd9035a5986a2641313feef04d --- engine/src/flutter/libs/minikin/Layout.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 2e7ef77e23..98e9fdb07b 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -304,15 +304,15 @@ hb_font_funcs_t* getHbFontFuncs(bool forColorBitmapFont) { if (*funcs == nullptr) { *funcs = hb_font_funcs_create(); if (forColorBitmapFont) { - // Override the h_advance function since we can't use HarfBuzz's implemenation. It may - // return the wrong value if the font uses hinting aggressively. - hb_font_funcs_set_glyph_h_advance_func(*funcs, harfbuzzGetGlyphHorizontalAdvance, 0, 0); - } else { // Don't override the h_advance function since we use HarfBuzz's implementation for // emoji for performance reasons. // Note that it is technically possible for a TrueType font to have outline and embedded // bitmap at the same time. We ignore modified advances of hinted outline glyphs in that // case. + } else { + // Override the h_advance function since we can't use HarfBuzz's implemenation. It may + // return the wrong value if the font uses hinting aggressively. + hb_font_funcs_set_glyph_h_advance_func(*funcs, harfbuzzGetGlyphHorizontalAdvance, 0, 0); } hb_font_funcs_set_glyph_h_origin_func(*funcs, harfbuzzGetGlyphHorizontalOrigin, 0, 0); hb_font_funcs_make_immutable(*funcs); From defcd9d9c227776396e00daf0b33503ae54d96d7 Mon Sep 17 00:00:00 2001 From: Siyamed Sinir Date: Thu, 12 Jan 2017 19:18:48 +0000 Subject: [PATCH 223/364] Revert "Reduce memory usage of FontCollection." This reverts commit 41ef8b376f4616ba13e13096f7c03a4caa0c695a. Test: Manually tested Bug: 34247671 Change-Id: I0510009b2deac784770f26059681b1980800abc8 --- engine/src/flutter/include/minikin/FontCollection.h | 10 +++++----- engine/src/flutter/libs/minikin/FontCollection.cpp | 13 ++++++------- 2 files changed, 11 insertions(+), 12 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index f6312dcea5..c9c8520be6 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -58,8 +58,8 @@ private: static const int kPageMask = (1 << kLogCharsPerPage) - 1; struct Range { - uint8_t start; - uint8_t end; + size_t start; + size_t end; }; FontFamily* getFamilyForChar(uint32_t ch, uint32_t vs, uint32_t langListId, int variant) const; @@ -87,14 +87,14 @@ private: // This vector can't be empty. std::vector mFamilies; - // This vector contains indices into mFamilies. + // This vector contains pointers into mInstances // This vector can't be empty. - std::vector mFamilyVec; + std::vector mFamilyVec; // This vector has pointers to the font family instance which has cmap 14 subtable. std::vector mVSFamilyVec; - // These are offsets into mFamilyVec, one range per page + // These are offsets into mInstanceVec, one range per page std::vector mRanges; }; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 7ad2f48565..365d7752b0 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -111,8 +111,6 @@ FontCollection::FontCollection(const vector& typefaces) : nTypefaces = mFamilies.size(); LOG_ALWAYS_FATAL_IF(nTypefaces == 0, "Font collection must have at least one valid typeface"); - LOG_ALWAYS_FATAL_IF(nTypefaces > 254, - "Up to 254 font families can be registered to collection."); size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage; size_t offset = 0; // TODO: Use variation selector map for mRanges construction. @@ -126,11 +124,11 @@ FontCollection::FontCollection(const vector& typefaces) : #ifdef VERBOSE_DEBUG ALOGD("i=%zd: range start = %zd\n", i, offset); #endif - range->start = (uint8_t)offset; + range->start = offset; for (size_t j = 0; j < nTypefaces; j++) { if (lastChar[j] < (i + 1) << kLogCharsPerPage) { FontFamily* family = mFamilies[j]; - mFamilyVec.push_back((uint8_t)j); + mFamilyVec.push_back(family); offset++; uint32_t nextChar = family->getCoverage()->nextSetBit((i + 1) << kLogCharsPerPage); #ifdef VERBOSE_DEBUG @@ -139,7 +137,7 @@ FontCollection::FontCollection(const vector& typefaces) : lastChar[j] = nextChar; } } - range->end = (uint8_t)offset; + range->end = offset; } } @@ -286,10 +284,11 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, return mFamilies[0]; } + const std::vector& familyVec = (vs == 0) ? mFamilyVec : mFamilies; Range range = mRanges[ch >> kLogCharsPerPage]; if (vs != 0) { - range = { 0, (uint8_t)mFamilies.size() }; + range = { 0, mFamilies.size() }; } #ifdef VERBOSE_DEBUG @@ -298,7 +297,7 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, FontFamily* bestFamily = nullptr; uint32_t bestScore = kUnsupportedFontScore; for (size_t i = range.start; i < range.end; i++) { - FontFamily* family = vs == 0 ? mFamilies[mFamilyVec[i]] : mFamilies[i]; + FontFamily* family = familyVec[i]; const uint32_t score = calcFamilyScore(ch, vs, variant, langListId, family); if (score == kFirstFontScore) { // If the first font family supports the given character or variation sequence, always From df0cbf3bc0c9bb40ca0e15b3755530a14b9c842a Mon Sep 17 00:00:00 2001 From: Siyamed Sinir Date: Fri, 20 Jan 2017 01:11:20 +0000 Subject: [PATCH 224/364] Revert "Introduce createCollectionWithVariation." This reverts commit ed8318e4e860e7e542fa5143c399c3d1328bc25e. Bug: 34378805 Change-Id: I22b683f774813724f220b1b8584ab188f3cf4fa7 --- .../minikin/AnalyzeStyle.h} | 9 +-- .../flutter/include/minikin/FontCollection.h | 8 -- .../src/flutter/include/minikin/FontFamily.h | 17 +--- .../src/flutter/include/minikin/MinikinFont.h | 4 - .../src/flutter/libs/minikin/AnalyzeStyle.cpp | 43 +++++++++++ engine/src/flutter/libs/minikin/Android.mk | 2 +- .../flutter/libs/minikin/FontCollection.cpp | 39 ---------- .../src/flutter/libs/minikin/FontFamily.cpp | 67 ++-------------- engine/src/flutter/libs/minikin/FontUtils.cpp | 77 ------------------- engine/src/flutter/tests/unittest/Android.mk | 1 - .../tests/unittest/FontCollectionTest.cpp | 72 ----------------- .../flutter/tests/unittest/FontFamilyTest.cpp | 63 --------------- .../flutter/tests/util/MinikinFontForTest.cpp | 9 +-- .../flutter/tests/util/MinikinFontForTest.h | 9 +-- 14 files changed, 55 insertions(+), 365 deletions(-) rename engine/src/flutter/{libs/minikin/FontUtils.h => include/minikin/AnalyzeStyle.h} (75%) create mode 100644 engine/src/flutter/libs/minikin/AnalyzeStyle.cpp delete mode 100644 engine/src/flutter/libs/minikin/FontUtils.cpp diff --git a/engine/src/flutter/libs/minikin/FontUtils.h b/engine/src/flutter/include/minikin/AnalyzeStyle.h similarity index 75% rename from engine/src/flutter/libs/minikin/FontUtils.h rename to engine/src/flutter/include/minikin/AnalyzeStyle.h index fa2051b409..b4cd915108 100644 --- a/engine/src/flutter/libs/minikin/FontUtils.h +++ b/engine/src/flutter/include/minikin/AnalyzeStyle.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2016 The Android Open Source Project + * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,15 +14,12 @@ * limitations under the License. */ -#ifndef MINIKIN_FONT_UTILS_H -#define MINIKIN_FONT_UTILS_H - -#include +#ifndef MINIKIN_ANALYZE_STYLE_H +#define MINIKIN_ANALYZE_STYLE_H namespace minikin { bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic); -void analyzeAxes(const uint8_t* fvar_data, size_t fvar_size, std::unordered_set* axes); } // namespace minikin diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index eaebcbcf93..f6312dcea5 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -18,7 +18,6 @@ #define MINIKIN_FONT_COLLECTION_H #include -#include #include #include @@ -52,10 +51,6 @@ public: // Get base font with fakery information (fake bold could affect metrics) FakedFont baseFontFaked(FontStyle style); - // Creates new FontCollection based on this collection while applying font variations. Returns - // nullptr if none of variations apply to this collection. - FontCollection* createCollectionWithVariation(const std::vector& variations); - uint32_t getId() const; private: @@ -101,9 +96,6 @@ private: // These are offsets into mFamilyVec, one range per page std::vector mRanges; - - // Set of supported axes in this collection. - std::unordered_set mSupportedAxes; }; } // namespace minikin diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index b848a04630..bdf00e9f7c 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -19,7 +19,6 @@ #include #include -#include #include #include @@ -99,8 +98,6 @@ struct FakedFont { FontFakery fakery; }; -typedef uint32_t AxisTag; - struct Font { Font(MinikinFont* typeface, FontStyle style); Font(Font&& o); @@ -109,13 +106,6 @@ struct Font { MinikinFont* typeface; FontStyle style; - std::unordered_set supportedAxes; -}; - -struct FontVariation { - FontVariation(AxisTag axisTag, float value) : axisTag(axisTag), value(value) {} - AxisTag axisTag; - float value; }; class FontFamily : public MinikinRefCounted { @@ -139,7 +129,6 @@ public: MinikinFont* getFont(size_t index) const { return mFonts[index].typeface; } FontStyle getStyle(size_t index) const { return mFonts[index].style; } bool isColorEmojiFamily() const; - const std::unordered_set& supportedAxes() const { return mSupportedAxes; } // Get Unicode coverage. const SparseBitSet& getCoverage() const { return mCoverage; } @@ -151,16 +140,12 @@ public: // Returns true if this font family has a variaion sequence table (cmap format 14 subtable). bool hasVSTable() const { return mHasVSTable; } - // Creates new FontFamily based on this family while applying font variations. Returns nullptr - // if none of variations apply to this family. - FontFamily* createFamilyWithVariation(const std::vector& variations) const; - private: void computeCoverage(); + uint32_t mLangId; int mVariant; std::vector mFonts; - std::unordered_set mSupportedAxes; SparseBitSet mCoverage; bool mHasVSTable; diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 57b939788a..353edd6566 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -126,10 +126,6 @@ public: return 0; } - virtual MinikinFont* createFontWithVariation(const std::vector&) const { - return nullptr; - } - 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; diff --git a/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp b/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp new file mode 100644 index 0000000000..333f008f7f --- /dev/null +++ b/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include + +namespace minikin { + +// should we have a single FontAnalyzer class this stuff lives in, to avoid dup? +static int32_t readU16(const uint8_t* data, size_t offset) { + return data[offset] << 8 | data[offset + 1]; +} + +bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic) { + const size_t kUsWeightClassOffset = 4; + const size_t kFsSelectionOffset = 62; + const uint16_t kItalicFlag = (1 << 0); + if (os2_size < kFsSelectionOffset + 2) { + return false; + } + uint16_t weightClass = readU16(os2_data, kUsWeightClassOffset); + *weight = weightClass / 100; + uint16_t fsSelection = readU16(os2_data, kFsSelectionOffset); + *italic = (fsSelection & kItalicFlag) != 0; + return true; +} + +} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 44abb88532..d6c3df7f62 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -30,12 +30,12 @@ $(UNICODE_EMOJI_H): include $(CLEAR_VARS) minikin_src_files := \ + AnalyzeStyle.cpp \ CmapCoverage.cpp \ FontCollection.cpp \ FontFamily.cpp \ FontLanguage.cpp \ FontLanguageListCache.cpp \ - FontUtils.cpp \ GraphemeBreak.cpp \ HbFontCache.cpp \ Hyphenator.cpp \ diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index ac6f8f336d..9e9223fd2e 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -103,9 +103,6 @@ FontCollection::FontCollection(const vector& typefaces) : } mMaxChar = max(mMaxChar, coverage.length()); lastChar.push_back(coverage.nextSetBit(0)); - - const std::unordered_set& supportedAxes = family->supportedAxes(); - mSupportedAxes.insert(supportedAxes.begin(), supportedAxes.end()); } nTypefaces = mFamilies.size(); LOG_ALWAYS_FATAL_IF(nTypefaces == 0, @@ -465,42 +462,6 @@ FakedFont FontCollection::baseFontFaked(FontStyle style) { return mFamilies[0]->getClosestMatch(style); } -FontCollection* FontCollection::createCollectionWithVariation( - const std::vector& variations) { - if (variations.empty() || mSupportedAxes.empty()) { - return nullptr; - } - - bool hasSupportedAxis = false; - for (const FontVariation& variation : variations) { - if (mSupportedAxes.find(variation.axisTag) != mSupportedAxes.end()) { - hasSupportedAxis = true; - break; - } - } - if (!hasSupportedAxis) { - // None of variation axes are supported by this font collection. - return nullptr; - } - - std::vector families; - for (FontFamily* family : mFamilies) { - FontFamily* newFamily = family->createFamilyWithVariation(variations); - if (newFamily) { - families.push_back(newFamily); - } else { - family->Ref(); - families.push_back(family); - } - } - - FontCollection* result = new FontCollection(families); - for (FontFamily* family : families) { - family->Unref(); - } - return result; -} - uint32_t FontCollection::getId() const { return mId; } diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 5a277f7810..164cc7d8ad 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -28,11 +28,10 @@ #include "FontLanguage.h" #include "FontLanguageListCache.h" -#include "FontUtils.h" #include "HbFontCache.h" #include "MinikinInternal.h" +#include #include -#include #include #include @@ -67,30 +66,19 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { Font::Font(MinikinFont* typeface, FontStyle style) : typeface(typeface), style(style) { - android::AutoMutex _l(gMinikinLock); - typeface->RefLocked(); - - const uint32_t fvarTag = MinikinFont::MakeTag('f', 'v', 'a', 'r'); - HbBlob fvarTable(getFontTable(typeface, fvarTag)); - if (fvarTable.size() == 0) { - return; - } - - analyzeAxes(fvarTable.get(), fvarTable.size(), &supportedAxes); + typeface->Ref(); } Font::Font(Font&& o) { typeface = o.typeface; style = o.style; o.typeface = nullptr; - supportedAxes = std::move(o.supportedAxes); } Font::Font(const Font& o) { typeface = o.typeface; typeface->Ref(); style = o.style; - supportedAxes = o.supportedAxes; } Font::~Font() { @@ -186,10 +174,9 @@ void FontFamily::computeCoverage() { } // TODO: Error check? CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); - - for (size_t i = 0; i < mFonts.size(); ++i) { - mSupportedAxes.insert(mFonts[i].supportedAxes.begin(), mFonts[i].supportedAxes.end()); - } +#ifdef VERBOSE_DEBUG + ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), mCoverage.nextSetBit(0)); +#endif } bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const { @@ -209,48 +196,4 @@ bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const return result; } -FontFamily* FontFamily::createFamilyWithVariation( - const std::vector& variations) const { - if (variations.empty() || mSupportedAxes.empty()) { - return nullptr; - } - - bool hasSupportedAxis = false; - for (const FontVariation& variation : variations) { - if (mSupportedAxes.find(variation.axisTag) != mSupportedAxes.end()) { - hasSupportedAxis = true; - break; - } - } - if (!hasSupportedAxis) { - // None of variation axes are suppored by this family. - return nullptr; - } - - std::vector fonts; - for (const Font& font : mFonts) { - bool supportedVariations = false; - if (!font.supportedAxes.empty()) { - for (const FontVariation& variation : variations) { - if (font.supportedAxes.find(variation.axisTag) != font.supportedAxes.end()) { - supportedVariations = true; - break; - } - } - } - MinikinFont* minikinFont = nullptr; - if (supportedVariations) { - minikinFont = font.typeface->createFontWithVariation(variations); - } - if (minikinFont == nullptr) { - minikinFont = font.typeface; - minikinFont->Ref(); - } - fonts.push_back(Font(minikinFont, font.style)); - minikinFont->Unref(); - } - - return new FontFamily(mLangId, mVariant, std::move(fonts)); -} - } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontUtils.cpp b/engine/src/flutter/libs/minikin/FontUtils.cpp deleted file mode 100644 index 56be16d696..0000000000 --- a/engine/src/flutter/libs/minikin/FontUtils.cpp +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright (C) 2016 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 -#include - -#include "FontUtils.h" - -namespace minikin { - -static uint16_t readU16(const uint8_t* data, size_t offset) { - return data[offset] << 8 | data[offset + 1]; -} - -static uint32_t readU32(const uint8_t* data, size_t offset) { - return ((uint32_t)data[offset]) << 24 | ((uint32_t)data[offset + 1]) << 16 | - ((uint32_t)data[offset + 2]) << 8 | ((uint32_t)data[offset + 3]); -} - -bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic) { - const size_t kUsWeightClassOffset = 4; - const size_t kFsSelectionOffset = 62; - const uint16_t kItalicFlag = (1 << 0); - if (os2_size < kFsSelectionOffset + 2) { - return false; - } - uint16_t weightClass = readU16(os2_data, kUsWeightClassOffset); - *weight = weightClass / 100; - uint16_t fsSelection = readU16(os2_data, kFsSelectionOffset); - *italic = (fsSelection & kItalicFlag) != 0; - return true; -} - -void analyzeAxes(const uint8_t* fvar_data, size_t fvar_size, std::unordered_set* axes) { - const size_t kMajorVersionOffset = 0; - const size_t kMinorVersionOffset = 2; - const size_t kOffsetToAxesArrayOffset = 4; - const size_t kAxisCountOffset = 8; - const size_t kAxisSizeOffset = 10; - - axes->clear(); - - if (fvar_size < kAxisSizeOffset + 2) { - return; - } - const uint16_t majorVersion = readU16(fvar_data, kMajorVersionOffset); - const uint16_t minorVersion = readU16(fvar_data, kMinorVersionOffset); - const uint32_t axisOffset = readU16(fvar_data, kOffsetToAxesArrayOffset); - const uint32_t axisCount = readU16(fvar_data, kAxisCountOffset); - const uint32_t axisSize = readU16(fvar_data, kAxisSizeOffset); - - if (majorVersion != 1 || minorVersion != 0 || axisOffset != 0x10 || axisSize != 0x14) { - return; // Unsupported version. - } - if (fvar_size < axisOffset + axisOffset * axisCount) { - return; // Invalid table size. - } - for (uint32_t i = 0; i < axisCount; ++i) { - size_t axisRecordOffset = axisOffset + i * axisSize; - uint32_t tag = readU32(fvar_data, axisRecordOffset); - axes->insert(tag); - } -} -} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index 7b3f60f8f9..cced545737 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -27,7 +27,6 @@ LOCAL_TEST_DATA := \ data/Italic.ttf \ data/Ja.ttf \ data/Ko.ttf \ - data/MultiAxis.ttf \ data/NoCmapFormat14.ttf \ data/NoGlyphFont.ttf \ data/Regular.ttf \ diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index 02e861c903..c0b6b526b7 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -121,76 +121,4 @@ TEST(FontCollectionTest, newEmojiTest) { EXPECT_FALSE(collection->hasVariationSelector(0x2642, 0xFE0F)); } -TEST(FontCollectionTest, createWithVariations) { - // This font has 'wdth' and 'wght' axes. - const char kMultiAxisFont[] = kTestFontDir "/MultiAxis.ttf"; - const char kNoAxisFont[] = kTestFontDir "/Regular.ttf"; - - MinikinAutoUnref multiAxisFont(new MinikinFontForTest(kMultiAxisFont)); - MinikinAutoUnref multiAxisFamily(new FontFamily( - std::vector({ Font(multiAxisFont.get(), FontStyle()) }))); - std::vector multiAxisFamilies({multiAxisFamily.get()}); - MinikinAutoUnref multiAxisFc(new FontCollection(multiAxisFamilies)); - - MinikinAutoUnref noAxisFont(new MinikinFontForTest(kNoAxisFont)); - MinikinAutoUnref noAxisFamily(new FontFamily( - std::vector({ Font(noAxisFont.get(), FontStyle()) }))); - std::vector noAxisFamilies({noAxisFamily.get()}); - MinikinAutoUnref noAxisFc(new FontCollection(noAxisFamilies)); - - { - // Do not ceate new instance if none of variations are specified. - EXPECT_EQ(nullptr, - multiAxisFc->createCollectionWithVariation(std::vector())); - EXPECT_EQ(nullptr, - noAxisFc->createCollectionWithVariation(std::vector())); - } - { - // New instance should be used for supported variation. - std::vector variations = { - { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f } - }; - MinikinAutoUnref newFc( - multiAxisFc->createCollectionWithVariation(variations)); - EXPECT_NE(nullptr, newFc.get()); - EXPECT_NE(multiAxisFc.get(), newFc.get()); - - EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); - } - { - // New instance should be used for supported variation (multiple variations case). - std::vector variations = { - { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, - { MinikinFont::MakeTag('w', 'g', 'h', 't'), 1.0f } - }; - MinikinAutoUnref newFc( - multiAxisFc->createCollectionWithVariation(variations)); - EXPECT_NE(nullptr, newFc.get()); - EXPECT_NE(multiAxisFc.get(), newFc.get()); - - EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); - } - { - // Do not ceate new instance if none of variations are supported. - std::vector variations = { - { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } - }; - EXPECT_EQ(nullptr, multiAxisFc->createCollectionWithVariation(variations)); - EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); - } - { - // At least one axis is supported, should create new instance. - std::vector variations = { - { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, - { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } - }; - MinikinAutoUnref newFc( - multiAxisFc->createCollectionWithVariation(variations)); - EXPECT_NE(nullptr, newFc.get()); - EXPECT_NE(multiAxisFc.get(), newFc.get()); - - EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); - } -} - } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 35f387304b..ddc36e4570 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -527,67 +527,4 @@ TEST_F(FontFamilyTest, hasVSTableTest) { } } -TEST_F(FontFamilyTest, createFamilyWithVariationTest) { - // This font has 'wdth' and 'wght' axes. - const char kMultiAxisFont[] = kTestFontDir "/MultiAxis.ttf"; - const char kNoAxisFont[] = kTestFontDir "/Regular.ttf"; - - MinikinAutoUnref multiAxisFont(new MinikinFontForTest(kMultiAxisFont)); - MinikinAutoUnref multiAxisFamily(new FontFamily( - std::vector({Font(multiAxisFont.get(), FontStyle())}))); - - MinikinAutoUnref noAxisFont(new MinikinFontForTest(kNoAxisFont)); - MinikinAutoUnref noAxisFamily(new FontFamily( - std::vector({Font(noAxisFont.get(), FontStyle())}))); - - { - // Do not ceate new instance if none of variations are specified. - EXPECT_EQ(nullptr, - multiAxisFamily->createFamilyWithVariation(std::vector())); - EXPECT_EQ(nullptr, - noAxisFamily->createFamilyWithVariation(std::vector())); - } - { - // New instance should be used for supported variation. - std::vector variations = {{MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f}}; - MinikinAutoUnref newFamily( - multiAxisFamily->createFamilyWithVariation(variations)); - EXPECT_NE(nullptr, newFamily.get()); - EXPECT_NE(multiAxisFamily.get(), newFamily.get()); - EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); - } - { - // New instance should be used for supported variation. (multiple variations case) - std::vector variations = { - { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, - { MinikinFont::MakeTag('w', 'g', 'h', 't'), 1.0f } - }; - MinikinAutoUnref newFamily( - multiAxisFamily->createFamilyWithVariation(variations)); - EXPECT_NE(nullptr, newFamily.get()); - EXPECT_NE(multiAxisFamily.get(), newFamily.get()); - EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); - } - { - // Do not ceate new instance if none of variations are supported. - std::vector variations = { - { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } - }; - EXPECT_EQ(nullptr, multiAxisFamily->createFamilyWithVariation(variations)); - EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); - } - { - // At least one axis is supported, should create new instance. - std::vector variations = { - { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, - { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } - }; - MinikinAutoUnref newFamily( - multiAxisFamily->createFamilyWithVariation(variations)); - EXPECT_NE(nullptr, newFamily.get()); - EXPECT_NE(multiAxisFamily.get(), newFamily.get()); - EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); - } -} - } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index f191f07d6e..a4132e5178 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -34,11 +34,9 @@ namespace minikin { static int uniqueId = 0; // TODO: make thread safe if necessary. -MinikinFontForTest::MinikinFontForTest(const std::string& font_path, int index, - const std::vector& variations) : +MinikinFontForTest::MinikinFontForTest(const std::string& font_path, int index) : MinikinFont(uniqueId++), mFontPath(font_path), - mVariations(variations), mFontIndex(index) { int fd = open(font_path.c_str(), O_RDONLY); LOG_ALWAYS_FATAL_IF(fd == -1); @@ -69,9 +67,4 @@ void MinikinFontForTest::GetBounds(MinikinRect* bounds, uint32_t /* glyph_id */, bounds->mBottom = 10.0f; } -MinikinFont* MinikinFontForTest::createFontWithVariation( - const std::vector& variations) const { - return new MinikinFontForTest(mFontPath, mFontIndex, variations); -} - } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index 2a107036ed..ee0eadbe0c 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -25,10 +25,7 @@ namespace minikin { class MinikinFontForTest : public MinikinFont { public: - MinikinFontForTest(const std::string& font_path, int index, - const std::vector& variations); - MinikinFontForTest(const std::string& font_path, int index) - : MinikinFontForTest(font_path, index, std::vector()) {} + MinikinFontForTest(const std::string& font_path, int index); MinikinFontForTest(const std::string& font_path) : MinikinFontForTest(font_path, 0) {} virtual ~MinikinFontForTest(); @@ -38,19 +35,15 @@ public: const MinikinPaint& paint) const; const std::string& fontPath() const { return mFontPath; } - const std::vector& variations() const { return mVariations; } - const void* GetFontData() const { return mFontData; } size_t GetFontSize() const { return mFontSize; } int GetFontIndex() const { return mFontIndex; } - MinikinFont* createFontWithVariation(const std::vector& variations) const; private: MinikinFontForTest() = delete; MinikinFontForTest(const MinikinFontForTest&) = delete; MinikinFontForTest& operator=(MinikinFontForTest&) = delete; const std::string mFontPath; - const std::vector mVariations; const int mFontIndex; void* mFontData; size_t mFontSize; From 92c0eb1f83a380f4a8f5f7f8e2007dbc0ca433eb Mon Sep 17 00:00:00 2001 From: Siyamed Sinir Date: Fri, 20 Jan 2017 01:11:02 +0000 Subject: [PATCH 225/364] Revert "Remove FontFamily.addFont and make FontFamily immutable." This reverts commit 0470cdb3e41f0ae603f6a3e89efabdc196424652. Bug: 34378805 Change-Id: I8f1ee00b365c8b17c6140e9e286fbea082e31364 --- .../src/flutter/include/minikin/FontFamily.h | 57 ++++----- .../flutter/libs/minikin/FontCollection.cpp | 18 +-- .../src/flutter/libs/minikin/FontFamily.cpp | 113 ++++++++++-------- engine/src/flutter/sample/example.cpp | 8 +- engine/src/flutter/sample/example_skia.cpp | 8 +- .../unittest/FontCollectionItemizeTest.cpp | 46 +++---- .../tests/unittest/FontCollectionTest.cpp | 4 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 22 ++-- .../src/flutter/tests/util/FontTestUtils.cpp | 25 ++-- 9 files changed, 163 insertions(+), 138 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index bdf00e9f7c..10362c24de 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -98,61 +98,64 @@ struct FakedFont { FontFakery fakery; }; -struct Font { - Font(MinikinFont* typeface, FontStyle style); - Font(Font&& o); - Font(const Font& o); - ~Font(); - - MinikinFont* typeface; - FontStyle style; -}; - class FontFamily : public MinikinRefCounted { public: - explicit FontFamily(std::vector&& fonts); - FontFamily(int variant, std::vector&& fonts); - FontFamily(uint32_t langId, int variant, std::vector&& fonts); + FontFamily(); + + explicit FontFamily(int variant); + + FontFamily(uint32_t langId, int variant) + : mLangId(langId), + mVariant(variant), + mHasVSTable(false), + mCoverageValid(false) { + } ~FontFamily(); - // TODO: Good to expose FontUtil.h. - static bool analyzeStyle(MinikinFont* typeface, int* weight, bool* italic); + // Add font to family, extracting style information from the font + bool addFont(MinikinFont* typeface); + void addFont(MinikinFont* typeface, FontStyle style); FakedFont getClosestMatch(FontStyle style) const; uint32_t langId() const { return mLangId; } int variant() const { return mVariant; } // API's for enumerating the fonts in a family. These don't guarantee any particular order - size_t getNumFonts() const { return mFonts.size(); } - MinikinFont* getFont(size_t index) const { return mFonts[index].typeface; } - FontStyle getStyle(size_t index) const { return mFonts[index].style; } + size_t getNumFonts() const; + MinikinFont* getFont(size_t index) const; + FontStyle getStyle(size_t index) const; bool isColorEmojiFamily() const; - // Get Unicode coverage. - const SparseBitSet& getCoverage() const { return mCoverage; } + // Get Unicode coverage. Lifetime of returned bitset is same as receiver. May return nullptr on + // error. + const SparseBitSet* getCoverage(); // Returns true if the font has a glyph for the code point and variation selector pair. // Caller should acquire a lock before calling the method. - bool hasGlyph(uint32_t codepoint, uint32_t variationSelector) const; + bool hasGlyph(uint32_t codepoint, uint32_t variationSelector); // Returns true if this font family has a variaion sequence table (cmap format 14 subtable). - bool hasVSTable() const { return mHasVSTable; } + bool hasVSTable() const; private: - void computeCoverage(); + void addFontLocked(MinikinFont* typeface, FontStyle style); + class Font { + public: + Font(MinikinFont* typeface, FontStyle style) : + typeface(typeface), style(style) { } + MinikinFont* typeface; + FontStyle style; + }; uint32_t mLangId; int mVariant; std::vector mFonts; SparseBitSet mCoverage; bool mHasVSTable; - - // Forbid copying and assignment. - FontFamily(const FontFamily&) = delete; - void operator=(const FontFamily&) = delete; + bool mCoverageValid; }; } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 4688520699..9d26377e6d 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -96,13 +96,17 @@ FontCollection::FontCollection(const vector& typefaces) : continue; } family->RefLocked(); - const SparseBitSet& coverage = family->getCoverage(); + const SparseBitSet* coverage = family->getCoverage(); + if (coverage == nullptr) { + family->UnrefLocked(); + continue; + } mFamilies.push_back(family); // emplace_back would be better if (family->hasVSTable()) { mVSFamilyVec.push_back(family); } - mMaxChar = max(mMaxChar, coverage.length()); - lastChar.push_back(coverage.nextSetBit(0)); + mMaxChar = max(mMaxChar, coverage->length()); + lastChar.push_back(coverage->nextSetBit(0)); } nTypefaces = mFamilies.size(); LOG_ALWAYS_FATAL_IF(nTypefaces == 0, @@ -126,7 +130,7 @@ FontCollection::FontCollection(const vector& typefaces) : FontFamily* family = mFamilies[j]; mFamilyVec.push_back(family); offset++; - uint32_t nextChar = family->getCoverage().nextSetBit((i + 1) << kLogCharsPerPage); + uint32_t nextChar = family->getCoverage()->nextSetBit((i + 1) << kLogCharsPerPage); #ifdef VERBOSE_DEBUG ALOGD("nextChar = %d (j = %zd)\n", nextChar, j); #endif @@ -193,7 +197,7 @@ uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, // variation sequence's base character. uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* fontFamily) const { const bool hasVSGlyph = (vs != 0) && fontFamily->hasGlyph(ch, vs); - if (!hasVSGlyph && !fontFamily->getCoverage().get(ch)) { + if (!hasVSGlyph && !fontFamily->getCoverage()->get(ch)) { // The font doesn't support either variation sequence or even the base character. return kUnsupportedFontScore; } @@ -412,7 +416,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty if (lastFamily != nullptr) { if (isStickyWhitelisted(ch)) { // Continue using existing font as long as it has coverage and is whitelisted - shouldContinueRun = lastFamily->getCoverage().get(ch); + shouldContinueRun = lastFamily->getCoverage()->get(ch); } else if (isVariationSelector(ch)) { // Always continue if the character is a variation selector. shouldContinueRun = true; @@ -432,7 +436,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty if (utf16Pos != 0 && ((U_GET_GC_MASK(ch) & U_GC_M_MASK) != 0 || (isEmojiModifier(ch) && isEmojiBase(prevCh))) && - family && family->getCoverage().get(prevCh)) { + family && family->getCoverage()->get(prevCh)) { const size_t prevChLength = U16_LENGTH(prevCh); run->end -= prevChLength; if (run->start == run->end) { diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 164cc7d8ad..8efa32a937 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -64,51 +64,45 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { return (weight & kWeightMask) | (italic ? kItalicMask : 0) | (variant << kVariantShift); } -Font::Font(MinikinFont* typeface, FontStyle style) - : typeface(typeface), style(style) { - typeface->Ref(); +FontFamily::FontFamily() : FontFamily(0 /* variant */) { } -Font::Font(Font&& o) { - typeface = o.typeface; - style = o.style; - o.typeface = nullptr; -} - -Font::Font(const Font& o) { - typeface = o.typeface; - typeface->Ref(); - style = o.style; -} - -Font::~Font() { - if (typeface == nullptr) { - return; - } - typeface->UnrefLocked(); -} - -FontFamily::FontFamily(std::vector&& fonts) : FontFamily(0 /* variant */, std::move(fonts)) { -} - -FontFamily::FontFamily(int variant, std::vector&& fonts) - : FontFamily(FontLanguageListCache::kEmptyListId, variant, std::move(fonts)) { -} - -FontFamily::FontFamily(uint32_t langId, int variant, std::vector&& fonts) - : mLangId(langId), mVariant(variant), mFonts(std::move(fonts)), mHasVSTable(false) { - computeCoverage(); +FontFamily::FontFamily(int variant) : FontFamily(FontLanguageListCache::kEmptyListId, variant) { } FontFamily::~FontFamily() { + for (size_t i = 0; i < mFonts.size(); i++) { + mFonts[i].typeface->UnrefLocked(); + } } -bool FontFamily::analyzeStyle(MinikinFont* typeface, int* weight, bool* italic) { +bool FontFamily::addFont(MinikinFont* typeface) { android::AutoMutex _l(gMinikinLock); const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); HbBlob os2Table(getFontTable(typeface, os2Tag)); if (os2Table.get() == nullptr) return false; - return ::minikin::analyzeStyle(os2Table.get(), os2Table.size(), weight, italic); + int weight; + bool italic; + if (analyzeStyle(os2Table.get(), os2Table.size(), &weight, &italic)) { + //ALOGD("analyzed weight = %d, italic = %s", weight, italic ? "true" : "false"); + FontStyle style(weight, italic); + addFontLocked(typeface, style); + return true; + } else { + ALOGD("failed to analyze style"); + } + return false; +} + +void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { + android::AutoMutex _l(gMinikinLock); + addFontLocked(typeface, style); +} + +void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { + typeface->RefLocked(); + mFonts.push_back(Font(typeface, style)); + mCoverageValid = false; } // Compute a matching metric between two styles - 0 is an exact match @@ -152,6 +146,18 @@ FakedFont FontFamily::getClosestMatch(FontStyle style) const { return result; } +size_t FontFamily::getNumFonts() const { + return mFonts.size(); +} + +MinikinFont* FontFamily::getFont(size_t index) const { + return mFonts[index].typeface; +} + +FontStyle FontFamily::getStyle(size_t index) const { + return mFonts[index].style; +} + bool FontFamily::isColorEmojiFamily() const { const FontLanguages& languageList = FontLanguageListCache::getById(mLangId); for (size_t i = 0; i < languageList.size(); ++i) { @@ -162,24 +168,30 @@ bool FontFamily::isColorEmojiFamily() const { return false; } -void FontFamily::computeCoverage() { - android::AutoMutex _l(gMinikinLock); - const FontStyle defaultStyle; - MinikinFont* typeface = getClosestMatch(defaultStyle).font; - const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); - HbBlob cmapTable(getFontTable(typeface, cmapTag)); - if (cmapTable.get() == nullptr) { - ALOGE("Could not get cmap table size!\n"); - return; - } - // TODO: Error check? - CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); +const SparseBitSet* FontFamily::getCoverage() { + if (!mCoverageValid) { + const FontStyle defaultStyle; + MinikinFont* typeface = getClosestMatch(defaultStyle).font; + const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); + HbBlob cmapTable(getFontTable(typeface, cmapTag)); + if (cmapTable.get() == nullptr) { + ALOGE("Could not get cmap table size!\n"); + // Note: This means we will retry on the next call to getCoverage, as we can't store + // the failure. This is fine, as we assume this doesn't really happen in practice. + return nullptr; + } + // TODO: Error check? + CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); #ifdef VERBOSE_DEBUG - ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), mCoverage.nextSetBit(0)); + ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), + mCoverage.nextSetBit(0)); #endif + mCoverageValid = true; + } + return &mCoverage; } -bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const { +bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) { assertMinikinLocked(); if (variationSelector != 0 && !mHasVSTable) { // Early exit if the variation selector is specified but the font doesn't have a cmap format @@ -196,4 +208,9 @@ bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const return result; } +bool FontFamily::hasVSTable() const { + LOG_ALWAYS_FATAL_IF(!mCoverageValid, "Do not call this method before getCoverage() call"); + return mHasVSTable; +} + } // namespace minikin diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index 1c9c322d23..a27918ea75 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -45,9 +45,9 @@ FontCollection *makeFontCollection() { "/system/fonts/Roboto-LightItalic.ttf" }; + FontFamily *family = new FontFamily(); FT_Face face; FT_Error error; - std::vector fonts; for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { const char *fn = fns[i]; printf("adding %s\n", fn); @@ -56,16 +56,16 @@ FontCollection *makeFontCollection() { printf("error loading %s, %d\n", fn, error); } MinikinFont *font = new MinikinFontFreeType(face); - fonts.push_back(Font(font, FontStyle())); + family->addFont(font); } - FontFamily *family = new FontFamily(std::move(fonts)); typefaces.push_back(family); #if 1 + family = new FontFamily(); const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; error = FT_New_Face(library, fn, 0, &face); MinikinFont *font = new MinikinFontFreeType(face); - family = new FontFamily(std::vector({ Font(font, FontStyle()) })); + family->addFont(font); typefaces.push_back(family); #endif diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index 6e6f868051..b04c8abcbc 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -54,21 +54,21 @@ FontCollection *makeFontCollection() { "/system/fonts/Roboto-LightItalic.ttf" }; - std::vector fonts; + FontFamily *family = new FontFamily(); for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { const char *fn = fns[i]; sk_sp skFace = SkTypeface::MakeFromFile(fn); MinikinFont *font = new MinikinFontSkia(std::move(skFace)); - fonts.push_back(Font(font, FontStyle())); + family->addFont(font); } - FontFamily *family = new FontFamily(std::move(fonts)); typefaces.push_back(family); #if 1 + family = new FontFamily(); const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; sk_sp skFace = SkTypeface::MakeFromFile(fn); MinikinFont *font = new MinikinFontSkia(std::move(skFace)); - family = new FontFamily(std::vector({ Font(font, FontStyle()) })); + family->addFont(font); typefaces.push_back(family); #endif diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 5c5a5d343c..52786d0c7e 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -668,14 +668,14 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { const std::string kVSTestFont = kTestFontDir "VarioationSelectorTest-Regular.ttf"; std::vector families; + FontFamily* family1 = new FontFamily(VARIANT_DEFAULT); MinikinAutoUnref font(new MinikinFontForTest(kLatinFont)); - FontFamily* family1 = new FontFamily(VARIANT_DEFAULT, - std::vector{ Font(font.get(), FontStyle()) }); + family1->addFont(font.get()); families.push_back(family1); + FontFamily* family2 = new FontFamily(VARIANT_DEFAULT); MinikinAutoUnref font2(new MinikinFontForTest(kVSTestFont)); - FontFamily* family2 = new FontFamily(VARIANT_DEFAULT, - std::vector{ Font(font2.get(), FontStyle()) }); + family2->addFont(font2.get()); families.push_back(family2); FontCollection collection(families); @@ -811,11 +811,11 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { std::vector families; // Prepare first font which doesn't supports U+9AA8 + FontFamily* firstFamily = new FontFamily( + FontStyle::registerLanguageList("und"), 0 /* variant */); MinikinAutoUnref firstFamilyMinikinFont( new MinikinFontForTest(kNoGlyphFont)); - FontFamily* firstFamily = new FontFamily( - FontStyle::registerLanguageList("und"), 0 /* variant */, - std::vector({ Font(firstFamilyMinikinFont.get(), FontStyle()) })); + firstFamily->addFont(firstFamilyMinikinFont.get()); families.push_back(firstFamily); // Prepare font families @@ -824,10 +824,10 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { std::unordered_map fontLangIdxMap; for (size_t i = 0; i < testCase.fontLanguages.size(); ++i) { - MinikinAutoUnref minikin_font(new MinikinFontForTest(kJAFont)); FontFamily* family = new FontFamily( - FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */, - std::vector({ Font(minikin_font.get(), FontStyle()) })); + FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */); + MinikinAutoUnref minikin_font(new MinikinFontForTest(kJAFont)); + family->addFont(minikin_font.get()); families.push_back(family); fontLangIdxMap.insert(std::make_pair(minikin_font.get(), i)); } @@ -1417,12 +1417,13 @@ TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS) { MinikinAutoUnref fontA(new MinikinFontForTest(kZH_HansFont)); MinikinAutoUnref fontB(new MinikinFontForTest(kZH_HansFont)); - MinikinAutoUnref dummyFamily(new FontFamily( - std::vector({ Font(dummyFont.get(), FontStyle()) }))); - MinikinAutoUnref familyA(new FontFamily( - std::vector({ Font(fontA.get(), FontStyle()) }))); - MinikinAutoUnref familyB(new FontFamily( - std::vector({ Font(fontB.get(), FontStyle()) }))); + MinikinAutoUnref dummyFamily(new FontFamily()); + MinikinAutoUnref familyA(new FontFamily()); + MinikinAutoUnref familyB(new FontFamily()); + + dummyFamily->addFont(dummyFont.get()); + familyA->addFont(fontA.get()); + familyB->addFont(fontB.get()); std::vector families = { dummyFamily.get(), familyA.get(), familyB.get() }; @@ -1452,12 +1453,13 @@ TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS2) { MinikinAutoUnref noCmapFormat14Font( new MinikinFontForTest(kNoCmapFormat14Font)); - MinikinAutoUnref dummyFamily(new FontFamily( - std::vector({ Font(dummyFont.get(), FontStyle()) }))); - MinikinAutoUnref hasCmapFormat14Family(new FontFamily( - std::vector({ Font(hasCmapFormat14Font.get(), FontStyle()) }))); - MinikinAutoUnref noCmapFormat14Family(new FontFamily( - std::vector({ Font(noCmapFormat14Font.get(), FontStyle()) }))); + MinikinAutoUnref dummyFamily(new FontFamily()); + MinikinAutoUnref hasCmapFormat14Family(new FontFamily()); + MinikinAutoUnref noCmapFormat14Family(new FontFamily()); + + dummyFamily->addFont(dummyFont.get()); + hasCmapFormat14Family->addFont(hasCmapFormat14Font.get()); + noCmapFormat14Family->addFont(noCmapFormat14Font.get()); std::vector families = { dummyFamily.get(), hasCmapFormat14Family.get(), noCmapFormat14Family.get() }; diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index c0b6b526b7..62d2f022fa 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -57,9 +57,9 @@ void expectVSGlyphs(const FontCollection* fc, uint32_t codepoint, const std::set } TEST(FontCollectionTest, hasVariationSelectorTest) { + MinikinAutoUnref family(new FontFamily()); MinikinAutoUnref font(new MinikinFontForTest(kVsTestFont)); - MinikinAutoUnref family(new FontFamily( - std::vector({ Font(font.get(), FontStyle()) }))); + family->addFont(font.get()); std::vector families({family.get()}); MinikinAutoUnref fc(new FontCollection(families)); diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index ddc36e4570..4409801892 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -464,10 +464,8 @@ void expectVSGlyphs(FontFamily* family, uint32_t codepoint, const std::set minikinFont(new MinikinFontForTest(kVsTestFont)); - MinikinAutoUnref family( - new FontFamily(std::vector{ - Font(minikinFont.get(), FontStyle()) - })); + MinikinAutoUnref family(new FontFamily); + family->addFont(minikinFont.get()); android::AutoMutex _l(gMinikinLock); @@ -480,23 +478,23 @@ TEST_F(FontFamilyTest, hasVariationSelectorTest) { const uint32_t kVS20 = 0xE0103; const uint32_t kSupportedChar1 = 0x82A6; - EXPECT_TRUE(family->getCoverage().get(kSupportedChar1)); + EXPECT_TRUE(family->getCoverage()->get(kSupportedChar1)); expectVSGlyphs(family.get(), kSupportedChar1, std::set({kVS1, kVS17, kVS18, kVS19})); const uint32_t kSupportedChar2 = 0x845B; - EXPECT_TRUE(family->getCoverage().get(kSupportedChar2)); + EXPECT_TRUE(family->getCoverage()->get(kSupportedChar2)); expectVSGlyphs(family.get(), kSupportedChar2, std::set({kVS2, kVS18, kVS19, kVS20})); const uint32_t kNoVsSupportedChar = 0x537F; - EXPECT_TRUE(family->getCoverage().get(kNoVsSupportedChar)); + EXPECT_TRUE(family->getCoverage()->get(kNoVsSupportedChar)); expectVSGlyphs(family.get(), kNoVsSupportedChar, std::set()); const uint32_t kVsOnlySupportedChar = 0x717D; - EXPECT_FALSE(family->getCoverage().get(kVsOnlySupportedChar)); + EXPECT_FALSE(family->getCoverage()->get(kVsOnlySupportedChar)); expectVSGlyphs(family.get(), kVsOnlySupportedChar, std::set({kVS3, kVS19, kVS20})); const uint32_t kNotSupportedChar = 0x845C; - EXPECT_FALSE(family->getCoverage().get(kNotSupportedChar)); + EXPECT_FALSE(family->getCoverage()->get(kNotSupportedChar)); expectVSGlyphs(family.get(), kNotSupportedChar, std::set()); } @@ -520,9 +518,11 @@ TEST_F(FontFamilyTest, hasVSTableTest) { MinikinAutoUnref minikinFont( new MinikinFontForTest(testCase.fontPath)); - MinikinAutoUnref family(new FontFamily( - std::vector{ Font(minikinFont.get(), FontStyle()) })); + MinikinAutoUnref family(new FontFamily); + family->addFont(minikinFont.get()); android::AutoMutex _l(gMinikinLock); + family->getCoverage(); + EXPECT_EQ(testCase.hasVSTable, family->hasVSTable()); } } diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index e29a2fe534..0c7b2ba032 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -48,7 +48,16 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { } } - std::vector fonts; + xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); + FontFamily* family; + if (lang == nullptr) { + family = new FontFamily(variant); + } else { + uint32_t langId = FontStyle::registerLanguageList( + std::string((const char*)lang, xmlStrlen(lang))); + family = new FontFamily(langId, variant); + } + for (xmlNode* fontNode = familyNode->children; fontNode; fontNode = fontNode->next) { if (xmlStrcmp(fontNode->name, (const xmlChar*)"font") != 0) { continue; @@ -71,23 +80,13 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { if (index == nullptr) { MinikinAutoUnref minikinFont(new MinikinFontForTest(fontPath)); - fonts.push_back(Font(minikinFont.get(), FontStyle(weight, italic))); + family->addFont(minikinFont.get(), FontStyle(weight, italic)); } else { MinikinAutoUnref minikinFont(new MinikinFontForTest(fontPath, atoi((const char*)index))); - fonts.push_back(Font(minikinFont.get(), FontStyle(weight, italic))); + family->addFont(minikinFont.get(), FontStyle(weight, italic)); } } - - xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); - FontFamily* family; - if (lang == nullptr) { - family = new FontFamily(variant, std::move(fonts)); - } else { - uint32_t langId = FontStyle::registerLanguageList( - std::string((const char*)lang, xmlStrlen(lang))); - family = new FontFamily(langId, variant, std::move(fonts)); - } families.push_back(family); } xmlFreeDoc(doc); From 0afb39eaedb81d0e9c07b2bd276aa33384519d79 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 29 Dec 2016 00:36:30 +0900 Subject: [PATCH 226/364] Remove FontFamily.addFont and make FontFamily immutable. This is 2nd attempt of 0470cdb3e41f0ae603f6a3e89efabdc196424652 The difference is adding clearElementsEithLock to Font class which is necessary to delete Fonts object outside of minikin. This method should be removed once http://b/28119474 is fixed. Here is original commit message of reverted change. This lays the groundwork for making SparseBitSet serializable. FontFamily.addFont is only used when the FontFamily is constructed. Thus, instead of calling FontFamily.addFont multiple time, passes Font list to the constructor. By this change, FontFamily can be immutable now. By making FontFamily immutable, We can create FontFamily with pre-calculated SparseBitSet. Bug: 34042446 Bug: 28119474 Bug: 34378805 Test: minikin_tests has passed Change-Id: Ice433931196f5ae79a1a7ee0c98020f914aeb5f2 --- .../src/flutter/include/minikin/FontFamily.h | 62 ++++----- .../flutter/libs/minikin/FontCollection.cpp | 18 +-- .../src/flutter/libs/minikin/FontFamily.cpp | 120 ++++++++---------- engine/src/flutter/sample/example.cpp | 8 +- engine/src/flutter/sample/example_skia.cpp | 8 +- .../unittest/FontCollectionItemizeTest.cpp | 46 ++++--- .../tests/unittest/FontCollectionTest.cpp | 4 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 22 ++-- .../src/flutter/tests/util/FontTestUtils.cpp | 25 ++-- 9 files changed, 149 insertions(+), 164 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 10362c24de..71a6384055 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -98,64 +98,66 @@ struct FakedFont { FontFakery fakery; }; +struct Font { + Font(MinikinFont* typeface, FontStyle style); + Font(Font&& o); + Font(const Font& o); + ~Font(); + + MinikinFont* typeface; + FontStyle style; + + // TODO: remove this weird function. http://b/28119474 + // MinikinFont requres mutex lock for destruction, but the mutex lock is not + // visible from outside of minikin library. + static void clearElementsWithLock(std::vector* fonts); +}; + class FontFamily : public MinikinRefCounted { public: - FontFamily(); - - explicit FontFamily(int variant); - - FontFamily(uint32_t langId, int variant) - : mLangId(langId), - mVariant(variant), - mHasVSTable(false), - mCoverageValid(false) { - } + explicit FontFamily(std::vector&& fonts); + FontFamily(int variant, std::vector&& fonts); + FontFamily(uint32_t langId, int variant, std::vector&& fonts); ~FontFamily(); - // Add font to family, extracting style information from the font - bool addFont(MinikinFont* typeface); + // TODO: Good to expose FontUtil.h. + static bool analyzeStyle(MinikinFont* typeface, int* weight, bool* italic); - void addFont(MinikinFont* typeface, FontStyle style); FakedFont getClosestMatch(FontStyle style) const; uint32_t langId() const { return mLangId; } int variant() const { return mVariant; } // API's for enumerating the fonts in a family. These don't guarantee any particular order - size_t getNumFonts() const; - MinikinFont* getFont(size_t index) const; - FontStyle getStyle(size_t index) const; + size_t getNumFonts() const { return mFonts.size(); } + MinikinFont* getFont(size_t index) const { return mFonts[index].typeface; } + FontStyle getStyle(size_t index) const { return mFonts[index].style; } bool isColorEmojiFamily() const; - // Get Unicode coverage. Lifetime of returned bitset is same as receiver. May return nullptr on - // error. - const SparseBitSet* getCoverage(); + // Get Unicode coverage. + const SparseBitSet& getCoverage() const { return mCoverage; } // Returns true if the font has a glyph for the code point and variation selector pair. // Caller should acquire a lock before calling the method. - bool hasGlyph(uint32_t codepoint, uint32_t variationSelector); + bool hasGlyph(uint32_t codepoint, uint32_t variationSelector) const; // Returns true if this font family has a variaion sequence table (cmap format 14 subtable). - bool hasVSTable() const; + bool hasVSTable() const { return mHasVSTable; } private: - void addFontLocked(MinikinFont* typeface, FontStyle style); + void computeCoverage(); - class Font { - public: - Font(MinikinFont* typeface, FontStyle style) : - typeface(typeface), style(style) { } - MinikinFont* typeface; - FontStyle style; - }; uint32_t mLangId; int mVariant; std::vector mFonts; SparseBitSet mCoverage; bool mHasVSTable; - bool mCoverageValid; + + // Forbid copying and assignment. + FontFamily(const FontFamily&) = delete; + void operator=(const FontFamily&) = delete; }; } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 9d26377e6d..4688520699 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -96,17 +96,13 @@ FontCollection::FontCollection(const vector& typefaces) : continue; } family->RefLocked(); - const SparseBitSet* coverage = family->getCoverage(); - if (coverage == nullptr) { - family->UnrefLocked(); - continue; - } + const SparseBitSet& coverage = family->getCoverage(); mFamilies.push_back(family); // emplace_back would be better if (family->hasVSTable()) { mVSFamilyVec.push_back(family); } - mMaxChar = max(mMaxChar, coverage->length()); - lastChar.push_back(coverage->nextSetBit(0)); + mMaxChar = max(mMaxChar, coverage.length()); + lastChar.push_back(coverage.nextSetBit(0)); } nTypefaces = mFamilies.size(); LOG_ALWAYS_FATAL_IF(nTypefaces == 0, @@ -130,7 +126,7 @@ FontCollection::FontCollection(const vector& typefaces) : FontFamily* family = mFamilies[j]; mFamilyVec.push_back(family); offset++; - uint32_t nextChar = family->getCoverage()->nextSetBit((i + 1) << kLogCharsPerPage); + uint32_t nextChar = family->getCoverage().nextSetBit((i + 1) << kLogCharsPerPage); #ifdef VERBOSE_DEBUG ALOGD("nextChar = %d (j = %zd)\n", nextChar, j); #endif @@ -197,7 +193,7 @@ uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, // variation sequence's base character. uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* fontFamily) const { const bool hasVSGlyph = (vs != 0) && fontFamily->hasGlyph(ch, vs); - if (!hasVSGlyph && !fontFamily->getCoverage()->get(ch)) { + if (!hasVSGlyph && !fontFamily->getCoverage().get(ch)) { // The font doesn't support either variation sequence or even the base character. return kUnsupportedFontScore; } @@ -416,7 +412,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty if (lastFamily != nullptr) { if (isStickyWhitelisted(ch)) { // Continue using existing font as long as it has coverage and is whitelisted - shouldContinueRun = lastFamily->getCoverage()->get(ch); + shouldContinueRun = lastFamily->getCoverage().get(ch); } else if (isVariationSelector(ch)) { // Always continue if the character is a variation selector. shouldContinueRun = true; @@ -436,7 +432,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty if (utf16Pos != 0 && ((U_GET_GC_MASK(ch) & U_GC_M_MASK) != 0 || (isEmojiModifier(ch) && isEmojiBase(prevCh))) && - family && family->getCoverage()->get(prevCh)) { + family && family->getCoverage().get(prevCh)) { const size_t prevChLength = U16_LENGTH(prevCh); run->end -= prevChLength; if (run->start == run->end) { diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 8efa32a937..619110db8e 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -64,45 +64,56 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { return (weight & kWeightMask) | (italic ? kItalicMask : 0) | (variant << kVariantShift); } -FontFamily::FontFamily() : FontFamily(0 /* variant */) { +Font::Font(MinikinFont* typeface, FontStyle style) + : typeface(typeface), style(style) { + typeface->Ref(); } -FontFamily::FontFamily(int variant) : FontFamily(FontLanguageListCache::kEmptyListId, variant) { +Font::Font(Font&& o) { + typeface = o.typeface; + style = o.style; + o.typeface = nullptr; +} + +Font::Font(const Font& o) { + typeface = o.typeface; + typeface->Ref(); + style = o.style; +} + +Font::~Font() { + if (typeface == nullptr) { + return; + } + typeface->UnrefLocked(); +} + +void Font::clearElementsWithLock(std::vector* fonts) { + android::AutoMutex _l(gMinikinLock); + fonts->clear(); +} + +FontFamily::FontFamily(std::vector&& fonts) : FontFamily(0 /* variant */, std::move(fonts)) { +} + +FontFamily::FontFamily(int variant, std::vector&& fonts) + : FontFamily(FontLanguageListCache::kEmptyListId, variant, std::move(fonts)) { +} + +FontFamily::FontFamily(uint32_t langId, int variant, std::vector&& fonts) + : mLangId(langId), mVariant(variant), mFonts(std::move(fonts)), mHasVSTable(false) { + computeCoverage(); } FontFamily::~FontFamily() { - for (size_t i = 0; i < mFonts.size(); i++) { - mFonts[i].typeface->UnrefLocked(); - } } -bool FontFamily::addFont(MinikinFont* typeface) { +bool FontFamily::analyzeStyle(MinikinFont* typeface, int* weight, bool* italic) { android::AutoMutex _l(gMinikinLock); const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); HbBlob os2Table(getFontTable(typeface, os2Tag)); if (os2Table.get() == nullptr) return false; - int weight; - bool italic; - if (analyzeStyle(os2Table.get(), os2Table.size(), &weight, &italic)) { - //ALOGD("analyzed weight = %d, italic = %s", weight, italic ? "true" : "false"); - FontStyle style(weight, italic); - addFontLocked(typeface, style); - return true; - } else { - ALOGD("failed to analyze style"); - } - return false; -} - -void FontFamily::addFont(MinikinFont* typeface, FontStyle style) { - android::AutoMutex _l(gMinikinLock); - addFontLocked(typeface, style); -} - -void FontFamily::addFontLocked(MinikinFont* typeface, FontStyle style) { - typeface->RefLocked(); - mFonts.push_back(Font(typeface, style)); - mCoverageValid = false; + return ::minikin::analyzeStyle(os2Table.get(), os2Table.size(), weight, italic); } // Compute a matching metric between two styles - 0 is an exact match @@ -146,18 +157,6 @@ FakedFont FontFamily::getClosestMatch(FontStyle style) const { return result; } -size_t FontFamily::getNumFonts() const { - return mFonts.size(); -} - -MinikinFont* FontFamily::getFont(size_t index) const { - return mFonts[index].typeface; -} - -FontStyle FontFamily::getStyle(size_t index) const { - return mFonts[index].style; -} - bool FontFamily::isColorEmojiFamily() const { const FontLanguages& languageList = FontLanguageListCache::getById(mLangId); for (size_t i = 0; i < languageList.size(); ++i) { @@ -168,30 +167,24 @@ bool FontFamily::isColorEmojiFamily() const { return false; } -const SparseBitSet* FontFamily::getCoverage() { - if (!mCoverageValid) { - const FontStyle defaultStyle; - MinikinFont* typeface = getClosestMatch(defaultStyle).font; - const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); - HbBlob cmapTable(getFontTable(typeface, cmapTag)); - if (cmapTable.get() == nullptr) { - ALOGE("Could not get cmap table size!\n"); - // Note: This means we will retry on the next call to getCoverage, as we can't store - // the failure. This is fine, as we assume this doesn't really happen in practice. - return nullptr; - } - // TODO: Error check? - CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); -#ifdef VERBOSE_DEBUG - ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), - mCoverage.nextSetBit(0)); -#endif - mCoverageValid = true; +void FontFamily::computeCoverage() { + android::AutoMutex _l(gMinikinLock); + const FontStyle defaultStyle; + MinikinFont* typeface = getClosestMatch(defaultStyle).font; + const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); + HbBlob cmapTable(getFontTable(typeface, cmapTag)); + if (cmapTable.get() == nullptr) { + ALOGE("Could not get cmap table size!\n"); + return; } - return &mCoverage; + // TODO: Error check? + CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); +#ifdef VERBOSE_DEBUG + ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), mCoverage.nextSetBit(0)); +#endif } -bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) { +bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const { assertMinikinLocked(); if (variationSelector != 0 && !mHasVSTable) { // Early exit if the variation selector is specified but the font doesn't have a cmap format @@ -208,9 +201,4 @@ bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) { return result; } -bool FontFamily::hasVSTable() const { - LOG_ALWAYS_FATAL_IF(!mCoverageValid, "Do not call this method before getCoverage() call"); - return mHasVSTable; -} - } // namespace minikin diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index a27918ea75..1c9c322d23 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -45,9 +45,9 @@ FontCollection *makeFontCollection() { "/system/fonts/Roboto-LightItalic.ttf" }; - FontFamily *family = new FontFamily(); FT_Face face; FT_Error error; + std::vector fonts; for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { const char *fn = fns[i]; printf("adding %s\n", fn); @@ -56,16 +56,16 @@ FontCollection *makeFontCollection() { printf("error loading %s, %d\n", fn, error); } MinikinFont *font = new MinikinFontFreeType(face); - family->addFont(font); + fonts.push_back(Font(font, FontStyle())); } + FontFamily *family = new FontFamily(std::move(fonts)); typefaces.push_back(family); #if 1 - family = new FontFamily(); const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; error = FT_New_Face(library, fn, 0, &face); MinikinFont *font = new MinikinFontFreeType(face); - family->addFont(font); + family = new FontFamily(std::vector({ Font(font, FontStyle()) })); typefaces.push_back(family); #endif diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index b04c8abcbc..6e6f868051 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -54,21 +54,21 @@ FontCollection *makeFontCollection() { "/system/fonts/Roboto-LightItalic.ttf" }; - FontFamily *family = new FontFamily(); + std::vector fonts; for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { const char *fn = fns[i]; sk_sp skFace = SkTypeface::MakeFromFile(fn); MinikinFont *font = new MinikinFontSkia(std::move(skFace)); - family->addFont(font); + fonts.push_back(Font(font, FontStyle())); } + FontFamily *family = new FontFamily(std::move(fonts)); typefaces.push_back(family); #if 1 - family = new FontFamily(); const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; sk_sp skFace = SkTypeface::MakeFromFile(fn); MinikinFont *font = new MinikinFontSkia(std::move(skFace)); - family->addFont(font); + family = new FontFamily(std::vector({ Font(font, FontStyle()) })); typefaces.push_back(family); #endif diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 52786d0c7e..5c5a5d343c 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -668,14 +668,14 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { const std::string kVSTestFont = kTestFontDir "VarioationSelectorTest-Regular.ttf"; std::vector families; - FontFamily* family1 = new FontFamily(VARIANT_DEFAULT); MinikinAutoUnref font(new MinikinFontForTest(kLatinFont)); - family1->addFont(font.get()); + FontFamily* family1 = new FontFamily(VARIANT_DEFAULT, + std::vector{ Font(font.get(), FontStyle()) }); families.push_back(family1); - FontFamily* family2 = new FontFamily(VARIANT_DEFAULT); MinikinAutoUnref font2(new MinikinFontForTest(kVSTestFont)); - family2->addFont(font2.get()); + FontFamily* family2 = new FontFamily(VARIANT_DEFAULT, + std::vector{ Font(font2.get(), FontStyle()) }); families.push_back(family2); FontCollection collection(families); @@ -811,11 +811,11 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { std::vector families; // Prepare first font which doesn't supports U+9AA8 - FontFamily* firstFamily = new FontFamily( - FontStyle::registerLanguageList("und"), 0 /* variant */); MinikinAutoUnref firstFamilyMinikinFont( new MinikinFontForTest(kNoGlyphFont)); - firstFamily->addFont(firstFamilyMinikinFont.get()); + FontFamily* firstFamily = new FontFamily( + FontStyle::registerLanguageList("und"), 0 /* variant */, + std::vector({ Font(firstFamilyMinikinFont.get(), FontStyle()) })); families.push_back(firstFamily); // Prepare font families @@ -824,10 +824,10 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { std::unordered_map fontLangIdxMap; for (size_t i = 0; i < testCase.fontLanguages.size(); ++i) { - FontFamily* family = new FontFamily( - FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */); MinikinAutoUnref minikin_font(new MinikinFontForTest(kJAFont)); - family->addFont(minikin_font.get()); + FontFamily* family = new FontFamily( + FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */, + std::vector({ Font(minikin_font.get(), FontStyle()) })); families.push_back(family); fontLangIdxMap.insert(std::make_pair(minikin_font.get(), i)); } @@ -1417,13 +1417,12 @@ TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS) { MinikinAutoUnref fontA(new MinikinFontForTest(kZH_HansFont)); MinikinAutoUnref fontB(new MinikinFontForTest(kZH_HansFont)); - MinikinAutoUnref dummyFamily(new FontFamily()); - MinikinAutoUnref familyA(new FontFamily()); - MinikinAutoUnref familyB(new FontFamily()); - - dummyFamily->addFont(dummyFont.get()); - familyA->addFont(fontA.get()); - familyB->addFont(fontB.get()); + MinikinAutoUnref dummyFamily(new FontFamily( + std::vector({ Font(dummyFont.get(), FontStyle()) }))); + MinikinAutoUnref familyA(new FontFamily( + std::vector({ Font(fontA.get(), FontStyle()) }))); + MinikinAutoUnref familyB(new FontFamily( + std::vector({ Font(fontB.get(), FontStyle()) }))); std::vector families = { dummyFamily.get(), familyA.get(), familyB.get() }; @@ -1453,13 +1452,12 @@ TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS2) { MinikinAutoUnref noCmapFormat14Font( new MinikinFontForTest(kNoCmapFormat14Font)); - MinikinAutoUnref dummyFamily(new FontFamily()); - MinikinAutoUnref hasCmapFormat14Family(new FontFamily()); - MinikinAutoUnref noCmapFormat14Family(new FontFamily()); - - dummyFamily->addFont(dummyFont.get()); - hasCmapFormat14Family->addFont(hasCmapFormat14Font.get()); - noCmapFormat14Family->addFont(noCmapFormat14Font.get()); + MinikinAutoUnref dummyFamily(new FontFamily( + std::vector({ Font(dummyFont.get(), FontStyle()) }))); + MinikinAutoUnref hasCmapFormat14Family(new FontFamily( + std::vector({ Font(hasCmapFormat14Font.get(), FontStyle()) }))); + MinikinAutoUnref noCmapFormat14Family(new FontFamily( + std::vector({ Font(noCmapFormat14Font.get(), FontStyle()) }))); std::vector families = { dummyFamily.get(), hasCmapFormat14Family.get(), noCmapFormat14Family.get() }; diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index 62d2f022fa..c0b6b526b7 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -57,9 +57,9 @@ void expectVSGlyphs(const FontCollection* fc, uint32_t codepoint, const std::set } TEST(FontCollectionTest, hasVariationSelectorTest) { - MinikinAutoUnref family(new FontFamily()); MinikinAutoUnref font(new MinikinFontForTest(kVsTestFont)); - family->addFont(font.get()); + MinikinAutoUnref family(new FontFamily( + std::vector({ Font(font.get(), FontStyle()) }))); std::vector families({family.get()}); MinikinAutoUnref fc(new FontCollection(families)); diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 4409801892..ddc36e4570 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -464,8 +464,10 @@ void expectVSGlyphs(FontFamily* family, uint32_t codepoint, const std::set minikinFont(new MinikinFontForTest(kVsTestFont)); - MinikinAutoUnref family(new FontFamily); - family->addFont(minikinFont.get()); + MinikinAutoUnref family( + new FontFamily(std::vector{ + Font(minikinFont.get(), FontStyle()) + })); android::AutoMutex _l(gMinikinLock); @@ -478,23 +480,23 @@ TEST_F(FontFamilyTest, hasVariationSelectorTest) { const uint32_t kVS20 = 0xE0103; const uint32_t kSupportedChar1 = 0x82A6; - EXPECT_TRUE(family->getCoverage()->get(kSupportedChar1)); + EXPECT_TRUE(family->getCoverage().get(kSupportedChar1)); expectVSGlyphs(family.get(), kSupportedChar1, std::set({kVS1, kVS17, kVS18, kVS19})); const uint32_t kSupportedChar2 = 0x845B; - EXPECT_TRUE(family->getCoverage()->get(kSupportedChar2)); + EXPECT_TRUE(family->getCoverage().get(kSupportedChar2)); expectVSGlyphs(family.get(), kSupportedChar2, std::set({kVS2, kVS18, kVS19, kVS20})); const uint32_t kNoVsSupportedChar = 0x537F; - EXPECT_TRUE(family->getCoverage()->get(kNoVsSupportedChar)); + EXPECT_TRUE(family->getCoverage().get(kNoVsSupportedChar)); expectVSGlyphs(family.get(), kNoVsSupportedChar, std::set()); const uint32_t kVsOnlySupportedChar = 0x717D; - EXPECT_FALSE(family->getCoverage()->get(kVsOnlySupportedChar)); + EXPECT_FALSE(family->getCoverage().get(kVsOnlySupportedChar)); expectVSGlyphs(family.get(), kVsOnlySupportedChar, std::set({kVS3, kVS19, kVS20})); const uint32_t kNotSupportedChar = 0x845C; - EXPECT_FALSE(family->getCoverage()->get(kNotSupportedChar)); + EXPECT_FALSE(family->getCoverage().get(kNotSupportedChar)); expectVSGlyphs(family.get(), kNotSupportedChar, std::set()); } @@ -518,11 +520,9 @@ TEST_F(FontFamilyTest, hasVSTableTest) { MinikinAutoUnref minikinFont( new MinikinFontForTest(testCase.fontPath)); - MinikinAutoUnref family(new FontFamily); - family->addFont(minikinFont.get()); + MinikinAutoUnref family(new FontFamily( + std::vector{ Font(minikinFont.get(), FontStyle()) })); android::AutoMutex _l(gMinikinLock); - family->getCoverage(); - EXPECT_EQ(testCase.hasVSTable, family->hasVSTable()); } } diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index 0c7b2ba032..e29a2fe534 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -48,16 +48,7 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { } } - xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); - FontFamily* family; - if (lang == nullptr) { - family = new FontFamily(variant); - } else { - uint32_t langId = FontStyle::registerLanguageList( - std::string((const char*)lang, xmlStrlen(lang))); - family = new FontFamily(langId, variant); - } - + std::vector fonts; for (xmlNode* fontNode = familyNode->children; fontNode; fontNode = fontNode->next) { if (xmlStrcmp(fontNode->name, (const xmlChar*)"font") != 0) { continue; @@ -80,13 +71,23 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { if (index == nullptr) { MinikinAutoUnref minikinFont(new MinikinFontForTest(fontPath)); - family->addFont(minikinFont.get(), FontStyle(weight, italic)); + fonts.push_back(Font(minikinFont.get(), FontStyle(weight, italic))); } else { MinikinAutoUnref minikinFont(new MinikinFontForTest(fontPath, atoi((const char*)index))); - family->addFont(minikinFont.get(), FontStyle(weight, italic)); + fonts.push_back(Font(minikinFont.get(), FontStyle(weight, italic))); } } + + xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); + FontFamily* family; + if (lang == nullptr) { + family = new FontFamily(variant, std::move(fonts)); + } else { + uint32_t langId = FontStyle::registerLanguageList( + std::string((const char*)lang, xmlStrlen(lang))); + family = new FontFamily(langId, variant, std::move(fonts)); + } families.push_back(family); } xmlFreeDoc(doc); From 77a29ed5ecd924af9afb9cbf1531db2f39a46116 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 22 Nov 2016 18:10:57 +0900 Subject: [PATCH 227/364] Introduce createCollectionWithVariation. This is 2nd attempt of I08e9b74192f8af1d045f1276498fa4e60d73863e. The original CL was reverted due to conflicting with another CL submitted before. Here is the original commit message of reverted change. This lays the groundwork for variation settings support. Since we should regard different variations of a font as different fonts, we need to create new typefaces. To reuse the same instance of MinikinFont, as much as possible, FontFamily::createFamilyWithVariation now reuses an existence instance, while incrementing the reference count. Test: minikin_tests Bug: 33062398 Change-Id: Ib25bf1bb5a5191e15a6523954146521464c91906 --- .../flutter/include/minikin/FontCollection.h | 8 ++ .../src/flutter/include/minikin/FontFamily.h | 17 +++- .../src/flutter/include/minikin/MinikinFont.h | 4 + .../src/flutter/libs/minikin/AnalyzeStyle.cpp | 43 ----------- engine/src/flutter/libs/minikin/Android.mk | 2 +- .../flutter/libs/minikin/FontCollection.cpp | 39 ++++++++++ .../src/flutter/libs/minikin/FontFamily.cpp | 67 ++++++++++++++-- engine/src/flutter/libs/minikin/FontUtils.cpp | 77 +++++++++++++++++++ .../minikin/FontUtils.h} | 9 ++- engine/src/flutter/tests/unittest/Android.mk | 1 + .../tests/unittest/FontCollectionTest.cpp | 72 +++++++++++++++++ .../flutter/tests/unittest/FontFamilyTest.cpp | 63 +++++++++++++++ .../flutter/tests/util/MinikinFontForTest.cpp | 9 ++- .../flutter/tests/util/MinikinFontForTest.h | 9 ++- 14 files changed, 365 insertions(+), 55 deletions(-) delete mode 100644 engine/src/flutter/libs/minikin/AnalyzeStyle.cpp create mode 100644 engine/src/flutter/libs/minikin/FontUtils.cpp rename engine/src/flutter/{include/minikin/AnalyzeStyle.h => libs/minikin/FontUtils.h} (75%) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index c9c8520be6..42499a0469 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -18,6 +18,7 @@ #define MINIKIN_FONT_COLLECTION_H #include +#include #include #include @@ -51,6 +52,10 @@ public: // Get base font with fakery information (fake bold could affect metrics) FakedFont baseFontFaked(FontStyle style); + // Creates new FontCollection based on this collection while applying font variations. Returns + // nullptr if none of variations apply to this collection. + FontCollection* createCollectionWithVariation(const std::vector& variations); + uint32_t getId() const; private: @@ -96,6 +101,9 @@ private: // These are offsets into mInstanceVec, one range per page std::vector mRanges; + + // Set of supported axes in this collection. + std::unordered_set mSupportedAxes; }; } // namespace minikin diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 71a6384055..9ce8c6537c 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -19,6 +19,7 @@ #include #include +#include #include #include @@ -98,6 +99,8 @@ struct FakedFont { FontFakery fakery; }; +typedef uint32_t AxisTag; + struct Font { Font(MinikinFont* typeface, FontStyle style); Font(Font&& o); @@ -106,6 +109,7 @@ struct Font { MinikinFont* typeface; FontStyle style; + std::unordered_set supportedAxes; // TODO: remove this weird function. http://b/28119474 // MinikinFont requres mutex lock for destruction, but the mutex lock is not @@ -113,6 +117,12 @@ struct Font { static void clearElementsWithLock(std::vector* fonts); }; +struct FontVariation { + FontVariation(AxisTag axisTag, float value) : axisTag(axisTag), value(value) {} + AxisTag axisTag; + float value; +}; + class FontFamily : public MinikinRefCounted { public: explicit FontFamily(std::vector&& fonts); @@ -134,6 +144,7 @@ public: MinikinFont* getFont(size_t index) const { return mFonts[index].typeface; } FontStyle getStyle(size_t index) const { return mFonts[index].style; } bool isColorEmojiFamily() const; + const std::unordered_set& supportedAxes() const { return mSupportedAxes; } // Get Unicode coverage. const SparseBitSet& getCoverage() const { return mCoverage; } @@ -145,12 +156,16 @@ public: // Returns true if this font family has a variaion sequence table (cmap format 14 subtable). bool hasVSTable() const { return mHasVSTable; } + // Creates new FontFamily based on this family while applying font variations. Returns nullptr + // if none of variations apply to this family. + FontFamily* createFamilyWithVariation(const std::vector& variations) const; + private: void computeCoverage(); - uint32_t mLangId; int mVariant; std::vector mFonts; + std::unordered_set mSupportedAxes; SparseBitSet mCoverage; bool mHasVSTable; diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 353edd6566..57b939788a 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -126,6 +126,10 @@ public: return 0; } + virtual MinikinFont* createFontWithVariation(const std::vector&) const { + return nullptr; + } + 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; diff --git a/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp b/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp deleted file mode 100644 index 333f008f7f..0000000000 --- a/engine/src/flutter/libs/minikin/AnalyzeStyle.cpp +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (C) 2013 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include - -#include - -namespace minikin { - -// should we have a single FontAnalyzer class this stuff lives in, to avoid dup? -static int32_t readU16(const uint8_t* data, size_t offset) { - return data[offset] << 8 | data[offset + 1]; -} - -bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic) { - const size_t kUsWeightClassOffset = 4; - const size_t kFsSelectionOffset = 62; - const uint16_t kItalicFlag = (1 << 0); - if (os2_size < kFsSelectionOffset + 2) { - return false; - } - uint16_t weightClass = readU16(os2_data, kUsWeightClassOffset); - *weight = weightClass / 100; - uint16_t fsSelection = readU16(os2_data, kFsSelectionOffset); - *italic = (fsSelection & kItalicFlag) != 0; - return true; -} - -} // namespace minikin diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index d6c3df7f62..44abb88532 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -30,12 +30,12 @@ $(UNICODE_EMOJI_H): include $(CLEAR_VARS) minikin_src_files := \ - AnalyzeStyle.cpp \ CmapCoverage.cpp \ FontCollection.cpp \ FontFamily.cpp \ FontLanguage.cpp \ FontLanguageListCache.cpp \ + FontUtils.cpp \ GraphemeBreak.cpp \ HbFontCache.cpp \ Hyphenator.cpp \ diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 4688520699..fbcf1d72b1 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -103,6 +103,9 @@ FontCollection::FontCollection(const vector& typefaces) : } mMaxChar = max(mMaxChar, coverage.length()); lastChar.push_back(coverage.nextSetBit(0)); + + const std::unordered_set& supportedAxes = family->supportedAxes(); + mSupportedAxes.insert(supportedAxes.begin(), supportedAxes.end()); } nTypefaces = mFamilies.size(); LOG_ALWAYS_FATAL_IF(nTypefaces == 0, @@ -461,6 +464,42 @@ FakedFont FontCollection::baseFontFaked(FontStyle style) { return mFamilies[0]->getClosestMatch(style); } +FontCollection* FontCollection::createCollectionWithVariation( + const std::vector& variations) { + if (variations.empty() || mSupportedAxes.empty()) { + return nullptr; + } + + bool hasSupportedAxis = false; + for (const FontVariation& variation : variations) { + if (mSupportedAxes.find(variation.axisTag) != mSupportedAxes.end()) { + hasSupportedAxis = true; + break; + } + } + if (!hasSupportedAxis) { + // None of variation axes are supported by this font collection. + return nullptr; + } + + std::vector families; + for (FontFamily* family : mFamilies) { + FontFamily* newFamily = family->createFamilyWithVariation(variations); + if (newFamily) { + families.push_back(newFamily); + } else { + family->Ref(); + families.push_back(family); + } + } + + FontCollection* result = new FontCollection(families); + for (FontFamily* family : families) { + family->Unref(); + } + return result; +} + uint32_t FontCollection::getId() const { return mId; } diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 619110db8e..6d44bc395c 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -28,10 +28,11 @@ #include "FontLanguage.h" #include "FontLanguageListCache.h" +#include "FontUtils.h" #include "HbFontCache.h" #include "MinikinInternal.h" -#include #include +#include #include #include @@ -66,19 +67,30 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { Font::Font(MinikinFont* typeface, FontStyle style) : typeface(typeface), style(style) { - typeface->Ref(); + android::AutoMutex _l(gMinikinLock); + typeface->RefLocked(); + + const uint32_t fvarTag = MinikinFont::MakeTag('f', 'v', 'a', 'r'); + HbBlob fvarTable(getFontTable(typeface, fvarTag)); + if (fvarTable.size() == 0) { + return; + } + + analyzeAxes(fvarTable.get(), fvarTable.size(), &supportedAxes); } Font::Font(Font&& o) { typeface = o.typeface; style = o.style; o.typeface = nullptr; + supportedAxes = std::move(o.supportedAxes); } Font::Font(const Font& o) { typeface = o.typeface; typeface->Ref(); style = o.style; + supportedAxes = o.supportedAxes; } Font::~Font() { @@ -179,9 +191,10 @@ void FontFamily::computeCoverage() { } // TODO: Error check? CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); -#ifdef VERBOSE_DEBUG - ALOGD("font coverage length=%d, first ch=%x\n", mCoverage.length(), mCoverage.nextSetBit(0)); -#endif + + for (size_t i = 0; i < mFonts.size(); ++i) { + mSupportedAxes.insert(mFonts[i].supportedAxes.begin(), mFonts[i].supportedAxes.end()); + } } bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const { @@ -201,4 +214,48 @@ bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const return result; } +FontFamily* FontFamily::createFamilyWithVariation( + const std::vector& variations) const { + if (variations.empty() || mSupportedAxes.empty()) { + return nullptr; + } + + bool hasSupportedAxis = false; + for (const FontVariation& variation : variations) { + if (mSupportedAxes.find(variation.axisTag) != mSupportedAxes.end()) { + hasSupportedAxis = true; + break; + } + } + if (!hasSupportedAxis) { + // None of variation axes are suppored by this family. + return nullptr; + } + + std::vector fonts; + for (const Font& font : mFonts) { + bool supportedVariations = false; + if (!font.supportedAxes.empty()) { + for (const FontVariation& variation : variations) { + if (font.supportedAxes.find(variation.axisTag) != font.supportedAxes.end()) { + supportedVariations = true; + break; + } + } + } + MinikinFont* minikinFont = nullptr; + if (supportedVariations) { + minikinFont = font.typeface->createFontWithVariation(variations); + } + if (minikinFont == nullptr) { + minikinFont = font.typeface; + minikinFont->Ref(); + } + fonts.push_back(Font(minikinFont, font.style)); + minikinFont->Unref(); + } + + return new FontFamily(mLangId, mVariant, std::move(fonts)); +} + } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontUtils.cpp b/engine/src/flutter/libs/minikin/FontUtils.cpp new file mode 100644 index 0000000000..c5a32f82e8 --- /dev/null +++ b/engine/src/flutter/libs/minikin/FontUtils.cpp @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2017 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 +#include + +#include "FontUtils.h" + +namespace minikin { + +static uint16_t readU16(const uint8_t* data, size_t offset) { + return data[offset] << 8 | data[offset + 1]; +} + +static uint32_t readU32(const uint8_t* data, size_t offset) { + return ((uint32_t)data[offset]) << 24 | ((uint32_t)data[offset + 1]) << 16 | + ((uint32_t)data[offset + 2]) << 8 | ((uint32_t)data[offset + 3]); +} + +bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic) { + const size_t kUsWeightClassOffset = 4; + const size_t kFsSelectionOffset = 62; + const uint16_t kItalicFlag = (1 << 0); + if (os2_size < kFsSelectionOffset + 2) { + return false; + } + uint16_t weightClass = readU16(os2_data, kUsWeightClassOffset); + *weight = weightClass / 100; + uint16_t fsSelection = readU16(os2_data, kFsSelectionOffset); + *italic = (fsSelection & kItalicFlag) != 0; + return true; +} + +void analyzeAxes(const uint8_t* fvar_data, size_t fvar_size, std::unordered_set* axes) { + const size_t kMajorVersionOffset = 0; + const size_t kMinorVersionOffset = 2; + const size_t kOffsetToAxesArrayOffset = 4; + const size_t kAxisCountOffset = 8; + const size_t kAxisSizeOffset = 10; + + axes->clear(); + + if (fvar_size < kAxisSizeOffset + 2) { + return; + } + const uint16_t majorVersion = readU16(fvar_data, kMajorVersionOffset); + const uint16_t minorVersion = readU16(fvar_data, kMinorVersionOffset); + const uint32_t axisOffset = readU16(fvar_data, kOffsetToAxesArrayOffset); + const uint32_t axisCount = readU16(fvar_data, kAxisCountOffset); + const uint32_t axisSize = readU16(fvar_data, kAxisSizeOffset); + + if (majorVersion != 1 || minorVersion != 0 || axisOffset != 0x10 || axisSize != 0x14) { + return; // Unsupported version. + } + if (fvar_size < axisOffset + axisOffset * axisCount) { + return; // Invalid table size. + } + for (uint32_t i = 0; i < axisCount; ++i) { + size_t axisRecordOffset = axisOffset + i * axisSize; + uint32_t tag = readU32(fvar_data, axisRecordOffset); + axes->insert(tag); + } +} +} // namespace minikin diff --git a/engine/src/flutter/include/minikin/AnalyzeStyle.h b/engine/src/flutter/libs/minikin/FontUtils.h similarity index 75% rename from engine/src/flutter/include/minikin/AnalyzeStyle.h rename to engine/src/flutter/libs/minikin/FontUtils.h index b4cd915108..d26d5e42a0 100644 --- a/engine/src/flutter/include/minikin/AnalyzeStyle.h +++ b/engine/src/flutter/libs/minikin/FontUtils.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2013 The Android Open Source Project + * Copyright (C) 2017 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. @@ -14,12 +14,15 @@ * limitations under the License. */ -#ifndef MINIKIN_ANALYZE_STYLE_H -#define MINIKIN_ANALYZE_STYLE_H +#ifndef MINIKIN_FONT_UTILS_H +#define MINIKIN_FONT_UTILS_H + +#include namespace minikin { bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic); +void analyzeAxes(const uint8_t* fvar_data, size_t fvar_size, std::unordered_set* axes); } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index cced545737..7b3f60f8f9 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -27,6 +27,7 @@ LOCAL_TEST_DATA := \ data/Italic.ttf \ data/Ja.ttf \ data/Ko.ttf \ + data/MultiAxis.ttf \ data/NoCmapFormat14.ttf \ data/NoGlyphFont.ttf \ data/Regular.ttf \ diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index c0b6b526b7..68fe582aa3 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -121,4 +121,76 @@ TEST(FontCollectionTest, newEmojiTest) { EXPECT_FALSE(collection->hasVariationSelector(0x2642, 0xFE0F)); } +TEST(FontCollectionTest, createWithVariations) { + // This font has 'wdth' and 'wght' axes. + const char kMultiAxisFont[] = kTestFontDir "/MultiAxis.ttf"; + const char kNoAxisFont[] = kTestFontDir "/Regular.ttf"; + + MinikinAutoUnref multiAxisFont(new MinikinFontForTest(kMultiAxisFont)); + MinikinAutoUnref multiAxisFamily(new FontFamily( + std::vector({ Font(multiAxisFont.get(), FontStyle()) }))); + std::vector multiAxisFamilies({multiAxisFamily.get()}); + MinikinAutoUnref multiAxisFc(new FontCollection(multiAxisFamilies)); + + MinikinAutoUnref noAxisFont(new MinikinFontForTest(kNoAxisFont)); + MinikinAutoUnref noAxisFamily(new FontFamily( + std::vector({ Font(noAxisFont.get(), FontStyle()) }))); + std::vector noAxisFamilies({noAxisFamily.get()}); + MinikinAutoUnref noAxisFc(new FontCollection(noAxisFamilies)); + + { + // Do not ceate new instance if none of variations are specified. + EXPECT_EQ(nullptr, + multiAxisFc->createCollectionWithVariation(std::vector())); + EXPECT_EQ(nullptr, + noAxisFc->createCollectionWithVariation(std::vector())); + } + { + // New instance should be used for supported variation. + std::vector variations = { + { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f } + }; + MinikinAutoUnref newFc( + multiAxisFc->createCollectionWithVariation(variations)); + EXPECT_NE(nullptr, newFc.get()); + EXPECT_NE(multiAxisFc.get(), newFc.get()); + + EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); + } + { + // New instance should be used for supported variation (multiple variations case). + std::vector variations = { + { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, + { MinikinFont::MakeTag('w', 'g', 'h', 't'), 1.0f } + }; + MinikinAutoUnref newFc( + multiAxisFc->createCollectionWithVariation(variations)); + EXPECT_NE(nullptr, newFc.get()); + EXPECT_NE(multiAxisFc.get(), newFc.get()); + + EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); + } + { + // Do not ceate new instance if none of variations are supported. + std::vector variations = { + { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } + }; + EXPECT_EQ(nullptr, multiAxisFc->createCollectionWithVariation(variations)); + EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); + } + { + // At least one axis is supported, should create new instance. + std::vector variations = { + { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, + { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } + }; + MinikinAutoUnref newFc( + multiAxisFc->createCollectionWithVariation(variations)); + EXPECT_NE(nullptr, newFc.get()); + EXPECT_NE(multiAxisFc.get(), newFc.get()); + + EXPECT_EQ(nullptr, noAxisFc->createCollectionWithVariation(variations)); + } +} + } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index ddc36e4570..1655760bcf 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -527,4 +527,67 @@ TEST_F(FontFamilyTest, hasVSTableTest) { } } +TEST_F(FontFamilyTest, createFamilyWithVariationTest) { + // This font has 'wdth' and 'wght' axes. + const char kMultiAxisFont[] = kTestFontDir "/MultiAxis.ttf"; + const char kNoAxisFont[] = kTestFontDir "/Regular.ttf"; + + MinikinAutoUnref multiAxisFont(new MinikinFontForTest(kMultiAxisFont)); + MinikinAutoUnref multiAxisFamily(new FontFamily( + std::vector({Font(multiAxisFont.get(), FontStyle())}))); + + MinikinAutoUnref noAxisFont(new MinikinFontForTest(kNoAxisFont)); + MinikinAutoUnref noAxisFamily(new FontFamily( + std::vector({Font(noAxisFont.get(), FontStyle())}))); + + { + // Do not ceate new instance if none of variations are specified. + EXPECT_EQ(nullptr, + multiAxisFamily->createFamilyWithVariation(std::vector())); + EXPECT_EQ(nullptr, + noAxisFamily->createFamilyWithVariation(std::vector())); + } + { + // New instance should be used for supported variation. + std::vector variations = {{MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f}}; + MinikinAutoUnref newFamily( + multiAxisFamily->createFamilyWithVariation(variations)); + EXPECT_NE(nullptr, newFamily.get()); + EXPECT_NE(multiAxisFamily.get(), newFamily.get()); + EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); + } + { + // New instance should be used for supported variation. (multiple variations case) + std::vector variations = { + { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, + { MinikinFont::MakeTag('w', 'g', 'h', 't'), 1.0f } + }; + MinikinAutoUnref newFamily( + multiAxisFamily->createFamilyWithVariation(variations)); + EXPECT_NE(nullptr, newFamily.get()); + EXPECT_NE(multiAxisFamily.get(), newFamily.get()); + EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); + } + { + // Do not ceate new instance if none of variations are supported. + std::vector variations = { + { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } + }; + EXPECT_EQ(nullptr, multiAxisFamily->createFamilyWithVariation(variations)); + EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); + } + { + // At least one axis is supported, should create new instance. + std::vector variations = { + { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, + { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } + }; + MinikinAutoUnref newFamily( + multiAxisFamily->createFamilyWithVariation(variations)); + EXPECT_NE(nullptr, newFamily.get()); + EXPECT_NE(multiAxisFamily.get(), newFamily.get()); + EXPECT_EQ(nullptr, noAxisFamily->createFamilyWithVariation(variations)); + } +} + } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index a4132e5178..f191f07d6e 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -34,9 +34,11 @@ namespace minikin { static int uniqueId = 0; // TODO: make thread safe if necessary. -MinikinFontForTest::MinikinFontForTest(const std::string& font_path, int index) : +MinikinFontForTest::MinikinFontForTest(const std::string& font_path, int index, + const std::vector& variations) : MinikinFont(uniqueId++), mFontPath(font_path), + mVariations(variations), mFontIndex(index) { int fd = open(font_path.c_str(), O_RDONLY); LOG_ALWAYS_FATAL_IF(fd == -1); @@ -67,4 +69,9 @@ void MinikinFontForTest::GetBounds(MinikinRect* bounds, uint32_t /* glyph_id */, bounds->mBottom = 10.0f; } +MinikinFont* MinikinFontForTest::createFontWithVariation( + const std::vector& variations) const { + return new MinikinFontForTest(mFontPath, mFontIndex, variations); +} + } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index ee0eadbe0c..2a107036ed 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -25,7 +25,10 @@ namespace minikin { class MinikinFontForTest : public MinikinFont { public: - MinikinFontForTest(const std::string& font_path, int index); + MinikinFontForTest(const std::string& font_path, int index, + const std::vector& variations); + MinikinFontForTest(const std::string& font_path, int index) + : MinikinFontForTest(font_path, index, std::vector()) {} MinikinFontForTest(const std::string& font_path) : MinikinFontForTest(font_path, 0) {} virtual ~MinikinFontForTest(); @@ -35,15 +38,19 @@ public: const MinikinPaint& paint) const; const std::string& fontPath() const { return mFontPath; } + const std::vector& variations() const { return mVariations; } + const void* GetFontData() const { return mFontData; } size_t GetFontSize() const { return mFontSize; } int GetFontIndex() const { return mFontIndex; } + MinikinFont* createFontWithVariation(const std::vector& variations) const; private: MinikinFontForTest() = delete; MinikinFontForTest(const MinikinFontForTest&) = delete; MinikinFontForTest& operator=(MinikinFontForTest&) = delete; const std::string mFontPath; + const std::vector mVariations; const int mFontIndex; void* mFontData; size_t mFontSize; From 3c71c47a6a9cb0c50cae13d08ae122c1e21c0d88 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 7 Feb 2017 15:52:25 +0900 Subject: [PATCH 228/364] Update the instruction to run tests. "adb sync data" pushes test data as well as test executables. Test: ran minikin_perftests Test: ran minikin_tests Change-Id: I08219f8abc4b59bd26d8f9155975b65b56a88b7b --- engine/src/flutter/tests/perftests/how_to_run.txt | 3 +-- engine/src/flutter/tests/unittest/how_to_run.txt | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/tests/perftests/how_to_run.txt b/engine/src/flutter/tests/perftests/how_to_run.txt index 3390522c2f..f55a8ac4ef 100644 --- a/engine/src/flutter/tests/perftests/how_to_run.txt +++ b/engine/src/flutter/tests/perftests/how_to_run.txt @@ -1,4 +1,3 @@ mmm -j8 frameworks/minikin/tests/perftests && -adb push $OUT/data/benchmarktest/minikin_perftests/minikin_perftests \ - /data/benchmarktest/minikin_perftests/minikin_perftests && +adb sync data && adb shell /data/benchmarktest/minikin_perftests/minikin_perftests diff --git a/engine/src/flutter/tests/unittest/how_to_run.txt b/engine/src/flutter/tests/unittest/how_to_run.txt index e94c904bec..20aa5ab31e 100644 --- a/engine/src/flutter/tests/unittest/how_to_run.txt +++ b/engine/src/flutter/tests/unittest/how_to_run.txt @@ -1,3 +1,3 @@ mmm -j8 frameworks/minikin/tests/unittest && -adb push $OUT/data/nativetest/minikin_tests /data/nativetest/ && +adb sync data && adb shell /data/nativetest/minikin_tests/minikin_tests From 655d2a760d8c8dad590739f237a26a654cabf745 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 2 Feb 2017 17:31:31 +0900 Subject: [PATCH 229/364] Introduce unittests for flag sequence. The Flag sequence is well handled by latest ICU. Just add unit tests for catching regression in future. Test: ran minikin_tests Change-Id: I78d5461de8ff4d002ca06fb5bb81fcd7bc45d95e --- .../tests/unittest/GraphemeBreakTests.cpp | 28 +++++++++++ .../tests/unittest/WordBreakerTests.cpp | 50 ++++++++++++++++++- 2 files changed, 77 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp index d95fa31b1d..29b1669bd4 100644 --- a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp @@ -115,6 +115,34 @@ TEST(GraphemeBreak, rules) { EXPECT_TRUE(IsBreak("U+4E00 | U+4E00")); // CJK ideographs EXPECT_TRUE(IsBreak("'a' | U+1F1FA U+1F1F8")); // Regional indicator pair (flag) EXPECT_TRUE(IsBreak("U+1F1FA U+1F1F8 | 'a'")); // Regional indicator pair (flag) + + // Extended rule for emoji tag sequence. + EXPECT_TRUE(IsBreak("'a' | U+1F3F4 'a'")); + EXPECT_TRUE(IsBreak("'a' U+1F3F4 | 'a'")); + + // Immediate tag_term after tag_base. + EXPECT_TRUE(IsBreak("'a' | U+1F3F4 U+E007F 'a'")); + EXPECT_FALSE(IsBreak("U+1F3F4 | U+E007F")); + EXPECT_TRUE(IsBreak("'a' U+1F3F4 U+E007F | 'a'")); + + // Flag sequence + // U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 U+E007F is emoji tag sequence for the flag + // of Scotland. + // U+1F3F4 is WAVING BLACK FLAG. This can be a tag_base character. + // U+E0067 is TAG LATIN SMALL LETTER G. This can be a part of tag_spec. + // U+E0062 is TAG LATIN SMALL LETTER B. This can be a part of tag_spec. + // U+E0073 is TAG LATIN SMALL LETTER S. This can be a part of tag_spec. + // U+E0063 is TAG LATIN SMALL LETTER C. This can be a part of tag_spec. + // U+E0074 is TAG LATIN SMALL LETTER T. This can be a part of tag_spec. + // U+E007F is CANCEL TAG. This is a tag_term character. + EXPECT_TRUE(IsBreak("'a' | U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 U+E007F")); + EXPECT_FALSE(IsBreak("U+1F3F4 | U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 U+E007F")); + EXPECT_FALSE(IsBreak("U+1F3F4 U+E0067 | U+E0062 U+E0073 U+E0063 U+E0074 U+E007F")); + EXPECT_FALSE(IsBreak("U+1F3F4 U+E0067 U+E0062 | U+E0073 U+E0063 U+E0074 U+E007F")); + EXPECT_FALSE(IsBreak("U+1F3F4 U+E0067 U+E0062 U+E0073 | U+E0063 U+E0074 U+E007F")); + EXPECT_FALSE(IsBreak("U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 | U+E0074 U+E007F")); + EXPECT_FALSE(IsBreak("U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 | U+E007F")); + EXPECT_TRUE(IsBreak("U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 U+E007F | 'a'")); } TEST(GraphemeBreak, tailoring) { diff --git a/engine/src/flutter/tests/unittest/WordBreakerTests.cpp b/engine/src/flutter/tests/unittest/WordBreakerTests.cpp index c3228aa74b..dc46c19d24 100644 --- a/engine/src/flutter/tests/unittest/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/unittest/WordBreakerTests.cpp @@ -137,7 +137,7 @@ TEST_F(WordBreakerTest, emojiWithModifier) { breaker.setLocale(icu::Locale::getEnglish()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); - EXPECT_EQ(4, breaker.next()); // after man + type 6 fitzpatrick modifier + EXPECT_EQ(4, breaker.next()); // after boy + type 1-2 fitzpatrick modifier EXPECT_EQ(0, breaker.wordStart()); EXPECT_EQ(4, breaker.wordEnd()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end @@ -145,6 +145,54 @@ TEST_F(WordBreakerTest, emojiWithModifier) { EXPECT_EQ(8, breaker.wordEnd()); } +TEST_F(WordBreakerTest, flagsSequenceSingleFlag) { + const std::string kFlag = "U+1F3F4"; + const std::string flags = kFlag + " " + kFlag; + + const int kFlagLength = 2; + const size_t BUF_SIZE = kFlagLength * 2; + + uint16_t buf[BUF_SIZE]; + size_t size; + ParseUnicode(buf, BUF_SIZE, flags.c_str(), &size, nullptr); + + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, size); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(kFlagLength, breaker.next()); // end of the first flag + EXPECT_EQ(0, breaker.wordStart()); + EXPECT_EQ(kFlagLength, breaker.wordEnd()); + EXPECT_EQ(static_cast(size), breaker.next()); + EXPECT_EQ(kFlagLength, breaker.wordStart()); + EXPECT_EQ(kFlagLength * 2, breaker.wordEnd()); +} + +TEST_F(WordBreakerTest, flagsSequence) { + // U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 U+E007F is emoji tag sequence for the flag + // of Scotland. + const std::string kFlagSequence = "U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 U+E007F"; + const std::string flagSequence = kFlagSequence + " " + kFlagSequence; + + const int kFlagLength = 14; + const size_t BUF_SIZE = kFlagLength * 2; + + uint16_t buf[BUF_SIZE]; + size_t size; + ParseUnicode(buf, BUF_SIZE, flagSequence.c_str(), &size, nullptr); + + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, size); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(kFlagLength, breaker.next()); // end of the first flag sequence + EXPECT_EQ(0, breaker.wordStart()); + EXPECT_EQ(kFlagLength, breaker.wordEnd()); + EXPECT_EQ(static_cast(size), breaker.next()); + EXPECT_EQ(kFlagLength, breaker.wordStart()); + EXPECT_EQ(kFlagLength * 2, breaker.wordEnd()); +} + TEST_F(WordBreakerTest, punct) { uint16_t buf[] = {0x00A1, 0x00A1, 'h', 'e', 'l', 'l' ,'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', '!'}; From 30b9f327d3554e3f48f0cd2e46b63a0fcd948606 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Mon, 13 Feb 2017 15:33:47 -0800 Subject: [PATCH 230/364] Add U+202F NARROW NO-BREAK SPACE to the sticky white list Mongolian fonts need to shape across U+202F NARROW NO-BREAK SPACE (NNBSP). But if the first font in the fallback chain supports NNBSP, it would break Mongolian shaping since the text would be broken into three font runs. By making NNBSP sticky, we make sure Mongolian text is kept in one font run and is shaped properly. See http://www.unicode.org/L2/L2017/17036-mongolian-suffix.pdf for background. The proposed character in the proposal was not accepted for encoding by the Unicode Techincal Committee, but the document explains in more detail why this change in needed. Bug: 34344220 Test: manual Change-Id: I344a63f383fa5485875603570025eac3c4eb2574 --- engine/src/flutter/libs/minikin/FontCollection.cpp | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index fbcf1d72b1..9d0e2c8b38 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -325,19 +325,21 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, return bestFamily; } -const uint32_t NBSP = 0xa0; -const uint32_t ZWJ = 0x200c; -const uint32_t ZWNJ = 0x200d; +const uint32_t NBSP = 0xA0; +const uint32_t ZWJ = 0x200C; +const uint32_t ZWNJ = 0x200D; const uint32_t HYPHEN = 0x2010; const uint32_t NB_HYPHEN = 0x2011; +const uint32_t NNBSP = 0x202F; const uint32_t FEMALE_SIGN = 0x2640; const uint32_t MALE_SIGN = 0x2642; const uint32_t STAFF_OF_AESCULAPIUS = 0x2695; // Characters where we want to continue using existing font run instead of // recomputing the best match in the fallback list. -static const uint32_t stickyWhitelist[] = { '!', ',', '-', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, - HYPHEN, NB_HYPHEN, FEMALE_SIGN, MALE_SIGN, STAFF_OF_AESCULAPIUS }; +static const uint32_t stickyWhitelist[] = { + '!', ',', '-', '.', ':', ';', '?', NBSP, ZWJ, ZWNJ, + HYPHEN, NB_HYPHEN, NNBSP, FEMALE_SIGN, MALE_SIGN, STAFF_OF_AESCULAPIUS }; static bool isStickyWhitelisted(uint32_t c) { for (size_t i = 0; i < sizeof(stickyWhitelist) / sizeof(stickyWhitelist[0]); i++) { From 480ad4a314a075927a0177846b109effd629753e Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 7 Feb 2017 19:54:08 +0900 Subject: [PATCH 231/364] Pass region code to HarfBuzz. Keep the region code and pass it to HarfBuzz during doing layout. Test: minikin_tests Bug: 30746293 Change-Id: I7c908701ca677238f663c82c597f8615d190e055 --- .../src/flutter/libs/minikin/FontLanguage.cpp | 205 ++++++++++++++---- .../src/flutter/libs/minikin/FontLanguage.h | 30 ++- engine/src/flutter/libs/minikin/Layout.cpp | 3 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 91 +++++++- 4 files changed, 261 insertions(+), 68 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontLanguage.cpp b/engine/src/flutter/libs/minikin/FontLanguage.cpp index c6ddda5ae9..0897c06ea5 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguage.cpp @@ -41,60 +41,169 @@ static bool isEmojiSubtag(const char* buf, size_t bufLen, const char* subtag, si buf[subtagLen] == '-' || buf[subtagLen] == '_'); } +// Pack the three letter code into 15 bits and stored to 16 bit integer. The highest bit is 0. +// For the region code, the letters must be all digits in three letter case, so the number of +// possible values are 10. For the language code, the letters must be all small alphabets, so the +// number of possible values are 26. Thus, 5 bits are sufficient for each case and we can pack the +// three letter language code or region code to 15 bits. +// +// In case of two letter code, use fullbit(0x1f) for the first letter instead. +static uint16_t packLanguageOrRegion(const char* c, size_t length, uint8_t twoLetterBase, + uint8_t threeLetterBase) { + if (length == 2) { + return 0x7c00u | // 0x1fu << 10 + (uint16_t)(c[0] - twoLetterBase) << 5 | + (uint16_t)(c[1] - twoLetterBase); + } else { + return ((uint16_t)(c[0] - threeLetterBase) << 10) | + (uint16_t)(c[1] - threeLetterBase) << 5 | + (uint16_t)(c[2] - threeLetterBase); + } +} + +static size_t unpackLanguageOrRegion(uint16_t in, char* out, uint8_t twoLetterBase, + uint8_t threeLetterBase) { + uint8_t first = (in >> 10) & 0x1f; + uint8_t second = (in >> 5) & 0x1f; + uint8_t third = in & 0x1f; + + if (first == 0x1f) { + out[0] = second + twoLetterBase; + out[1] = third + twoLetterBase; + return 2; + } else { + out[0] = first + threeLetterBase; + out[1] = second + threeLetterBase; + out[2] = third + threeLetterBase; + return 3; + } +} + +// Find the next '-' or '_' index from startOffset position. If not found, returns bufferLength. +static size_t nextDelimiterIndex(const char* buffer, size_t bufferLength, size_t startOffset) { + for (size_t i = startOffset; i < bufferLength; ++i) { + if (buffer[i] == '-' || buffer[i] == '_') { + return i; + } + } + return bufferLength; +} + +static inline bool isLowercase(char c) { + return 'a' <= c && c <= 'z'; +} + +static inline bool isUppercase(char c) { + return 'A' <= c && c <= 'Z'; +} + +static inline bool isDigit(char c) { + return '0' <= c && c <= '9'; +} + +// Returns true if the buffer is valid for language code. +static inline bool isValidLanguageCode(const char* buffer, size_t length) { + if (length != 2 && length != 3) return false; + if (!isLowercase(buffer[0])) return false; + if (!isLowercase(buffer[1])) return false; + if (length == 3 && !isLowercase(buffer[2])) return false; + return true; +} + +// Returns true if buffer is valid for script code. The length of buffer must be 4. +static inline bool isValidScriptCode(const char* buffer) { + return isUppercase(buffer[0]) && isLowercase(buffer[1]) && isLowercase(buffer[2]) && + isLowercase(buffer[3]); +} + +// Returns true if the buffer is valid for region code. +static inline bool isValidRegionCode(const char* buffer, size_t length) { + return (length == 2 && isUppercase(buffer[0]) && isUppercase(buffer[1])) || + (length == 3 && isDigit(buffer[0]) && isDigit(buffer[1]) && isDigit(buffer[2])); +} + // Parse BCP 47 language identifier into internal structure FontLanguage::FontLanguage(const char* buf, size_t length) : FontLanguage() { - size_t i; - for (i = 0; i < length; i++) { - char c = buf[i]; - if (c == '-' || c == '_') break; - } - if (i == 2 || i == 3) { // only accept two or three letter language code. - mLanguage = buf[0] | (buf[1] << 8) | ((i == 3) ? (buf[2] << 16) : 0); + size_t firstDelimiterPos = nextDelimiterIndex(buf, length, 0); + if (isValidLanguageCode(buf, firstDelimiterPos)) { + mLanguage = packLanguageOrRegion(buf, firstDelimiterPos, 'a', 'a'); } else { // We don't understand anything other than two-letter or three-letter // language codes, so we skip parsing the rest of the string. - mLanguage = 0ul; return; } - size_t next; - for (i++; i < length; i = next + 1) { - for (next = i; next < length; next++) { - char c = buf[next]; - if (c == '-' || c == '_') break; - } - if (next - i == 4 && 'A' <= buf[i] && buf[i] <= 'Z') { - mScript = SCRIPT_TAG(buf[i], buf[i + 1], buf[i + 2], buf[i + 3]); - } + if (firstDelimiterPos == length) { + mHbLanguage = hb_language_from_string(getString().c_str(), -1); + return; // Language code only. } - mSubScriptBits = scriptToSubScriptBits(mScript); - if (mScript == SCRIPT_TAG('Z', 's', 'y', 'e')) { - mEmojiStyle = EMSTYLE_EMOJI; - } else if (mScript == SCRIPT_TAG('Z', 's', 'y', 'm')) { - mEmojiStyle = EMSTYLE_TEXT; + size_t nextComponentStartPos = firstDelimiterPos + 1; + size_t nextDelimiterPos = nextDelimiterIndex(buf, length, nextComponentStartPos); + size_t componentLength = nextDelimiterPos - nextComponentStartPos; + + if (componentLength == 4) { + // Possibly script code. + const char* p = buf + nextComponentStartPos; + if (isValidScriptCode(p)) { + mScript = SCRIPT_TAG(p[0], p[1], p[2], p[3]); + mSubScriptBits = scriptToSubScriptBits(mScript); + } + + if (nextDelimiterPos == length) { + mHbLanguage = hb_language_from_string(getString().c_str(), -1); + mEmojiStyle = resolveEmojiStyle(buf, length, mScript); + return; // No region code. + } + + nextComponentStartPos = nextDelimiterPos + 1; + nextDelimiterPos = nextDelimiterIndex(buf, length, nextComponentStartPos); + componentLength = nextDelimiterPos - nextComponentStartPos; } + + if (componentLength == 2 || componentLength == 3) { + // Possibly region code. + const char* p = buf + nextComponentStartPos; + if (isValidRegionCode(p, componentLength)) { + mRegion = packLanguageOrRegion(p, componentLength, 'A', '0'); + } + } + + mHbLanguage = hb_language_from_string(getString().c_str(), -1); + mEmojiStyle = resolveEmojiStyle(buf, length, mScript); +} + +// static +FontLanguage::EmojiStyle FontLanguage::resolveEmojiStyle(const char* buf, size_t length, + uint32_t script) { + // First, lookup emoji subtag. // 10 is the length of "-u-em-text", which is the shortest emoji subtag, // unnecessary comparison can be avoided if total length is smaller than 10. const size_t kMinSubtagLength = 10; - if (length < kMinSubtagLength) { - return; + if (length >= kMinSubtagLength) { + static const char kPrefix[] = "-u-em-"; + const char *pos = std::search(buf, buf + length, kPrefix, kPrefix + strlen(kPrefix)); + if (pos != buf + length) { // found + pos += strlen(kPrefix); + const size_t remainingLength = length - (pos - buf); + if (isEmojiSubtag(pos, remainingLength, "emoji", 5)){ + return EMSTYLE_EMOJI; + } else if (isEmojiSubtag(pos, remainingLength, "text", 4)){ + return EMSTYLE_TEXT; + } else if (isEmojiSubtag(pos, remainingLength, "default", 7)){ + return EMSTYLE_DEFAULT; + } + } } - static const char kPrefix[] = "-u-em-"; - const char *pos = std::search(buf, buf + length, kPrefix, kPrefix + strlen(kPrefix)); - if (pos == buf + length) { - return; - } - pos += strlen(kPrefix); - const size_t remainingLength = length - (pos - buf); - if (isEmojiSubtag(pos, remainingLength, "emoji", 5)){ - mEmojiStyle = EMSTYLE_EMOJI; - } else if (isEmojiSubtag(pos, remainingLength, "text", 4)){ - mEmojiStyle = EMSTYLE_TEXT; - } else if (isEmojiSubtag(pos, remainingLength, "default", 7)){ - mEmojiStyle = EMSTYLE_DEFAULT; + // If no emoji subtag was provided, resolve the emoji style from script code. + if (script == SCRIPT_TAG('Z', 's', 'y', 'e')) { + return EMSTYLE_EMOJI; + } else if (script == SCRIPT_TAG('Z', 's', 'y', 'm')) { + return EMSTYLE_TEXT; } + + return EMSTYLE_EMPTY; } //static @@ -140,21 +249,21 @@ uint8_t FontLanguage::scriptToSubScriptBits(uint32_t script) { } std::string FontLanguage::getString() const { - if (mLanguage == 0ul) { + if (isUnsupported()) { return "und"; } char buf[16]; - size_t i = 0; - buf[i++] = mLanguage & 0xFF ; - buf[i++] = (mLanguage >> 8) & 0xFF; - char third_letter = (mLanguage >> 16) & 0xFF; - if (third_letter != 0) buf[i++] = third_letter; + size_t i = unpackLanguageOrRegion(mLanguage, buf, 'a', 'a'); if (mScript != 0) { - buf[i++] = '-'; - buf[i++] = (mScript >> 24) & 0xFFu; - buf[i++] = (mScript >> 16) & 0xFFu; - buf[i++] = (mScript >> 8) & 0xFFu; - buf[i++] = mScript & 0xFFu; + buf[i++] = '-'; + buf[i++] = (mScript >> 24) & 0xFFu; + buf[i++] = (mScript >> 16) & 0xFFu; + buf[i++] = (mScript >> 8) & 0xFFu; + buf[i++] = mScript & 0xFFu; + } + if (mRegion != INVALID_CODE) { + buf[i++] = '-'; + i += unpackLanguageOrRegion(mRegion, buf + i, 'A', '0'); } return std::string(buf, i); } diff --git a/engine/src/flutter/libs/minikin/FontLanguage.h b/engine/src/flutter/libs/minikin/FontLanguage.h index 1bebdfeeb9..6a50b1d4cc 100644 --- a/engine/src/flutter/libs/minikin/FontLanguage.h +++ b/engine/src/flutter/libs/minikin/FontLanguage.h @@ -27,6 +27,10 @@ namespace minikin { // Due to the limits in font fallback score calculation, we can't use anything more than 12 // languages. const size_t FONT_LANGUAGES_LIMIT = 12; + +// The language or region code is encoded to 15 bits. +const uint16_t INVALID_CODE = 0x7fff; + class FontLanguages; // FontLanguage is a compact representation of a BCP 47 language tag. It @@ -43,7 +47,9 @@ public: // Default constructor creates the unsupported language. FontLanguage() : mScript(0ul), - mLanguage(0ul), + mLanguage(INVALID_CODE), + mRegion(INVALID_CODE), + mHbLanguage(HB_LANGUAGE_INVALID), mSubScriptBits(0ul), mEmojiStyle(EMSTYLE_EMPTY) {} @@ -52,15 +58,17 @@ public: bool operator==(const FontLanguage other) const { return !isUnsupported() && isEqualScript(other) && mLanguage == other.mLanguage && - mEmojiStyle == other.mEmojiStyle; + mRegion == other.mRegion && mEmojiStyle == other.mEmojiStyle; } bool operator!=(const FontLanguage other) const { return !(*this == other); } - bool isUnsupported() const { return mLanguage == 0ul; } + bool isUnsupported() const { return mLanguage == INVALID_CODE; } EmojiStyle getEmojiStyle() const { return mEmojiStyle; } + hb_language_t getHbLanguage() const { return mHbLanguage; } + bool isEqualScript(const FontLanguage& other) const; @@ -76,7 +84,8 @@ public: int calcScoreFor(const FontLanguages& supported) const; uint64_t getIdentifier() const { - return (uint64_t)mScript << 32 | (uint64_t)mEmojiStyle << 24 | (uint64_t)mLanguage; + return ((uint64_t)mLanguage << 49) | ((uint64_t)mScript << 17) | ((uint64_t)mRegion << 2) | + mEmojiStyle; } private: @@ -86,9 +95,16 @@ private: uint32_t mScript; // ISO 639-1 or ISO 639-2 compliant language code. - // The two or three letter language code is packed into 24 bit integer. + // The two- or three-letter language code is packed into a 15 bit integer. // mLanguage = 0 means the FontLanguage is unsupported. - uint32_t mLanguage; + uint16_t mLanguage; + + // ISO 3166-1 or UN M.49 compliant region code. The two-letter or three-digit region code is + // packed into a 15 bit integer. + uint16_t mRegion; + + // The language to be passed HarfBuzz shaper. + hb_language_t mHbLanguage; // For faster comparing, use 7 bits for specific scripts. static const uint8_t kBopomofoFlag = 1u; @@ -104,6 +120,8 @@ private: static uint8_t scriptToSubScriptBits(uint32_t script); + static EmojiStyle resolveEmojiStyle(const char* buf, size_t length, uint32_t script); + // Returns true if the provide subscript bits has the requested subscript bits. // Note that this function returns false if the requested subscript bits are empty. static bool supportsScript(uint8_t providedBits, uint8_t requestedBits); diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 98e9fdb07b..117f326236 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -811,8 +811,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t break; } } - hb_buffer_set_language(buffer, - hb_language_from_string(hbLanguage->getString().c_str(), -1)); + hb_buffer_set_language(buffer, hbLanguage->getHbLanguage()); } hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); if (ctx->paint.hyphenEdit.hasHyphen() && srunend > srunstart) { diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 1655760bcf..fb917500f0 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -41,6 +41,10 @@ static FontLanguage createFontLanguage(const std::string& input) { return FontLanguageListCache::getById(langId)[0]; } +static FontLanguage createFontLanguageWithoutICUSanitization(const std::string& input) { + return FontLanguage(input.c_str(), input.size()); +} + TEST_F(FontLanguageTest, basicTests) { FontLanguage defaultLang; FontLanguage emptyLang("", 0); @@ -74,19 +78,25 @@ TEST_F(FontLanguageTest, basicTests) { } TEST_F(FontLanguageTest, getStringTest) { - EXPECT_EQ("en-Latn", createFontLanguage("en").getString()); - EXPECT_EQ("en-Latn", createFontLanguage("en-Latn").getString()); + EXPECT_EQ("en-Latn-US", createFontLanguage("en").getString()); + EXPECT_EQ("en-Latn-US", createFontLanguage("en-Latn").getString()); // Capitalized language code or lowercased script should be normalized. - EXPECT_EQ("en-Latn", createFontLanguage("EN-LATN").getString()); - EXPECT_EQ("en-Latn", createFontLanguage("EN-latn").getString()); - EXPECT_EQ("en-Latn", createFontLanguage("en-latn").getString()); + EXPECT_EQ("en-Latn-US", createFontLanguage("EN-LATN").getString()); + EXPECT_EQ("en-Latn-US", createFontLanguage("EN-latn").getString()); + EXPECT_EQ("en-Latn-US", createFontLanguage("en-latn").getString()); // Invalid script should be kept. - EXPECT_EQ("en-Xyzt", createFontLanguage("en-xyzt").getString()); + EXPECT_EQ("en-Xyzt-US", createFontLanguage("en-xyzt").getString()); - EXPECT_EQ("en-Latn", createFontLanguage("en-Latn-US").getString()); - EXPECT_EQ("ja-Jpan", createFontLanguage("ja").getString()); + EXPECT_EQ("en-Latn-US", createFontLanguage("en-Latn-US").getString()); + EXPECT_EQ("ja-Jpan-JP", createFontLanguage("ja").getString()); + EXPECT_EQ("zh-Hant-TW", createFontLanguage("zh-TW").getString()); + EXPECT_EQ("zh-Hant-HK", createFontLanguage("zh-HK").getString()); + EXPECT_EQ("zh-Hant-MO", createFontLanguage("zh-MO").getString()); + EXPECT_EQ("zh-Hans-CN", createFontLanguage("zh").getString()); + EXPECT_EQ("zh-Hans-CN", createFontLanguage("zh-CN").getString()); + EXPECT_EQ("zh-Hans-SG", createFontLanguage("zh-SG").getString()); EXPECT_EQ("und", createFontLanguage("und").getString()); EXPECT_EQ("und", createFontLanguage("UND").getString()); EXPECT_EQ("und", createFontLanguage("Und").getString()); @@ -94,10 +104,44 @@ TEST_F(FontLanguageTest, getStringTest) { EXPECT_EQ("und-Zsye", createFontLanguage("Und-ZSYE").getString()); EXPECT_EQ("und-Zsye", createFontLanguage("Und-zsye").getString()); - EXPECT_EQ("de-Latn", createFontLanguage("de-1901").getString()); + EXPECT_EQ("de-Latn-DE", createFontLanguage("de-1901").getString()); + + EXPECT_EQ("es-Latn-419", createFontLanguage("es-Latn-419").getString()); + + // Emoji subtag is dropped from getString(). + EXPECT_EQ("es-Latn-419", createFontLanguage("es-419-u-em-emoji").getString()); + EXPECT_EQ("es-Latn-419", createFontLanguage("es-Latn-419-u-em-emoji").getString()); // This is not a necessary desired behavior, just known behavior. - EXPECT_EQ("en-Latn", createFontLanguage("und-Abcdefgh").getString()); + EXPECT_EQ("en-Latn-US", createFontLanguage("und-Abcdefgh").getString()); +} + +TEST_F(FontLanguageTest, testReconstruction) { + EXPECT_EQ("en", createFontLanguageWithoutICUSanitization("en").getString()); + EXPECT_EQ("fil", createFontLanguageWithoutICUSanitization("fil").getString()); + EXPECT_EQ("und", createFontLanguageWithoutICUSanitization("und").getString()); + + EXPECT_EQ("en-Latn", createFontLanguageWithoutICUSanitization("en-Latn").getString()); + EXPECT_EQ("fil-Taga", createFontLanguageWithoutICUSanitization("fil-Taga").getString()); + EXPECT_EQ("und-Zsye", createFontLanguageWithoutICUSanitization("und-Zsye").getString()); + + EXPECT_EQ("en-US", createFontLanguageWithoutICUSanitization("en-US").getString()); + EXPECT_EQ("fil-PH", createFontLanguageWithoutICUSanitization("fil-PH").getString()); + EXPECT_EQ("es-419", createFontLanguageWithoutICUSanitization("es-419").getString()); + + EXPECT_EQ("en-Latn-US", createFontLanguageWithoutICUSanitization("en-Latn-US").getString()); + EXPECT_EQ("fil-Taga-PH", createFontLanguageWithoutICUSanitization("fil-Taga-PH").getString()); + EXPECT_EQ("es-Latn-419", createFontLanguageWithoutICUSanitization("es-Latn-419").getString()); + + // Possible minimum/maximum values. + EXPECT_EQ("aa", createFontLanguageWithoutICUSanitization("aa").getString()); + EXPECT_EQ("zz", createFontLanguageWithoutICUSanitization("zz").getString()); + EXPECT_EQ("aa-Aaaa", createFontLanguageWithoutICUSanitization("aa-Aaaa").getString()); + EXPECT_EQ("zz-Zzzz", createFontLanguageWithoutICUSanitization("zz-Zzzz").getString()); + EXPECT_EQ("aaa-Aaaa-AA", createFontLanguageWithoutICUSanitization("aaa-Aaaa-AA").getString()); + EXPECT_EQ("zzz-Zzzz-ZZ", createFontLanguageWithoutICUSanitization("zzz-Zzzz-ZZ").getString()); + EXPECT_EQ("aaa-Aaaa-000", createFontLanguageWithoutICUSanitization("aaa-Aaaa-000").getString()); + EXPECT_EQ("zzz-Zzzz-999", createFontLanguageWithoutICUSanitization("zzz-Zzzz-999").getString()); } TEST_F(FontLanguageTest, ScriptEqualTest) { @@ -247,6 +291,7 @@ TEST_F(FontLanguagesTest, unsupportedLanguageTests) { TEST_F(FontLanguagesTest, repeatedLanguageTests) { FontLanguage english = createFontLanguage("en"); FontLanguage french = createFontLanguage("fr"); + FontLanguage canadianFrench = createFontLanguage("fr-CA"); FontLanguage englishInLatn = createFontLanguage("en-Latn"); ASSERT_TRUE(english == englishInLatn); @@ -254,11 +299,16 @@ TEST_F(FontLanguagesTest, repeatedLanguageTests) { EXPECT_EQ(1u, langs.size()); EXPECT_EQ(english, langs[0]); - // Country codes are ignored. - const FontLanguages& fr = createFontLanguages("fr,fr-CA,fr-FR"); + const FontLanguages& fr = createFontLanguages("fr,fr-FR,fr-Latn-FR"); EXPECT_EQ(1u, fr.size()); EXPECT_EQ(french, fr[0]); + // ICU appends FR to fr. The third language is dropped which is same as the first language. + const FontLanguages& fr2 = createFontLanguages("fr,fr-CA,fr-FR"); + EXPECT_EQ(2u, fr2.size()); + EXPECT_EQ(french, fr2[0]); + EXPECT_EQ(canadianFrench, fr2[1]); + // The order should be kept. const FontLanguages& langs2 = createFontLanguages("en,fr,en-Latn"); EXPECT_EQ(2u, langs2.size()); @@ -266,6 +316,17 @@ TEST_F(FontLanguagesTest, repeatedLanguageTests) { EXPECT_EQ(french, langs2[1]); } +TEST_F(FontLanguagesTest, identifierTest) { + EXPECT_EQ(createFontLanguage("en-Latn-US"), createFontLanguage("en-Latn-US")); + EXPECT_EQ(createFontLanguage("zh-Hans-CN"), createFontLanguage("zh-Hans-CN")); + EXPECT_EQ(createFontLanguage("en-Zsye-US"), createFontLanguage("en-Zsye-US")); + + EXPECT_NE(createFontLanguage("en-Latn-US"), createFontLanguage("en-Latn-GB")); + EXPECT_NE(createFontLanguage("en-Latn-US"), createFontLanguage("en-Zsye-US")); + EXPECT_NE(createFontLanguage("es-Latn-US"), createFontLanguage("en-Latn-US")); + EXPECT_NE(createFontLanguage("zh-Hant-HK"), createFontLanguage("zh-Hant-TW")); +} + TEST_F(FontLanguagesTest, undEmojiTests) { FontLanguage emoji = createFontLanguage("und-Zsye"); EXPECT_EQ(FontLanguage::EMSTYLE_EMOJI, emoji.getEmojiStyle()); @@ -299,9 +360,11 @@ TEST_F(FontLanguagesTest, subtagEmojiTest) { // Strings that contain the county. "und-US-u-em-emoji", "en-US-u-em-emoji", + "es-419-u-em-emoji", "und-Latn-US-u-em-emoji", "en-Zsym-US-u-em-emoji", "en-Zsye-US-u-em-emoji", + "es-Zsye-419-u-em-emoji", }; for (auto subtagEmojiString : subtagEmojiStrings) { @@ -331,9 +394,11 @@ TEST_F(FontLanguagesTest, subtagTextTest) { // Strings that contain the county. "und-US-u-em-text", "en-US-u-em-text", + "es-419-u-em-text", "und-Latn-US-u-em-text", "en-Zsym-US-u-em-text", "en-Zsye-US-u-em-text", + "es-Zsye-419-u-em-text", }; for (auto subtagTextString : subtagTextStrings) { @@ -363,8 +428,10 @@ TEST_F(FontLanguagesTest, subtagDefaultTest) { // Strings that contain the county. "en-US-u-em-default", "en-Latn-US-u-em-default", + "es-Latn-419-u-em-default", "en-Zsym-US-u-em-default", "en-Zsye-US-u-em-default", + "es-Zsye-419-u-em-default", }; for (auto subtagDefaultString : subtagDefaultStrings) { From 3fcf3634db6acb2aec0285dc51e2dba7926ed717 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Mon, 13 Feb 2017 18:32:44 +0900 Subject: [PATCH 232/364] Call hb_font_set_variation if font variations are provided. Test: None Change-Id: I203d9ba7e1a1fcfdb10cd6a711d9a35136cbddd6 --- engine/src/flutter/include/minikin/MinikinFont.h | 2 ++ engine/src/flutter/include/minikin/MinikinFontFreeType.h | 5 +++++ engine/src/flutter/libs/minikin/HbFontCache.cpp | 5 +++++ engine/src/flutter/sample/MinikinSkia.h | 5 ++++- engine/src/flutter/tests/util/MinikinFontForTest.h | 2 +- 5 files changed, 17 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 57b939788a..64bab02a20 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -126,6 +126,8 @@ public: return 0; } + virtual const std::vector& GetAxes() const = 0; + virtual MinikinFont* createFontWithVariation(const std::vector&) const { return nullptr; } diff --git a/engine/src/flutter/include/minikin/MinikinFontFreeType.h b/engine/src/flutter/include/minikin/MinikinFontFreeType.h index 34c3fd92d4..37333e5f37 100644 --- a/engine/src/flutter/include/minikin/MinikinFontFreeType.h +++ b/engine/src/flutter/include/minikin/MinikinFontFreeType.h @@ -50,6 +50,10 @@ public: const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy); + const std::vector& GetAxes() const { + return mAxes; + } + // TODO: provide access to raw data, as an optimization. // Not a virtual method, as the protocol to access rendered @@ -63,6 +67,7 @@ public: private: FT_Face mTypeface; static int32_t sIdCounter; + std::vector mAxes; }; } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index bd59e8f626..e871b4ef9b 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -117,6 +117,11 @@ hb_font_t* getHbFontLocked(MinikinFont* minikinFont) { hb_font_set_scale(parent_font, upem, upem); font = hb_font_create_sub_font(parent_font); + std::vector variations; + for (const FontVariation& variation : minikinFont->GetAxes()) { + variations.push_back({variation.axisTag, variation.value}); + } + hb_font_set_variations(font, variations.data(), variations.size()); hb_font_destroy(parent_font); hb_face_destroy(face); fontCache->put(fontId, font); diff --git a/engine/src/flutter/sample/MinikinSkia.h b/engine/src/flutter/sample/MinikinSkia.h index d995f7d279..8284f5d0f9 100644 --- a/engine/src/flutter/sample/MinikinSkia.h +++ b/engine/src/flutter/sample/MinikinSkia.h @@ -26,12 +26,15 @@ public: const MinikinPaint& paint) const; const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy); + const std::vector& GetAxes() const { + return mAxes; + } SkTypeface *GetSkTypeface(); private: sk_sp mTypeface; - + std::vector mAxes; }; } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index 2a107036ed..1d0628319b 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -38,11 +38,11 @@ public: const MinikinPaint& paint) const; const std::string& fontPath() const { return mFontPath; } - const std::vector& variations() const { return mVariations; } const void* GetFontData() const { return mFontData; } size_t GetFontSize() const { return mFontSize; } int GetFontIndex() const { return mFontIndex; } + const std::vector& GetAxes() const { return mVariations; } MinikinFont* createFontWithVariation(const std::vector& variations) const; private: MinikinFontForTest() = delete; From 6308ea4c4b4652f061a646d164d5fdc941a25ba2 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Wed, 22 Feb 2017 18:48:18 -0800 Subject: [PATCH 233/364] Add exception for Bulgarian to mk_hyb_file MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The Bulgarian hyphenation patterns contain a line consisting of '0ь0' which has no practical effect on hyphenation. Add an exception in roundtrip testing to make sure we don't fail while comparing our tables with the input data. Test: make -j works and creates .hyb files for bg and cu Change-Id: Ia46b8a45fe522f5194d8105d31b34b0e27528cc9 --- engine/src/flutter/tools/mk_hyb_file.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/engine/src/flutter/tools/mk_hyb_file.py b/engine/src/flutter/tools/mk_hyb_file.py index 978c082b27..a9b8932c95 100755 --- a/engine/src/flutter/tools/mk_hyb_file.py +++ b/engine/src/flutter/tools/mk_hyb_file.py @@ -539,6 +539,12 @@ def verify_hyb_file(hyb_fn, pat_fn, chr_fn, hyp_fn): patterns = [] exceptions = [] traverse_trie(0, '', trie_data, ch_map, pattern_data, patterns, exceptions) + + # EXCEPTION for Bulgarian (bg), which contains an ineffectual line of <0, U+044C, 0> + if u'\u044c' in patterns: + patterns.remove(u'\u044c') + patterns.append(u'0\u044c0') + assert verify_file_sorted(patterns, pat_fn), 'pattern table not verified' assert verify_file_sorted(exceptions, hyp_fn), 'exception table not verified' From a6198608722f8c2ce49f993adfab39398105c240 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Fri, 10 Feb 2017 14:52:05 +0900 Subject: [PATCH 234/364] Remove MinikinRefCounted and use shared_ptr instead Let's use shared_ptr since manual ref counting can be a bug-prone and using the global mutex inside destructor is not useful for some time. To remove raw pointer manipulation, needed to change Layout constructors. Layout is no longer copyable and need to pass FontCollection to constructor. Bug: 28119474 Test: minikin_tests passed Test: hwui_unit_tests passed Test: No performance regression in minikin_perftest. Change-Id: I8824593206ecba74cbc9731e298f045e1ae442a3 --- .../flutter/include/minikin/FontCollection.h | 48 +-- .../src/flutter/include/minikin/FontFamily.h | 30 +- engine/src/flutter/include/minikin/Layout.h | 37 +- .../src/flutter/include/minikin/LineBreaker.h | 4 +- .../src/flutter/include/minikin/MinikinFont.h | 9 +- .../include/minikin/MinikinRefCounted.h | 59 ---- engine/src/flutter/libs/minikin/Android.mk | 1 - .../flutter/libs/minikin/FontCollection.cpp | 85 ++--- .../src/flutter/libs/minikin/FontFamily.cpp | 63 ++-- .../src/flutter/libs/minikin/HbFontCache.cpp | 2 +- engine/src/flutter/libs/minikin/HbFontCache.h | 2 +- engine/src/flutter/libs/minikin/Layout.cpp | 53 ++- .../src/flutter/libs/minikin/LineBreaker.cpp | 2 +- .../src/flutter/libs/minikin/MinikinFont.cpp | 2 + .../flutter/libs/minikin/MinikinInternal.cpp | 2 +- .../flutter/libs/minikin/MinikinInternal.h | 2 +- .../libs/minikin/MinikinRefCounted.cpp | 35 -- engine/src/flutter/sample/MinikinSkia.cpp | 5 +- engine/src/flutter/sample/MinikinSkia.h | 4 +- engine/src/flutter/sample/example.cpp | 17 +- engine/src/flutter/sample/example_skia.cpp | 19 +- .../tests/perftests/FontCollection.cpp | 7 +- .../unittest/FontCollectionItemizeTest.cpp | 327 +++++++++--------- .../tests/unittest/FontCollectionTest.cpp | 40 +-- .../flutter/tests/unittest/FontFamilyTest.cpp | 35 +- .../tests/unittest/HbFontCacheTest.cpp | 10 +- .../src/flutter/tests/unittest/LayoutTest.cpp | 36 +- .../src/flutter/tests/util/FontTestUtils.cpp | 25 +- .../flutter/tests/util/MinikinFontForTest.cpp | 4 +- .../flutter/tests/util/MinikinFontForTest.h | 3 +- .../src/flutter/tests/util/UnicodeUtils.cpp | 11 + engine/src/flutter/tests/util/UnicodeUtils.h | 3 + 32 files changed, 443 insertions(+), 539 deletions(-) delete mode 100644 engine/src/flutter/include/minikin/MinikinRefCounted.h delete mode 100644 engine/src/flutter/libs/minikin/MinikinRefCounted.cpp diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 42499a0469..2364538799 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -17,20 +17,19 @@ #ifndef MINIKIN_FONT_COLLECTION_H #define MINIKIN_FONT_COLLECTION_H -#include +#include #include +#include -#include #include #include namespace minikin { -class FontCollection : public MinikinRefCounted { +class FontCollection { public: - explicit FontCollection(const std::vector& typefaces); - - ~FontCollection(); + explicit FontCollection(const std::vector>& typefaces); + explicit FontCollection(std::shared_ptr&& typeface); struct Run { FakedFont fakedFont; @@ -46,15 +45,13 @@ public: // selector pair, or invalid variation selector is passed. bool hasVariationSelector(uint32_t baseCodepoint, uint32_t variationSelector) const; - // Get the base font for the given style, useful for font-wide metrics. - MinikinFont* baseFont(FontStyle style); - // Get base font with fakery information (fake bold could affect metrics) FakedFont baseFontFaked(FontStyle style); // Creates new FontCollection based on this collection while applying font variations. Returns // nullptr if none of variations apply to this collection. - FontCollection* createCollectionWithVariation(const std::vector& variations); + std::shared_ptr + createCollectionWithVariation(const std::vector& variations); uint32_t getId() const; @@ -67,12 +64,17 @@ private: size_t end; }; - FontFamily* getFamilyForChar(uint32_t ch, uint32_t vs, uint32_t langListId, int variant) const; + // Initialize the FontCollection. + void init(const std::vector>& typefaces); + + const std::shared_ptr& getFamilyForChar(uint32_t ch, uint32_t vs, + uint32_t langListId, int variant) const; uint32_t calcFamilyScore(uint32_t ch, uint32_t vs, int variant, uint32_t langListId, - FontFamily* fontFamily) const; + const std::shared_ptr& fontFamily) const; - uint32_t calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* fontFamily) const; + uint32_t calcCoverageScore(uint32_t ch, uint32_t vs, + const std::shared_ptr& fontFamily) const; static uint32_t calcLanguageMatchingScore(uint32_t userLangListId, const FontFamily& fontFamily); @@ -88,19 +90,19 @@ private: // Highest UTF-32 code point that can be mapped uint32_t mMaxChar; - // This vector has ownership of the bitsets and typeface objects. + // This vector has pointers to the all font family instances in this collection. // This vector can't be empty. - std::vector mFamilies; + std::vector> mFamilies; - // This vector contains pointers into mInstances - // This vector can't be empty. - std::vector mFamilyVec; - - // This vector has pointers to the font family instance which has cmap 14 subtable. - std::vector mVSFamilyVec; - - // These are offsets into mInstanceVec, one range per page + // Following two vectors are pre-calculated tables for resolving coverage faster. + // For example, to iterate over all fonts which support Unicode code point U+XXYYZZ, + // iterate font families from mFamilyVec[mRanges[0xXXYY].start] to + // mFamilyVec[mRange[0xXXYY].end] instead of whole mFamilies. std::vector mRanges; + std::vector> mFamilyVec; + + // This vector has pointers to the font family instances which have cmap 14 subtables. + std::vector> mVSFamilyVec; // Set of supported axes in this collection. std::unordered_set mSupportedAxes; diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 9ce8c6537c..c7018a6f8c 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -17,14 +17,15 @@ #ifndef MINIKIN_FONT_FAMILY_H #define MINIKIN_FONT_FAMILY_H -#include +#include #include #include +#include + #include #include -#include #include namespace minikin { @@ -102,19 +103,17 @@ struct FakedFont { typedef uint32_t AxisTag; struct Font { - Font(MinikinFont* typeface, FontStyle style); + Font(const std::shared_ptr& typeface, FontStyle style); + Font(std::shared_ptr&& typeface, FontStyle style); Font(Font&& o); Font(const Font& o); - ~Font(); - MinikinFont* typeface; + std::shared_ptr typeface; FontStyle style; std::unordered_set supportedAxes; - // TODO: remove this weird function. http://b/28119474 - // MinikinFont requres mutex lock for destruction, but the mutex lock is not - // visible from outside of minikin library. - static void clearElementsWithLock(std::vector* fonts); +private: + void loadAxes(); }; struct FontVariation { @@ -123,7 +122,7 @@ struct FontVariation { float value; }; -class FontFamily : public MinikinRefCounted { +class FontFamily { public: explicit FontFamily(std::vector&& fonts); FontFamily(int variant, std::vector&& fonts); @@ -132,8 +131,8 @@ public: ~FontFamily(); // TODO: Good to expose FontUtil.h. - static bool analyzeStyle(MinikinFont* typeface, int* weight, bool* italic); - + static bool analyzeStyle(const std::shared_ptr& typeface, int* weight, + bool* italic); FakedFont getClosestMatch(FontStyle style) const; uint32_t langId() const { return mLangId; } @@ -141,7 +140,9 @@ public: // API's for enumerating the fonts in a family. These don't guarantee any particular order size_t getNumFonts() const { return mFonts.size(); } - MinikinFont* getFont(size_t index) const { return mFonts[index].typeface; } + const std::shared_ptr& getFont(size_t index) const { + return mFonts[index].typeface; + } FontStyle getStyle(size_t index) const { return mFonts[index].style; } bool isColorEmojiFamily() const; const std::unordered_set& supportedAxes() const { return mSupportedAxes; } @@ -158,7 +159,8 @@ public: // Creates new FontFamily based on this family while applying font variations. Returns nullptr // if none of variations apply to this family. - FontFamily* createFamilyWithVariation(const std::vector& variations) const; + std::shared_ptr createFamilyWithVariation( + const std::vector& variations) const; private: void computeCoverage(); diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 625e05c433..e9849c382c 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -19,6 +19,7 @@ #include +#include #include #include @@ -71,37 +72,34 @@ enum { // Lifecycle and threading assumptions for Layout: // The object is assumed to be owned by a single thread; multiple threads // may not mutate it at the same time. -// The lifetime of the FontCollection set through setFontCollection must -// extend through the lifetime of the Layout object. class Layout { public: - Layout() : mGlyphs(), mAdvances(), mCollection(0), mFaces(), mAdvance(0), mBounds() { + Layout(const std::shared_ptr& collection) + : mGlyphs(), mAdvances(), mCollection(collection), mFaces(), mAdvance(0), mBounds() { mBounds.setEmpty(); } - // Clears layout, ready to be used again - void reset(); + Layout(Layout&& layout) = default; + + // Forbid copying and assignment. + Layout(const Layout&) = delete; + void operator=(const Layout&) = delete; void dump() const; - void setFontCollection(const FontCollection* collection); void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint); static float measureText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint, - const FontCollection* collection, float* advances); + const std::shared_ptr& collection, float* advances); void draw(minikin::Bitmap*, int x0, int y0, float size) const; - // Deprecated. Nont needed. Remove when callers are removed. - static void init(); - // public accessors size_t nGlyphs() const; - // Does not bump reference; ownership is still layout - MinikinFont *getFont(int i) const; + const MinikinFont* getFont(int i) const; FontFakery getFakery(int i) const; unsigned int getGlyphId(int i) const; float getX(int i) const; @@ -117,7 +115,7 @@ public: // start and count are the parameters to doLayout float getCharAdvance(size_t i) const { return mAdvances[i]; } - void getBounds(MinikinRect* rect); + void getBounds(MinikinRect* rect) const; // Purge all caches, useful in low memory conditions static void purgeCaches(); @@ -126,19 +124,22 @@ private: friend class LayoutCacheKey; // Find a face in the mFaces vector, or create a new entry - int findFace(FakedFont face, LayoutContext* ctx); + int findFace(const FakedFont& face, LayoutContext* ctx); + + // Clears layout, ready to be used again + void reset(); // Lay out a single bidi run // When layout is not null, layout info will be stored in the object. // When advances is not null, measurement results will be stored in the array. static float doLayoutRunCached(const uint16_t* buf, size_t runStart, size_t runLength, size_t bufSize, bool isRtl, LayoutContext* ctx, size_t dstStart, - const FontCollection* collection, Layout* layout, float* advances); + const std::shared_ptr& collection, Layout* layout, float* advances); // Lay out a single word static float doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, LayoutContext* ctx, size_t bufStart, const FontCollection* collection, - Layout* layout, float* advances); + bool isRtl, LayoutContext* ctx, size_t bufStart, + const std::shared_ptr& collection, Layout* layout, float* advances); // Lay out a single bidi run void doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, @@ -150,7 +151,7 @@ private: std::vector mGlyphs; std::vector mAdvances; - const FontCollection* mCollection; + std::shared_ptr mCollection; std::vector mFaces; float mAdvance; MinikinRect mBounds; diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index 75e54b05f1..e93953666b 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -159,8 +159,8 @@ class LineBreaker { // Minikin to do the shaping of the strings. The main thing that would need to be changed // is having some kind of callback (or virtual class, or maybe even template), which could // easily be instantiated with Minikin's Layout. Future work for when needed. - float addStyleRun(MinikinPaint* paint, const FontCollection* typeface, FontStyle style, - size_t start, size_t end, bool isRtl); + float addStyleRun(MinikinPaint* paint, const std::shared_ptr& typeface, + FontStyle style, size_t start, size_t end, bool isRtl); void addReplacement(size_t start, size_t end, float width); diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 64bab02a20..1d5ebb774a 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -18,8 +18,8 @@ #define MINIKIN_FONT_H #include +#include -#include #include // An abstraction for platform fonts, allowing Minikin to be used with @@ -45,7 +45,7 @@ class MinikinFont; // Possibly move into own .h file? // Note: if you add a field here, either add it to LayoutCacheKey or to skipCache() struct MinikinPaint { - MinikinPaint() : font(0), size(0), scaleX(0), skewX(0), letterSpacing(0), wordSpacing(0), + MinikinPaint() : font(nullptr), size(0), scaleX(0), skewX(0), letterSpacing(0), wordSpacing(0), paintFlags(0), fakery(), hyphenEdit(), fontFeatureSettings() { } bool skipCache() const { @@ -98,7 +98,7 @@ class MinikinFontFreeType; // Callback for freeing data typedef void (*MinikinDestroyFunc) (void* data); -class MinikinFont : public MinikinRefCounted { +class MinikinFont { public: explicit MinikinFont(int32_t uniqueId) : mUniqueId(uniqueId) {} @@ -128,7 +128,8 @@ public: virtual const std::vector& GetAxes() const = 0; - virtual MinikinFont* createFontWithVariation(const std::vector&) const { + virtual std::shared_ptr createFontWithVariation( + const std::vector&) const { return nullptr; } diff --git a/engine/src/flutter/include/minikin/MinikinRefCounted.h b/engine/src/flutter/include/minikin/MinikinRefCounted.h deleted file mode 100644 index 960b6cc46d..0000000000 --- a/engine/src/flutter/include/minikin/MinikinRefCounted.h +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (C) 2014 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. - */ - -// Base class for reference counted objects in Minikin - -#ifndef MINIKIN_REF_COUNTED_H -#define MINIKIN_REF_COUNTED_H - -namespace minikin { - -class MinikinRefCounted { -public: - void RefLocked() { mRefcount_++; } - void UnrefLocked() { if (--mRefcount_ == 0) { delete this; } } - - // These refcount operations take the global lock. - void Ref(); - void Unref(); - - MinikinRefCounted() : mRefcount_(1) { } - - virtual ~MinikinRefCounted() { }; -private: - int mRefcount_; -}; - -// An RAII container for reference counted objects. -// Note: this is only suitable for clients which are _not_ holding the global lock. -template -class MinikinAutoUnref { -public: - explicit MinikinAutoUnref(T* obj) : mObj(obj) { - } - ~MinikinAutoUnref() { - mObj->Unref(); - } - T& operator*() const { return *mObj; } - T* operator->() const { return mObj; } - T* get() const { return mObj; } -private: - T* mObj; -}; - -} // namespace minikin - -#endif // MINIKIN_REF_COUNTED_H diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 44abb88532..603638e754 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -44,7 +44,6 @@ minikin_src_files := \ LineBreaker.cpp \ Measurement.cpp \ MinikinInternal.cpp \ - MinikinRefCounted.cpp \ MinikinFont.cpp \ MinikinFontFreeType.cpp \ SparseBitSet.cpp \ diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 9d0e2c8b38..c351c3a58d 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -79,8 +79,18 @@ static bool isEmojiStyleVSBase(uint32_t cp) { uint32_t FontCollection::sNextId = 0; -FontCollection::FontCollection(const vector& typefaces) : +FontCollection::FontCollection(std::shared_ptr&& typeface) : mMaxChar(0) { + std::vector> typefaces; + typefaces.push_back(typeface); + init(typefaces); +} + +FontCollection::FontCollection(const vector>& typefaces) : mMaxChar(0) { + init(typefaces); +} + +void FontCollection::init(const vector>& typefaces) { android::AutoMutex _l(gMinikinLock); mId = sNextId++; vector lastChar; @@ -90,12 +100,10 @@ FontCollection::FontCollection(const vector& typefaces) : #endif const FontStyle defaultStyle; for (size_t i = 0; i < nTypefaces; i++) { - FontFamily* family = typefaces[i]; - MinikinFont* typeface = family->getClosestMatch(defaultStyle).font; - if (typeface == NULL) { + const std::shared_ptr& family = typefaces[i]; + if (family->getClosestMatch(defaultStyle).font == nullptr) { continue; } - family->RefLocked(); const SparseBitSet& coverage = family->getCoverage(); mFamilies.push_back(family); // emplace_back would be better if (family->hasVSTable()) { @@ -126,7 +134,7 @@ FontCollection::FontCollection(const vector& typefaces) : range->start = offset; for (size_t j = 0; j < nTypefaces; j++) { if (lastChar[j] < (i + 1) << kLogCharsPerPage) { - FontFamily* family = mFamilies[j]; + const std::shared_ptr& family = mFamilies[j]; mFamilyVec.push_back(family); offset++; uint32_t nextChar = family->getCoverage().nextSetBit((i + 1) << kLogCharsPerPage); @@ -140,12 +148,6 @@ FontCollection::FontCollection(const vector& typefaces) : } } -FontCollection::~FontCollection() { - for (size_t i = 0; i < mFamilies.size(); i++) { - mFamilies[i]->UnrefLocked(); - } -} - // Special scores for the font fallback. const uint32_t kUnsupportedFontScore = 0; const uint32_t kFirstFontScore = UINT32_MAX; @@ -167,7 +169,7 @@ const uint32_t kFirstFontScore = UINT32_MAX; // - kFirstFontScore: When the font is the first font family in the collection and it supports the // given character or variation sequence. uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, uint32_t langListId, - FontFamily* fontFamily) const { + const std::shared_ptr& fontFamily) const { const uint32_t coverageScore = calcCoverageScore(ch, vs, fontFamily); if (coverageScore == kFirstFontScore || coverageScore == kUnsupportedFontScore) { @@ -194,7 +196,8 @@ uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, // - Returns 2 if the vs is a text variation selector (U+FE0E) and if the font is not an emoji font. // - Returns 1 if the variation selector is not specified or if the font family only supports the // variation sequence's base character. -uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, FontFamily* fontFamily) const { +uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, + const std::shared_ptr& fontFamily) const { const bool hasVSGlyph = (vs != 0) && fontFamily->hasGlyph(ch, vs); if (!hasVSGlyph && !fontFamily->getCoverage().get(ch)) { // The font doesn't support either variation sequence or even the base character. @@ -277,13 +280,13 @@ uint32_t FontCollection::calcVariantMatchingScore(int variant, const FontFamily& // 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. -FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, +const std::shared_ptr& FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, uint32_t langListId, int variant) const { if (ch >= mMaxChar) { return mFamilies[0]; } - const std::vector& familyVec = (vs == 0) ? mFamilyVec : mFamilies; + const std::vector>& familyVec = (vs == 0) ? mFamilyVec : mFamilies; Range range = mRanges[ch >> kLogCharsPerPage]; if (vs != 0) { @@ -293,10 +296,10 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, #ifdef VERBOSE_DEBUG ALOGD("querying range %zd:%zd\n", range.start, range.end); #endif - FontFamily* bestFamily = nullptr; + int bestFamilyIndex = -1; uint32_t bestScore = kUnsupportedFontScore; for (size_t i = range.start; i < range.end; i++) { - FontFamily* family = familyVec[i]; + const std::shared_ptr& family = familyVec[i]; const uint32_t score = calcFamilyScore(ch, vs, variant, langListId, family); if (score == kFirstFontScore) { // If the first font family supports the given character or variation sequence, always @@ -305,10 +308,10 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, } if (score > bestScore) { bestScore = score; - bestFamily = family; + bestFamilyIndex = i; } } - if (bestFamily == nullptr) { + if (bestFamilyIndex == -1) { UErrorCode errorCode = U_ZERO_ERROR; const UNormalizer2* normalizer = unorm2_getNFDInstance(&errorCode); if (U_SUCCESS(errorCode)) { @@ -320,9 +323,9 @@ FontFamily* FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, return getFamilyForChar(ch, vs, langListId, variant); } } - bestFamily = mFamilies[0]; + return mFamilies[0]; } - return bestFamily; + return familyVec[bestFamilyIndex]; } const uint32_t NBSP = 0xA0; @@ -375,7 +378,7 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, if (isEmojiStyleVSBase(baseCodepoint) && variationSelector == TEXT_STYLE_VS) { for (size_t i = 0; i < mFamilies.size(); ++i) { if (!mFamilies[i]->isColorEmojiFamily() && variationSelector == TEXT_STYLE_VS && - mFamilies[i]->hasGlyph(baseCodepoint, 0)) { + mFamilies[i]->hasGlyph(baseCodepoint, 0)) { return true; } } @@ -388,7 +391,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty vector* result) const { const uint32_t langListId = style.getLanguageListId(); int variant = style.getVariant(); - FontFamily* lastFamily = NULL; + const FontFamily* lastFamily = nullptr; Run* run = NULL; if (string_size == 0) { @@ -425,9 +428,9 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } if (!shouldContinueRun) { - FontFamily* family = getFamilyForChar(ch, isVariationSelector(nextCh) ? nextCh : 0, - langListId, variant); - if (utf16Pos == 0 || family != lastFamily) { + const std::shared_ptr& family = getFamilyForChar( + ch, isVariationSelector(nextCh) ? nextCh : 0, langListId, variant); + if (utf16Pos == 0 || family.get() != lastFamily) { 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 @@ -437,7 +440,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty if (utf16Pos != 0 && ((U_GET_GC_MASK(ch) & U_GC_M_MASK) != 0 || (isEmojiModifier(ch) && isEmojiBase(prevCh))) && - family && family->getCoverage().get(prevCh)) { + family != nullptr && family->getCoverage().get(prevCh)) { const size_t prevChLength = U16_LENGTH(prevCh); run->end -= prevChLength; if (run->start == run->end) { @@ -445,12 +448,9 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } start -= prevChLength; } - Run dummy; - result->push_back(dummy); + result->push_back({family->getClosestMatch(style), static_cast(start), 0}); run = &result->back(); - run->fakedFont = family->getClosestMatch(style); - lastFamily = family; - run->start = start; + lastFamily = family.get(); } } prevCh = ch; @@ -458,15 +458,11 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty } while (nextCh != kEndOfString); } -MinikinFont* FontCollection::baseFont(FontStyle style) { - return baseFontFaked(style).font; -} - FakedFont FontCollection::baseFontFaked(FontStyle style) { return mFamilies[0]->getClosestMatch(style); } -FontCollection* FontCollection::createCollectionWithVariation( +std::shared_ptr FontCollection::createCollectionWithVariation( const std::vector& variations) { if (variations.empty() || mSupportedAxes.empty()) { return nullptr; @@ -484,22 +480,17 @@ FontCollection* FontCollection::createCollectionWithVariation( return nullptr; } - std::vector families; - for (FontFamily* family : mFamilies) { - FontFamily* newFamily = family->createFamilyWithVariation(variations); + std::vector > families; + for (const std::shared_ptr& family : mFamilies) { + std::shared_ptr newFamily = family->createFamilyWithVariation(variations); if (newFamily) { families.push_back(newFamily); } else { - family->Ref(); families.push_back(family); } } - FontCollection* result = new FontCollection(families); - for (FontFamily* family : families) { - family->Unref(); - } - return result; + return std::shared_ptr(new FontCollection(families)); } uint32_t FontCollection::getId() const { diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 6d44bc395c..d0a0138ef2 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -65,13 +65,20 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { return (weight & kWeightMask) | (italic ? kItalicMask : 0) | (variant << kVariantShift); } -Font::Font(MinikinFont* typeface, FontStyle style) +Font::Font(const std::shared_ptr& typeface, FontStyle style) : typeface(typeface), style(style) { - android::AutoMutex _l(gMinikinLock); - typeface->RefLocked(); + loadAxes(); +} +Font::Font(std::shared_ptr&& typeface, FontStyle style) + : typeface(typeface), style(style) { + loadAxes(); +} + +void Font::loadAxes() { + android::AutoMutex _l(gMinikinLock); const uint32_t fvarTag = MinikinFont::MakeTag('f', 'v', 'a', 'r'); - HbBlob fvarTable(getFontTable(typeface, fvarTag)); + HbBlob fvarTable(getFontTable(typeface.get(), fvarTag)); if (fvarTable.size() == 0) { return; } @@ -80,7 +87,7 @@ Font::Font(MinikinFont* typeface, FontStyle style) } Font::Font(Font&& o) { - typeface = o.typeface; + typeface = std::move(o.typeface); style = o.style; o.typeface = nullptr; supportedAxes = std::move(o.supportedAxes); @@ -88,23 +95,11 @@ Font::Font(Font&& o) { Font::Font(const Font& o) { typeface = o.typeface; - typeface->Ref(); style = o.style; supportedAxes = o.supportedAxes; } -Font::~Font() { - if (typeface == nullptr) { - return; - } - typeface->UnrefLocked(); -} - -void Font::clearElementsWithLock(std::vector* fonts) { - android::AutoMutex _l(gMinikinLock); - fonts->clear(); -} - +// static FontFamily::FontFamily(std::vector&& fonts) : FontFamily(0 /* variant */, std::move(fonts)) { } @@ -120,10 +115,11 @@ FontFamily::FontFamily(uint32_t langId, int variant, std::vector&& fonts) FontFamily::~FontFamily() { } -bool FontFamily::analyzeStyle(MinikinFont* typeface, int* weight, bool* italic) { +bool FontFamily::analyzeStyle(const std::shared_ptr& typeface, int* weight, + bool* italic) { android::AutoMutex _l(gMinikinLock); const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); - HbBlob os2Table(getFontTable(typeface, os2Tag)); + HbBlob os2Table(getFontTable(typeface.get(), os2Tag)); if (os2Table.get() == nullptr) return false; return ::minikin::analyzeStyle(os2Table.get(), os2Table.size(), weight, italic); } @@ -149,7 +145,7 @@ static FontFakery computeFakery(FontStyle wanted, FontStyle actual) { } FakedFont FontFamily::getClosestMatch(FontStyle style) const { - const Font* bestFont = NULL; + const Font* bestFont = nullptr; int bestMatch = 0; for (size_t i = 0; i < mFonts.size(); i++) { const Font& font = mFonts[i]; @@ -159,14 +155,10 @@ FakedFont FontFamily::getClosestMatch(FontStyle style) const { bestMatch = match; } } - FakedFont result; - if (bestFont == NULL) { - result.font = NULL; - } else { - result.font = bestFont->typeface; - result.fakery = computeFakery(style, bestFont->style); + if (bestFont != nullptr) { + return FakedFont{ bestFont->typeface.get(), computeFakery(style, bestFont->style) }; } - return result; + return FakedFont{ nullptr, FontFakery() }; } bool FontFamily::isColorEmojiFamily() const { @@ -182,7 +174,7 @@ bool FontFamily::isColorEmojiFamily() const { void FontFamily::computeCoverage() { android::AutoMutex _l(gMinikinLock); const FontStyle defaultStyle; - MinikinFont* typeface = getClosestMatch(defaultStyle).font; + const MinikinFont* typeface = getClosestMatch(defaultStyle).font; const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); HbBlob cmapTable(getFontTable(typeface, cmapTag)); if (cmapTable.get() == nullptr) { @@ -206,15 +198,14 @@ bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const } const FontStyle defaultStyle; - MinikinFont* minikinFont = getClosestMatch(defaultStyle).font; - hb_font_t* font = getHbFontLocked(minikinFont); + hb_font_t* font = getHbFontLocked(getClosestMatch(defaultStyle).font); uint32_t unusedGlyph; bool result = hb_font_get_glyph(font, codepoint, variationSelector, &unusedGlyph); hb_font_destroy(font); return result; } -FontFamily* FontFamily::createFamilyWithVariation( +std::shared_ptr FontFamily::createFamilyWithVariation( const std::vector& variations) const { if (variations.empty() || mSupportedAxes.empty()) { return nullptr; @@ -243,19 +234,17 @@ FontFamily* FontFamily::createFamilyWithVariation( } } } - MinikinFont* minikinFont = nullptr; + std::shared_ptr minikinFont; if (supportedVariations) { minikinFont = font.typeface->createFontWithVariation(variations); } if (minikinFont == nullptr) { minikinFont = font.typeface; - minikinFont->Ref(); } - fonts.push_back(Font(minikinFont, font.style)); - minikinFont->Unref(); + fonts.push_back(Font(std::move(minikinFont), font.style)); } - return new FontFamily(mLangId, mVariant, std::move(fonts)); + return std::shared_ptr(new FontFamily(mLangId, mVariant, std::move(fonts))); } } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index e871b4ef9b..af3d783bc8 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -84,7 +84,7 @@ void purgeHbFontLocked(const MinikinFont* minikinFont) { // Returns a new reference to a hb_font_t object, caller is // responsible for calling hb_font_destroy() on it. -hb_font_t* getHbFontLocked(MinikinFont* minikinFont) { +hb_font_t* getHbFontLocked(const MinikinFont* minikinFont) { assertMinikinLocked(); // TODO: get rid of nullFaceFont static hb_font_t* nullFaceFont = nullptr; diff --git a/engine/src/flutter/libs/minikin/HbFontCache.h b/engine/src/flutter/libs/minikin/HbFontCache.h index fba685aeb2..59969e287e 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.h +++ b/engine/src/flutter/libs/minikin/HbFontCache.h @@ -24,7 +24,7 @@ class MinikinFont; void purgeHbFontCacheLocked(); void purgeHbFontLocked(const MinikinFont* minikinFont); -hb_font_t* getHbFontLocked(MinikinFont* minikinFont); +hb_font_t* getHbFontLocked(const MinikinFont* minikinFont); } // namespace minikin #endif // MINIKIN_HBFONT_CACHE_H diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 117f326236..6b28f57a33 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -104,8 +104,9 @@ struct LayoutContext { class LayoutCacheKey { public: - LayoutCacheKey(const FontCollection* collection, const MinikinPaint& paint, FontStyle style, - const uint16_t* chars, size_t start, size_t count, size_t nchars, bool dir) + LayoutCacheKey(const std::shared_ptr& collection, const MinikinPaint& paint, + FontStyle style, const uint16_t* chars, size_t start, size_t count, size_t nchars, + bool dir) : mChars(chars), mNchars(nchars), mStart(start), mCount(count), mId(collection->getId()), mStyle(style), mSize(paint.size), mScaleX(paint.scaleX), mSkewX(paint.skewX), @@ -129,8 +130,7 @@ public: mChars = NULL; } - void doLayout(Layout* layout, LayoutContext* ctx, const FontCollection* collection) const { - layout->setFontCollection(collection); + void doLayout(Layout* layout, LayoutContext* ctx) const { layout->mAdvances.resize(mCount, 0); ctx->clearHbFonts(); layout->doLayoutRun(mChars, mStart, mCount, mNchars, mIsRtl, ctx); @@ -167,12 +167,13 @@ public: mCache.clear(); } - Layout* get(LayoutCacheKey& key, LayoutContext* ctx, const FontCollection* collection) { + Layout* get(LayoutCacheKey& key, LayoutContext* ctx, + const std::shared_ptr& collection) { Layout* layout = mCache.get(key); if (layout == NULL) { key.copyText(); - layout = new Layout(); - key.doLayout(layout, ctx, collection); + layout = new Layout(collection); + key.doLayout(layout, ctx); mCache.put(key, layout); } return layout; @@ -262,10 +263,6 @@ void MinikinRect::join(const MinikinRect& r) { } } -// Deprecated. Remove when callers are removed. -void Layout::init() { -} - void Layout::reset() { mGlyphs.clear(); mFaces.clear(); @@ -274,15 +271,10 @@ void Layout::reset() { mAdvance = 0; } -void Layout::setFontCollection(const FontCollection* collection) { - mCollection = collection; -} - static hb_position_t harfbuzzGetGlyphHorizontalAdvance(hb_font_t* /* hbFont */, void* fontData, hb_codepoint_t glyph, void* /* userData */) { MinikinPaint* paint = reinterpret_cast(fontData); - MinikinFont* font = paint->font; - float advance = font->GetHorizontalAdvance(glyph, *paint); + float advance = paint->font->GetHorizontalAdvance(glyph, *paint); return 256 * advance + 0.5; } @@ -343,7 +335,7 @@ void Layout::dump() const { } } -int Layout::findFace(FakedFont face, LayoutContext* ctx) { +int Layout::findFace(const FakedFont& face, LayoutContext* ctx) { unsigned int ix; for (ix = 0; ix < mFaces.size(); ix++) { if (mFaces[ix].font == face.font) { @@ -610,7 +602,7 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu float Layout::measureText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint, - const FontCollection* collection, float* advances) { + const std::shared_ptr& collection, float* advances) { android::AutoMutex _l(gMinikinLock); LayoutContext ctx; @@ -629,8 +621,8 @@ float Layout::measureText(const uint16_t* buf, size_t start, size_t count, size_ } float Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, LayoutContext* ctx, size_t dstStart, const FontCollection* collection, - Layout* layout, float* advances) { + bool isRtl, LayoutContext* ctx, size_t dstStart, + const std::shared_ptr& collection, Layout* layout, float* advances) { HyphenEdit hyphen = ctx->paint.hyphenEdit; float advance = 0; if (!isRtl) { @@ -668,8 +660,8 @@ float Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, } float Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, LayoutContext* ctx, size_t bufStart, const FontCollection* collection, - Layout* layout, float* advances) { + bool isRtl, LayoutContext* ctx, size_t bufStart, + const std::shared_ptr& collection, Layout* layout, float* advances) { LayoutCache& cache = LayoutEngine::getInstance().layoutCache; LayoutCacheKey key(collection, ctx->paint, ctx->style, buf, start, count, bufSize, isRtl); @@ -677,8 +669,8 @@ float Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size float advance; if (ctx->paint.skipCache()) { - Layout layoutForWord; - key.doLayout(&layoutForWord, ctx, collection); + Layout layoutForWord(collection); + key.doLayout(&layoutForWord, ctx); if (layout) { layout->appendLayout(&layoutForWord, bufStart, wordSpacing); } @@ -732,9 +724,6 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_buffer_t* buffer = LayoutEngine::getInstance().hbBuffer; vector items; mCollection->itemize(buf + start, count, ctx->style, &items); - if (isRtl) { - std::reverse(items.begin(), items.end()); - } vector features; // Disable default-on non-required ligature features if letter-spacing @@ -756,7 +745,9 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t float x = mAdvance; float y = 0; - for (size_t run_ix = 0; run_ix < items.size(); run_ix++) { + for (int run_ix = isRtl ? items.size() - 1 : 0; + isRtl ? run_ix >= 0 : run_ix < static_cast(items.size()); + isRtl ? --run_ix : ++run_ix) { FontCollection::Run &run = items[run_ix]; if (run.fakedFont.font == NULL) { ALOGE("no font for run starting u+%04x length %d", buf[run.start], run.end - run.start); @@ -967,7 +958,7 @@ size_t Layout::nGlyphs() const { return mGlyphs.size(); } -MinikinFont* Layout::getFont(int i) const { +const MinikinFont* Layout::getFont(int i) const { const LayoutGlyph& glyph = mGlyphs[i]; return mFaces[glyph.font_ix].font; } @@ -1000,7 +991,7 @@ void Layout::getAdvances(float* advances) { memcpy(advances, &mAdvances[0], mAdvances.size() * sizeof(float)); } -void Layout::getBounds(MinikinRect* bounds) { +void Layout::getBounds(MinikinRect* bounds) const { bounds->set(mBounds); } diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index c21e6384c3..3965cbd4c8 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -129,7 +129,7 @@ static bool isLineBreakingHyphen(uint16_t c) { // width buffer. // This method finds the candidate word breaks (using the ICU break iterator) and sends them // to addCandidate. -float LineBreaker::addStyleRun(MinikinPaint* paint, const FontCollection* typeface, +float LineBreaker::addStyleRun(MinikinPaint* paint, const std::shared_ptr& typeface, FontStyle style, size_t start, size_t end, bool isRtl) { float width = 0.0f; int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; diff --git a/engine/src/flutter/libs/minikin/MinikinFont.cpp b/engine/src/flutter/libs/minikin/MinikinFont.cpp index 8aee01de7e..6bf6a4ae3b 100644 --- a/engine/src/flutter/libs/minikin/MinikinFont.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFont.cpp @@ -16,10 +16,12 @@ #include #include "HbFontCache.h" +#include "MinikinInternal.h" namespace minikin { MinikinFont::~MinikinFont() { + android::AutoMutex _l(gMinikinLock); purgeHbFontLocked(this); } diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index a98fc19e4c..e766dce992 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -85,7 +85,7 @@ bool isEmojiBase(uint32_t c) { } } -hb_blob_t* getFontTable(MinikinFont* minikinFont, uint32_t tag) { +hb_blob_t* getFontTable(const MinikinFont* minikinFont, uint32_t tag) { assertMinikinLocked(); hb_font_t* font = getHbFontLocked(minikinFont); hb_face_t* face = hb_font_get_face(font); diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index 9557d827df..365f20cc0d 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -45,7 +45,7 @@ bool isEmojiBase(uint32_t c); // Returns true if c is emoji modifier. bool isEmojiModifier(uint32_t c); -hb_blob_t* getFontTable(MinikinFont* minikinFont, uint32_t tag); +hb_blob_t* getFontTable(const MinikinFont* minikinFont, uint32_t tag); // An RAII wrapper for hb_blob_t class HbBlob { diff --git a/engine/src/flutter/libs/minikin/MinikinRefCounted.cpp b/engine/src/flutter/libs/minikin/MinikinRefCounted.cpp deleted file mode 100644 index 6914a012f8..0000000000 --- a/engine/src/flutter/libs/minikin/MinikinRefCounted.cpp +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright (C) 2014 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. - */ - -// Base class for reference counted objects in Minikin - -#include "MinikinInternal.h" - -#include - -namespace minikin { - -void MinikinRefCounted::Ref() { - android::AutoMutex _l(gMinikinLock); - this->RefLocked(); -} - -void MinikinRefCounted::Unref() { - android::AutoMutex _l(gMinikinLock); - this->UnrefLocked(); -} - -} // namespace minikin diff --git a/engine/src/flutter/sample/MinikinSkia.cpp b/engine/src/flutter/sample/MinikinSkia.cpp index ec1e9da78c..1ba7cccb41 100644 --- a/engine/src/flutter/sample/MinikinSkia.cpp +++ b/engine/src/flutter/sample/MinikinSkia.cpp @@ -44,7 +44,8 @@ void MinikinFontSkia::GetBounds(MinikinRect* bounds, uint32_t glyph_id, bounds->mBottom = skBounds.fBottom; } -const void* MinikinFontSkia::GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) { +const void* MinikinFontSkia::GetTable(uint32_t tag, size_t* size, + MinikinDestroyFunc* destroy) const { // we don't have a buffer to the font data, copy to own buffer const size_t tableSize = mTypeface->getTableSize(tag); *size = tableSize; @@ -60,7 +61,7 @@ const void* MinikinFontSkia::GetTable(uint32_t tag, size_t* size, MinikinDestroy return buf; } -SkTypeface *MinikinFontSkia::GetSkTypeface() { +SkTypeface *MinikinFontSkia::GetSkTypeface() const { return mTypeface.get(); } diff --git a/engine/src/flutter/sample/MinikinSkia.h b/engine/src/flutter/sample/MinikinSkia.h index 8284f5d0f9..5ebf1b6161 100644 --- a/engine/src/flutter/sample/MinikinSkia.h +++ b/engine/src/flutter/sample/MinikinSkia.h @@ -25,12 +25,12 @@ public: void GetBounds(MinikinRect* bounds, uint32_t glyph_id, const MinikinPaint& paint) const; - const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy); const std::vector& GetAxes() const { return mAxes; } + const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) const; - SkTypeface *GetSkTypeface(); + SkTypeface *GetSkTypeface() const; private: sk_sp mTypeface; diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp index 1c9c322d23..3df0905003 100644 --- a/engine/src/flutter/sample/example.cpp +++ b/engine/src/flutter/sample/example.cpp @@ -33,7 +33,7 @@ using namespace minikin; FT_Library library; // TODO: this should not be a global FontCollection *makeFontCollection() { - vectortypefaces; + vector>typefaces; const char *fns[] = { "/system/fonts/Roboto-Regular.ttf", "/system/fonts/Roboto-Italic.ttf", @@ -55,17 +55,17 @@ FontCollection *makeFontCollection() { if (error != 0) { printf("error loading %s, %d\n", fn, error); } - MinikinFont *font = new MinikinFontFreeType(face); + std::shared_ptr font(new MinikinFontFreeType(face)); fonts.push_back(Font(font, FontStyle())); } - FontFamily *family = new FontFamily(std::move(fonts)); + std::shared_ptr family(new FontFamily(std::move(fonts))); typefaces.push_back(family); #if 1 const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; error = FT_New_Face(library, fn, 0, &face); - MinikinFont *font = new MinikinFontFreeType(face); - family = new FontFamily(std::vector({ Font(font, FontStyle()) })); + std::shared_ptr font(new MinikinFontFreeType(face)); + family.reset(new FontFamily(std::vector({ Font(font, FontStyle()) }))); typefaces.push_back(family); #endif @@ -77,11 +77,8 @@ int runMinikinTest() { if (error) { return -1; } - Layout::init(); - - FontCollection *collection = makeFontCollection(); - Layout layout; - layout.setFontCollection(collection); + std::shared_ptr collection(makeFontCollection()); + Layout layout(collection); const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87"; int bidiFlags = 0; FontStyle fontStyle; diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp index 6e6f868051..6fa788b9e7 100644 --- a/engine/src/flutter/sample/example_skia.cpp +++ b/engine/src/flutter/sample/example_skia.cpp @@ -42,7 +42,7 @@ namespace minikin { FT_Library library; // TODO: this should not be a global FontCollection *makeFontCollection() { - vectortypefaces; + vector> typefaces; const char *fns[] = { "/system/fonts/Roboto-Regular.ttf", "/system/fonts/Roboto-Italic.ttf", @@ -58,20 +58,19 @@ FontCollection *makeFontCollection() { for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { const char *fn = fns[i]; sk_sp skFace = SkTypeface::MakeFromFile(fn); - MinikinFont *font = new MinikinFontSkia(std::move(skFace)); + std::shared_ptr font(new MinikinFontSkia(std::move(skFace))); fonts.push_back(Font(font, FontStyle())); } - FontFamily *family = new FontFamily(std::move(fonts)); + std::shared_ptr family(new FontFamily(std::move(fonts))); typefaces.push_back(family); #if 1 const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; sk_sp skFace = SkTypeface::MakeFromFile(fn); - MinikinFont *font = new MinikinFontSkia(std::move(skFace)); - family = new FontFamily(std::vector({ Font(font, FontStyle()) })); + std::shared_ptr font(new MinikinFontSkia(std::move(skFace))); + family.reset(new FontFamily(std::vector({ Font(font, FontStyle()) }))); typefaces.push_back(family); #endif - return new FontCollection(typefaces); } @@ -87,7 +86,7 @@ void drawToSkia(SkCanvas *canvas, SkPaint *paint, Layout *layout, float x, float paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); for (size_t i = 0; i < nGlyphs; i++) { - MinikinFontSkia *mfs = static_cast(layout->getFont(i)); + const MinikinFontSkia *mfs = static_cast(layout->getFont(i)); skFace = mfs->GetSkTypeface(); glyphs[i] = layout->getGlyphId(i); pos[i].fX = x + layout->getX(i); @@ -110,11 +109,9 @@ int runMinikinTest() { if (error) { return -1; } - Layout::init(); - FontCollection *collection = makeFontCollection(); - Layout layout; - layout.setFontCollection(collection); + std::shared_ptr collection(makeFontCollection()); + Layout layout(collection); const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87"; int bidiFlags = 0; FontStyle fontStyle(7); diff --git a/engine/src/flutter/tests/perftests/FontCollection.cpp b/engine/src/flutter/tests/perftests/FontCollection.cpp index a54607d183..6f9d636ca3 100644 --- a/engine/src/flutter/tests/perftests/FontCollection.cpp +++ b/engine/src/flutter/tests/perftests/FontCollection.cpp @@ -15,7 +15,8 @@ */ #include -#include +#include + #include #include #include @@ -27,7 +28,7 @@ const char* SYSTEM_FONT_PATH = "/system/fonts/"; const char* SYSTEM_FONT_XML = "/system/etc/fonts.xml"; static void BM_FontCollection_hasVariationSelector(benchmark::State& state) { - MinikinAutoUnref collection( + std::shared_ptr collection( getFontCollection(SYSTEM_FONT_PATH, SYSTEM_FONT_XML)); uint32_t baseCp = state.range(0); @@ -63,7 +64,7 @@ struct ItemizeTestCases { }; static void BM_FontCollection_itemize(benchmark::State& state) { - MinikinAutoUnref collection( + std::shared_ptr collection( getFontCollection(SYSTEM_FONT_PATH, SYSTEM_FONT_XML)); size_t testIndex = state.range(0); diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 5c5a5d343c..aa142cccdc 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -16,6 +16,8 @@ #include +#include + #include "FontLanguageListCache.h" #include "FontLanguage.h" #include "FontTestUtils.h" @@ -50,7 +52,7 @@ const char kNoCmapFormat14Font[] = kTestFontDir "VarioationSelectorTest-Regular typedef ICUTestBase FontCollectionItemizeTest; // Utility function for calling itemize function. -void itemize(FontCollection* collection, const char* str, FontStyle style, +void itemize(const std::shared_ptr& collection, const char* str, FontStyle style, std::vector* result) { const size_t BUF_SIZE = 256; uint16_t buf[BUF_SIZE]; @@ -75,7 +77,7 @@ const FontLanguages& registerAndGetFontLanguages(const std::string& lang_string) } TEST_F(FontCollectionItemizeTest, itemize_latin) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; const FontStyle kRegularStyle = FontStyle(); @@ -83,7 +85,7 @@ TEST_F(FontCollectionItemizeTest, itemize_latin) { const FontStyle kBoldStyle = FontStyle(7, false); const FontStyle kBoldItalicStyle = FontStyle(7, true); - itemize(collection.get(), "'a' 'b' 'c' 'd' 'e'", kRegularStyle, &runs); + itemize(collection, "'a' 'b' 'c' 'd' 'e'", kRegularStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); @@ -91,7 +93,7 @@ TEST_F(FontCollectionItemizeTest, itemize_latin) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); - itemize(collection.get(), "'a' 'b' 'c' 'd' 'e'", kItalicStyle, &runs); + itemize(collection, "'a' 'b' 'c' 'd' 'e'", kItalicStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); @@ -99,7 +101,7 @@ TEST_F(FontCollectionItemizeTest, itemize_latin) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); - itemize(collection.get(), "'a' 'b' 'c' 'd' 'e'", kBoldStyle, &runs); + itemize(collection, "'a' 'b' 'c' 'd' 'e'", kBoldStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); @@ -107,7 +109,7 @@ TEST_F(FontCollectionItemizeTest, itemize_latin) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); - itemize(collection.get(), "'a' 'b' 'c' 'd' 'e'", kBoldItalicStyle, &runs); + itemize(collection, "'a' 'b' 'c' 'd' 'e'", kBoldItalicStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); @@ -117,7 +119,7 @@ TEST_F(FontCollectionItemizeTest, itemize_latin) { // Continue if the specific characters (e.g. hyphen, comma, etc.) is // followed. - itemize(collection.get(), "'a' ',' '-' 'd' '!'", kRegularStyle, &runs); + itemize(collection, "'a' ',' '-' 'd' '!'", kRegularStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); @@ -125,7 +127,7 @@ TEST_F(FontCollectionItemizeTest, itemize_latin) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); - itemize(collection.get(), "'a' ',' '-' 'd' '!'", kRegularStyle, &runs); + itemize(collection, "'a' ',' '-' 'd' '!'", kRegularStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); @@ -135,7 +137,7 @@ TEST_F(FontCollectionItemizeTest, itemize_latin) { // U+0301(COMBINING ACUTE ACCENT) must be in the same run with preceding // chars if the font supports it. - itemize(collection.get(), "'a' U+0301", kRegularStyle, &runs); + itemize(collection, "'a' U+0301", kRegularStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -145,10 +147,10 @@ TEST_F(FontCollectionItemizeTest, itemize_latin) { } TEST_F(FontCollectionItemizeTest, itemize_emoji) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; - itemize(collection.get(), "U+1F469 U+1F467", FontStyle(), &runs); + itemize(collection, "U+1F469 U+1F467", FontStyle(), &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(4, runs[0].end); @@ -158,7 +160,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emoji) { // U+20E3(COMBINING ENCLOSING KEYCAP) must be in the same run with preceding // character if the font supports. - itemize(collection.get(), "'0' U+20E3", FontStyle(), &runs); + itemize(collection, "'0' U+20E3", FontStyle(), &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -166,7 +168,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emoji) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); - itemize(collection.get(), "U+1F470 U+20E3", FontStyle(), &runs); + itemize(collection, "U+1F470 U+20E3", FontStyle(), &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(3, runs[0].end); @@ -174,7 +176,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emoji) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeBold()); EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); - itemize(collection.get(), "U+242EE U+1F470 U+20E3", FontStyle(), &runs); + itemize(collection, "U+242EE U+1F470 U+20E3", FontStyle(), &runs); ASSERT_EQ(2U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -190,7 +192,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emoji) { // Currently there is no fonts which has a glyph for 'a' + U+20E3, so they // are splitted into two. - itemize(collection.get(), "'a' U+20E3", FontStyle(), &runs); + itemize(collection, "'a' U+20E3", FontStyle(), &runs); ASSERT_EQ(2U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); @@ -206,7 +208,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emoji) { } TEST_F(FontCollectionItemizeTest, itemize_non_latin) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; FontStyle kJAStyle = FontStyle(FontStyle::registerLanguageList("ja_JP")); @@ -214,7 +216,7 @@ TEST_F(FontCollectionItemizeTest, itemize_non_latin) { FontStyle kZH_HansStyle = FontStyle(FontStyle::registerLanguageList("zh_Hans")); // All Japanese Hiragana characters. - itemize(collection.get(), "U+3042 U+3044 U+3046 U+3048 U+304A", kUSStyle, &runs); + itemize(collection, "U+3042 U+3044 U+3046 U+3048 U+304A", kUSStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); @@ -223,7 +225,7 @@ TEST_F(FontCollectionItemizeTest, itemize_non_latin) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); // All Korean Hangul characters. - itemize(collection.get(), "U+B300 U+D55C U+BBFC U+AD6D", kUSStyle, &runs); + itemize(collection, "U+B300 U+D55C U+BBFC U+AD6D", kUSStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(4, runs[0].end); @@ -233,7 +235,7 @@ TEST_F(FontCollectionItemizeTest, itemize_non_latin) { // All Han characters ja, zh-Hans font having. // Japanese font should be selected if the specified language is Japanese. - itemize(collection.get(), "U+81ED U+82B1 U+5FCD", kJAStyle, &runs); + itemize(collection, "U+81ED U+82B1 U+5FCD", kJAStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(3, runs[0].end); @@ -243,7 +245,7 @@ TEST_F(FontCollectionItemizeTest, itemize_non_latin) { // Simplified Chinese font should be selected if the specified language is Simplified // Chinese. - itemize(collection.get(), "U+81ED U+82B1 U+5FCD", kZH_HansStyle, &runs); + itemize(collection, "U+81ED U+82B1 U+5FCD", kZH_HansStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(3, runs[0].end); @@ -253,7 +255,7 @@ TEST_F(FontCollectionItemizeTest, itemize_non_latin) { // Fallbacks to other fonts if there is no glyph in the specified language's // font. There is no character U+4F60 in Japanese. - itemize(collection.get(), "U+81ED U+4F60 U+5FCD", kJAStyle, &runs); + itemize(collection, "U+81ED U+4F60 U+5FCD", kJAStyle, &runs); ASSERT_EQ(3U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); @@ -274,7 +276,7 @@ TEST_F(FontCollectionItemizeTest, itemize_non_latin) { EXPECT_FALSE(runs[2].fakedFont.fakery.isFakeItalic()); // Tone mark. - itemize(collection.get(), "U+4444 U+302D", FontStyle(), &runs); + itemize(collection, "U+4444 U+302D", FontStyle(), &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -285,7 +287,7 @@ TEST_F(FontCollectionItemizeTest, itemize_non_latin) { // Both zh-Hant and ja fonts support U+242EE, but zh-Hans doesn't. // Here, ja and zh-Hant font should have the same score but ja should be selected since it is // listed before zh-Hant. - itemize(collection.get(), "U+242EE", kZH_HansStyle, &runs); + itemize(collection, "U+242EE", kZH_HansStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -295,12 +297,12 @@ TEST_F(FontCollectionItemizeTest, itemize_non_latin) { } TEST_F(FontCollectionItemizeTest, itemize_mixed) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; FontStyle kUSStyle = FontStyle(FontStyle::registerLanguageList("en_US")); - itemize(collection.get(), "'a' U+4F60 'b' U+4F60 'c'", kUSStyle, &runs); + itemize(collection, "'a' U+4F60 'b' U+4F60 'c'", kUSStyle, &runs); ASSERT_EQ(5U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); @@ -334,7 +336,7 @@ TEST_F(FontCollectionItemizeTest, itemize_mixed) { } TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; // A glyph for U+4FAE is provided by both Japanese font and Simplified @@ -346,19 +348,19 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { // U+4FAE is available in both zh_Hans and ja font, but U+4FAE,U+FE00 is // only available in ja font. - itemize(collection.get(), "U+4FAE", kZH_HansStyle, &runs); + itemize(collection, "U+4FAE", kZH_HansStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); - itemize(collection.get(), "U+4FAE U+FE00", kZH_HansStyle, &runs); + itemize(collection, "U+4FAE U+FE00", kZH_HansStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kJAFont, getFontPath(runs[0])); - itemize(collection.get(), "U+4FAE U+4FAE U+FE00", kZH_HansStyle, &runs); + itemize(collection, "U+4FAE U+4FAE U+FE00", kZH_HansStyle, &runs); ASSERT_EQ(2U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); @@ -367,7 +369,7 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { EXPECT_EQ(3, runs[1].end); EXPECT_EQ(kJAFont, getFontPath(runs[1])); - itemize(collection.get(), "U+4FAE U+4FAE U+FE00 U+4FAE", kZH_HansStyle, &runs); + itemize(collection, "U+4FAE U+4FAE U+FE00 U+4FAE", kZH_HansStyle, &runs); ASSERT_EQ(3U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); @@ -380,14 +382,14 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { EXPECT_EQ(kZH_HansFont, getFontPath(runs[2])); // Validation selector after validation selector. - itemize(collection.get(), "U+4FAE U+FE00 U+FE00", kZH_HansStyle, &runs); + itemize(collection, "U+4FAE U+FE00 U+FE00", kZH_HansStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(3, runs[0].end); EXPECT_EQ(kJAFont, getFontPath(runs[1])); // No font supports U+242EE U+FE0E. - itemize(collection.get(), "U+4FAE U+FE0E", kZH_HansStyle, &runs); + itemize(collection, "U+4FAE U+FE0E", kZH_HansStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -396,19 +398,19 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { // Surrogate pairs handling. // U+242EE is available in ja font and zh_Hant font. // U+242EE U+FE00 is available only in ja font. - itemize(collection.get(), "U+242EE", kZH_HantStyle, &runs); + itemize(collection, "U+242EE", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); - itemize(collection.get(), "U+242EE U+FE00", kZH_HantStyle, &runs); + itemize(collection, "U+242EE U+FE00", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(3, runs[0].end); EXPECT_EQ(kJAFont, getFontPath(runs[0])); - itemize(collection.get(), "U+242EE U+242EE U+FE00", kZH_HantStyle, &runs); + itemize(collection, "U+242EE U+242EE U+FE00", kZH_HantStyle, &runs); ASSERT_EQ(2U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -417,7 +419,7 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { EXPECT_EQ(5, runs[1].end); EXPECT_EQ(kJAFont, getFontPath(runs[1])); - itemize(collection.get(), "U+242EE U+242EE U+FE00 U+242EE", kZH_HantStyle, &runs); + itemize(collection, "U+242EE U+242EE U+FE00 U+242EE", kZH_HantStyle, &runs); ASSERT_EQ(3U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -430,27 +432,27 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { EXPECT_EQ(kZH_HantFont, getFontPath(runs[2])); // Validation selector after validation selector. - itemize(collection.get(), "U+242EE U+FE00 U+FE00", kZH_HansStyle, &runs); + itemize(collection, "U+242EE U+FE00 U+FE00", kZH_HansStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(4, runs[0].end); EXPECT_EQ(kJAFont, getFontPath(runs[0])); // No font supports U+242EE U+FE0E - itemize(collection.get(), "U+242EE U+FE0E", kZH_HantStyle, &runs); + itemize(collection, "U+242EE U+FE0E", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(3, runs[0].end); EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); // Isolated variation selector supplement. - itemize(collection.get(), "U+FE00", FontStyle(), &runs); + itemize(collection, "U+FE00", FontStyle(), &runs); 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 == getFontPath(runs[0])); - itemize(collection.get(), "U+FE00", kZH_HantStyle, &runs); + itemize(collection, "U+FE00", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); @@ -458,14 +460,14 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { // 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. - itemize(collection.get(), "U+203C U+FE0F", kZH_HantStyle, &runs); + itemize(collection, "U+203C U+FE0F", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kEmojiFont, getFontPath(runs[0])); // First font family (Regular.ttf) supports U+203C U+FE0E. - itemize(collection.get(), "U+203C U+FE0E", kZH_HantStyle, &runs); + itemize(collection, "U+203C U+FE0E", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -473,7 +475,7 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelector) { } TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; // A glyph for U+845B is provided by both Japanese font and Simplified @@ -485,19 +487,19 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { // U+845B is available in both zh_Hans and ja font, but U+845B,U+E0100 is // only available in ja font. - itemize(collection.get(), "U+845B", kZH_HansStyle, &runs); + itemize(collection, "U+845B", kZH_HansStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); EXPECT_EQ(kZH_HansFont, getFontPath(runs[0])); - itemize(collection.get(), "U+845B U+E0100", kZH_HansStyle, &runs); + itemize(collection, "U+845B U+E0100", kZH_HansStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(3, runs[0].end); EXPECT_EQ(kJAFont, getFontPath(runs[0])); - itemize(collection.get(), "U+845B U+845B U+E0100", kZH_HansStyle, &runs); + itemize(collection, "U+845B U+845B U+E0100", kZH_HansStyle, &runs); ASSERT_EQ(2U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); @@ -506,7 +508,7 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { EXPECT_EQ(4, runs[1].end); EXPECT_EQ(kJAFont, getFontPath(runs[1])); - itemize(collection.get(), "U+845B U+845B U+E0100 U+845B", kZH_HansStyle, &runs); + itemize(collection, "U+845B U+845B U+E0100 U+845B", kZH_HansStyle, &runs); ASSERT_EQ(3U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); @@ -519,14 +521,14 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { EXPECT_EQ(kZH_HansFont, getFontPath(runs[2])); // Validation selector after validation selector. - itemize(collection.get(), "U+845B U+E0100 U+E0100", kZH_HansStyle, &runs); + itemize(collection, "U+845B U+E0100 U+E0100", kZH_HansStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); EXPECT_EQ(kJAFont, getFontPath(runs[0])); // No font supports U+845B U+E01E0. - itemize(collection.get(), "U+845B U+E01E0", kZH_HansStyle, &runs); + itemize(collection, "U+845B U+E01E0", kZH_HansStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(3, runs[0].end); @@ -536,19 +538,19 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { // Surrogate pairs handling. // U+242EE is available in ja font and zh_Hant font. // U+242EE U+E0100 is available only in ja font. - itemize(collection.get(), "U+242EE", kZH_HantStyle, &runs); + itemize(collection, "U+242EE", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); - itemize(collection.get(), "U+242EE U+E0101", kZH_HantStyle, &runs); + itemize(collection, "U+242EE U+E0101", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(4, runs[0].end); EXPECT_EQ(kJAFont, getFontPath(runs[0])); - itemize(collection.get(), "U+242EE U+242EE U+E0101", kZH_HantStyle, &runs); + itemize(collection, "U+242EE U+242EE U+E0101", kZH_HantStyle, &runs); ASSERT_EQ(2U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -557,7 +559,7 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { EXPECT_EQ(6, runs[1].end); EXPECT_EQ(kJAFont, getFontPath(runs[1])); - itemize(collection.get(), "U+242EE U+242EE U+E0101 U+242EE", kZH_HantStyle, &runs); + itemize(collection, "U+242EE U+242EE U+E0101 U+242EE", kZH_HantStyle, &runs); ASSERT_EQ(3U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -570,27 +572,27 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { EXPECT_EQ(kZH_HantFont, getFontPath(runs[2])); // Validation selector after validation selector. - itemize(collection.get(), "U+242EE U+E0100 U+E0100", kZH_HantStyle, &runs); + itemize(collection, "U+242EE U+E0100 U+E0100", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(6, runs[0].end); EXPECT_EQ(kJAFont, getFontPath(runs[0])); // No font supports U+242EE U+E01E0. - itemize(collection.get(), "U+242EE U+E01E0", kZH_HantStyle, &runs); + itemize(collection, "U+242EE U+E01E0", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(4, runs[0].end); EXPECT_EQ(kZH_HantFont, getFontPath(runs[0])); // Isolated variation selector supplement. - itemize(collection.get(), "U+E0100", FontStyle(), &runs); + itemize(collection, "U+E0100", FontStyle(), &runs); 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 == getFontPath(runs[0])); - itemize(collection.get(), "U+E0100", kZH_HantStyle, &runs); + itemize(collection, "U+E0100", kZH_HantStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -598,31 +600,31 @@ TEST_F(FontCollectionItemizeTest, itemize_variationSelectorSupplement) { } TEST_F(FontCollectionItemizeTest, itemize_no_crash) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; // Broken Surrogate pairs. Check only not crashing. - itemize(collection.get(), "'a' U+D83D 'a'", FontStyle(), &runs); - itemize(collection.get(), "'a' U+DC69 'a'", FontStyle(), &runs); - itemize(collection.get(), "'a' U+D83D U+D83D 'a'", FontStyle(), &runs); - itemize(collection.get(), "'a' U+DC69 U+DC69 'a'", FontStyle(), &runs); + itemize(collection, "'a' U+D83D 'a'", FontStyle(), &runs); + itemize(collection, "'a' U+DC69 'a'", FontStyle(), &runs); + itemize(collection, "'a' U+D83D U+D83D 'a'", FontStyle(), &runs); + itemize(collection, "'a' U+DC69 U+DC69 'a'", FontStyle(), &runs); // Isolated variation selector. Check only not crashing. - itemize(collection.get(), "U+FE00 U+FE00", FontStyle(), &runs); - itemize(collection.get(), "U+E0100 U+E0100", FontStyle(), &runs); - itemize(collection.get(), "U+FE00 U+E0100", FontStyle(), &runs); - itemize(collection.get(), "U+E0100 U+FE00", FontStyle(), &runs); + itemize(collection, "U+FE00 U+FE00", FontStyle(), &runs); + itemize(collection, "U+E0100 U+E0100", FontStyle(), &runs); + itemize(collection, "U+FE00 U+E0100", FontStyle(), &runs); + itemize(collection, "U+E0100 U+FE00", FontStyle(), &runs); // Tone mark only. Check only not crashing. - itemize(collection.get(), "U+302D", FontStyle(), &runs); - itemize(collection.get(), "U+302D U+302D", FontStyle(), &runs); + itemize(collection, "U+302D", FontStyle(), &runs); + itemize(collection, "U+302D U+302D", FontStyle(), &runs); // Tone mark and variation selector mixed. Check only not crashing. - itemize(collection.get(), "U+FE00 U+302D U+E0100", FontStyle(), &runs); + itemize(collection, "U+FE00 U+302D U+E0100", FontStyle(), &runs); } TEST_F(FontCollectionItemizeTest, itemize_fakery) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kItemizeFontXml)); std::vector runs; FontStyle kJABoldStyle = FontStyle(FontStyle::registerLanguageList("ja_JP"), 0, 7, false); @@ -634,7 +636,7 @@ TEST_F(FontCollectionItemizeTest, itemize_fakery) { // the differences between desired and actual font style. // All Japanese Hiragana characters. - itemize(collection.get(), "U+3042 U+3044 U+3046 U+3048 U+304A", kJABoldStyle, &runs); + itemize(collection, "U+3042 U+3044 U+3046 U+3048 U+304A", kJABoldStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); @@ -643,7 +645,7 @@ TEST_F(FontCollectionItemizeTest, itemize_fakery) { EXPECT_FALSE(runs[0].fakedFont.fakery.isFakeItalic()); // All Japanese Hiragana characters. - itemize(collection.get(), "U+3042 U+3044 U+3046 U+3048 U+304A", kJAItalicStyle, &runs); + itemize(collection, "U+3042 U+3044 U+3046 U+3048 U+304A", kJAItalicStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); @@ -652,7 +654,7 @@ TEST_F(FontCollectionItemizeTest, itemize_fakery) { EXPECT_TRUE(runs[0].fakedFont.fakery.isFakeItalic()); // All Japanese Hiragana characters. - itemize(collection.get(), "U+3042 U+3044 U+3046 U+3048 U+304A", kJABoldItalicStyle, &runs); + itemize(collection, "U+3042 U+3044 U+3046 U+3048 U+304A", kJABoldItalicStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); @@ -667,29 +669,26 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { // point. const std::string kVSTestFont = kTestFontDir "VarioationSelectorTest-Regular.ttf"; - std::vector families; - MinikinAutoUnref font(new MinikinFontForTest(kLatinFont)); - FontFamily* family1 = new FontFamily(VARIANT_DEFAULT, - std::vector{ Font(font.get(), FontStyle()) }); + std::vector> families; + std::shared_ptr font(new MinikinFontForTest(kLatinFont)); + std::shared_ptr family1(new FontFamily(VARIANT_DEFAULT, + std::vector{ Font(font, FontStyle()) })); families.push_back(family1); - MinikinAutoUnref font2(new MinikinFontForTest(kVSTestFont)); - FontFamily* family2 = new FontFamily(VARIANT_DEFAULT, - std::vector{ Font(font2.get(), FontStyle()) }); + std::shared_ptr font2(new MinikinFontForTest(kVSTestFont)); + std::shared_ptr family2(new FontFamily(VARIANT_DEFAULT, + std::vector{ Font(font2, FontStyle()) })); families.push_back(family2); - FontCollection collection(families); + std::shared_ptr collection(new FontCollection(families)); std::vector runs; - itemize(&collection, "U+717D U+FE02", FontStyle(), &runs); + itemize(collection, "U+717D U+FE02", FontStyle(), &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kVSTestFont, getFontPath(runs[0])); - - family1->Unref(); - family2->Unref(); } TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { @@ -808,14 +807,14 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { SCOPED_TRACE("Test of user preferred languages: \"" + testCase.userPreferredLanguages + "\" with font languages: " + fontLanguagesStr); - std::vector families; + std::vector> families; // Prepare first font which doesn't supports U+9AA8 - MinikinAutoUnref firstFamilyMinikinFont( + std::shared_ptr firstFamilyMinikinFont( new MinikinFontForTest(kNoGlyphFont)); - FontFamily* firstFamily = new FontFamily( + std::shared_ptr firstFamily(new FontFamily( FontStyle::registerLanguageList("und"), 0 /* variant */, - std::vector({ Font(firstFamilyMinikinFont.get(), FontStyle()) })); + std::vector({ Font(firstFamilyMinikinFont, FontStyle()) }))); families.push_back(firstFamily); // Prepare font families @@ -824,23 +823,19 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageScore) { std::unordered_map fontLangIdxMap; for (size_t i = 0; i < testCase.fontLanguages.size(); ++i) { - MinikinAutoUnref minikin_font(new MinikinFontForTest(kJAFont)); - FontFamily* family = new FontFamily( + std::shared_ptr minikin_font(new MinikinFontForTest(kJAFont)); + std::shared_ptr family(new FontFamily( FontStyle::registerLanguageList(testCase.fontLanguages[i]), 0 /* variant */, - std::vector({ Font(minikin_font.get(), FontStyle()) })); + std::vector({ Font(minikin_font, FontStyle()) }))); families.push_back(family); fontLangIdxMap.insert(std::make_pair(minikin_font.get(), i)); } - MinikinAutoUnref collection(new FontCollection(families)); - for (auto family : families) { - family->Unref(); - } - + std::shared_ptr collection(new FontCollection(families)); // Do itemize const FontStyle style = FontStyle( FontStyle::registerLanguageList(testCase.userPreferredLanguages)); std::vector runs; - itemize(collection.get(), "U+9AA8", style, &runs); + itemize(collection, "U+9AA8", style, &runs); ASSERT_EQ(1U, runs.size()); ASSERT_NE(nullptr, runs[0].fakedFont.font); @@ -1146,7 +1141,7 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageAndCoverage) { { "U+1F469", "zh-Hant,ja-Jpan,zh-Hans", kEmojiFont }, }; - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kItemizeFontXml)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kItemizeFontXml)); for (auto testCase : testCases) { SCOPED_TRACE("Test for \"" + testCase.testString + "\" with languages " + @@ -1155,21 +1150,21 @@ TEST_F(FontCollectionItemizeTest, itemize_LanguageAndCoverage) { std::vector runs; const FontStyle style = FontStyle(FontStyle::registerLanguageList(testCase.requestedLanguages)); - itemize(collection.get(), testCase.testString.c_str(), style, &runs); + itemize(collection, testCase.testString.c_str(), style, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(testCase.expectedFont, getFontPath(runs[0])); } } TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); std::vector runs; const FontStyle kDefaultFontStyle; // U+00A9 is a text default emoji which is only available in TextEmojiFont.ttf. // TextEmojiFont.ttf should be selected. - itemize(collection.get(), "U+00A9 U+FE0E", kDefaultFontStyle, &runs); + itemize(collection, "U+00A9 U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1177,7 +1172,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { // U+00A9 is a text default emoji which is only available in ColorEmojiFont.ttf. // ColorEmojiFont.ttf should be selected. - itemize(collection.get(), "U+00AE U+FE0E", kDefaultFontStyle, &runs); + itemize(collection, "U+00AE U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1186,7 +1181,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { // U+203C is a text default emoji which is available in both TextEmojiFont.ttf and // ColorEmojiFont.ttf. TextEmojiFont.ttf should be selected. - itemize(collection.get(), "U+203C U+FE0E", kDefaultFontStyle, &runs); + itemize(collection, "U+203C U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1194,7 +1189,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { // U+2049 is a text default emoji which is not available either TextEmojiFont.ttf or // ColorEmojiFont.ttf. No font should be selected. - itemize(collection.get(), "U+2049 U+FE0E", kDefaultFontStyle, &runs); + itemize(collection, "U+2049 U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1202,7 +1197,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { // U+231A is a emoji default emoji which is available only in TextEmojifFont. // TextEmojiFont.ttf sohuld be selected. - itemize(collection.get(), "U+231A U+FE0E", kDefaultFontStyle, &runs); + itemize(collection, "U+231A U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1210,7 +1205,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { // U+231B is a emoji default emoji which is available only in ColorEmojiFont.ttf. // ColorEmojiFont.ttf should be selected. - itemize(collection.get(), "U+231B U+FE0E", kDefaultFontStyle, &runs); + itemize(collection, "U+231B U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1220,7 +1215,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { // U+23E9 is a emoji default emoji which is available in both TextEmojiFont.ttf and // ColorEmojiFont.ttf. TextEmojiFont.ttf should be selected even if U+23E9 is emoji default // emoji since U+FE0E is appended. - itemize(collection.get(), "U+23E9 U+FE0E", kDefaultFontStyle, &runs); + itemize(collection, "U+23E9 U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1228,7 +1223,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { // U+23EA is a emoji default emoji but which is not available in either TextEmojiFont.ttf or // ColorEmojiFont.ttf. No font should be selected. - itemize(collection.get(), "U+23EA U+FE0E", kDefaultFontStyle, &runs); + itemize(collection, "U+23EA U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1236,7 +1231,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { // U+26FA U+FE0E is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. - itemize(collection.get(), "U+26FA U+FE0E", kDefaultFontStyle, &runs); + itemize(collection, "U+26FA U+FE0E", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1244,14 +1239,14 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0E) { } TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); std::vector runs; const FontStyle kDefaultFontStyle; // U+00A9 is a text default emoji which is available only in TextEmojiFont.ttf. // TextEmojiFont.ttf shoudl be selected. - itemize(collection.get(), "U+00A9 U+FE0F", kDefaultFontStyle, &runs); + itemize(collection, "U+00A9 U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1260,7 +1255,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { // U+00AE is a text default emoji which is available only in ColorEmojiFont.ttf. // ColorEmojiFont.ttf should be selected. - itemize(collection.get(), "U+00AE U+FE0F", kDefaultFontStyle, &runs); + itemize(collection, "U+00AE U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1269,7 +1264,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { // U+203C is a text default emoji which is available in both TextEmojiFont.ttf and // ColorEmojiFont.ttf. ColorEmojiFont.ttf should be selected even if U+203C is a text default // emoji since U+FF0F is appended. - itemize(collection.get(), "U+203C U+FE0F", kDefaultFontStyle, &runs); + itemize(collection, "U+203C U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1277,7 +1272,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { // U+2049 is a text default emoji which is not available in either TextEmojiFont.ttf or // ColorEmojiFont.ttf. No font should be selected. - itemize(collection.get(), "U+2049 U+FE0F", kDefaultFontStyle, &runs); + itemize(collection, "U+2049 U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1285,7 +1280,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { // U+231A is a emoji default emoji which is available only in TextEmojiFont.ttf. // TextEmojiFont.ttf should be selected. - itemize(collection.get(), "U+231A U+FE0F", kDefaultFontStyle, &runs); + itemize(collection, "U+231A U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1294,7 +1289,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { // U+231B is a emoji default emoji which is available only in ColorEmojiFont.ttf. // ColorEmojiFont.ttf should be selected. - itemize(collection.get(), "U+231B U+FE0F", kDefaultFontStyle, &runs); + itemize(collection, "U+231B U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1302,7 +1297,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { // U+23E9 is a emoji default emoji which is available in both TextEmojiFont.ttf and // ColorEmojiFont.ttf. ColorEmojiFont.ttf should be selected. - itemize(collection.get(), "U+23E9 U+FE0F", kDefaultFontStyle, &runs); + itemize(collection, "U+23E9 U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1310,7 +1305,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { // U+23EA is a emoji default emoji which is not available in either TextEmojiFont.ttf or // ColorEmojiFont.ttf. No font should be selected. - itemize(collection.get(), "U+23EA U+FE0F", kDefaultFontStyle, &runs); + itemize(collection, "U+23EA U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1318,7 +1313,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { // U+26F9 U+FE0F is specified but ColorTextMixedEmojiFont has a variation sequence U+26F9 U+FE0F // in its cmap, so ColorTextMixedEmojiFont should be selected instaed of ColorEmojiFont. - itemize(collection.get(), "U+26F9 U+FE0F", kDefaultFontStyle, &runs); + itemize(collection, "U+26F9 U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1326,27 +1321,27 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_withFE0F) { } TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_with_skinTone) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); std::vector runs; const FontStyle kDefaultFontStyle; // TextEmoji font is selected since it is listed before ColorEmoji font. - itemize(collection.get(), "U+261D", kDefaultFontStyle, &runs); + itemize(collection, "U+261D", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(1, runs[0].end); EXPECT_EQ(kTextEmojiFont, getFontPath(runs[0])); // If skin tone is specified, it should be colored. - itemize(collection.get(), "U+261D U+1F3FD", kDefaultFontStyle, &runs); + itemize(collection, "U+261D U+1F3FD", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(3, runs[0].end); EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); // Still color font is selected if an emoji variation selector is specified. - itemize(collection.get(), "U+261D U+FE0F U+1F3FD", kDefaultFontStyle, &runs); + itemize(collection, "U+261D U+FE0F U+1F3FD", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(4, runs[0].end); @@ -1354,7 +1349,7 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_with_skinTone) { // Text font should be selected if a text variation selector is specified and skin tone is // rendered by itself. - itemize(collection.get(), "U+261D U+FE0E U+1F3FD", kDefaultFontStyle, &runs); + itemize(collection, "U+261D U+FE0E U+1F3FD", kDefaultFontStyle, &runs); ASSERT_EQ(2U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); @@ -1365,19 +1360,19 @@ TEST_F(FontCollectionItemizeTest, itemize_emojiSelection_with_skinTone) { } TEST_F(FontCollectionItemizeTest, itemize_PrivateUseArea) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); std::vector runs; const FontStyle kDefaultFontStyle; // Should not set nullptr to the result run. (Issue 26808815) - itemize(collection.get(), "U+FEE10", kDefaultFontStyle, &runs); + itemize(collection, "U+FEE10", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(2, runs[0].end); EXPECT_EQ(kNoGlyphFont, getFontPath(runs[0])); - itemize(collection.get(), "U+FEE40 U+FE4C5", kDefaultFontStyle, &runs); + itemize(collection, "U+FEE40 U+FE4C5", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(4, runs[0].end); @@ -1385,24 +1380,24 @@ TEST_F(FontCollectionItemizeTest, itemize_PrivateUseArea) { } TEST_F(FontCollectionItemizeTest, itemize_genderBalancedEmoji) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); std::vector runs; const FontStyle kDefaultFontStyle; - itemize(collection.get(), "U+1F469 U+200D U+1F373", kDefaultFontStyle, &runs); + itemize(collection, "U+1F469 U+200D U+1F373", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); - itemize(collection.get(), "U+1F469 U+200D U+2695 U+FE0F", kDefaultFontStyle, &runs); + itemize(collection, "U+1F469 U+200D U+2695 U+FE0F", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(5, runs[0].end); EXPECT_EQ(kColorEmojiFont, getFontPath(runs[0])); - itemize(collection.get(), "U+1F469 U+200D U+2695", kDefaultFontStyle, &runs); + itemize(collection, "U+1F469 U+200D U+2695", kDefaultFontStyle, &runs); ASSERT_EQ(1U, runs.size()); EXPECT_EQ(0, runs[0].start); EXPECT_EQ(4, runs[0].end); @@ -1413,32 +1408,32 @@ TEST_F(FontCollectionItemizeTest, itemize_genderBalancedEmoji) { TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS) { const FontStyle kDefaultFontStyle; - MinikinAutoUnref dummyFont(new MinikinFontForTest(kNoGlyphFont)); - MinikinAutoUnref fontA(new MinikinFontForTest(kZH_HansFont)); - MinikinAutoUnref fontB(new MinikinFontForTest(kZH_HansFont)); + std::shared_ptr dummyFont(new MinikinFontForTest(kNoGlyphFont)); + std::shared_ptr fontA(new MinikinFontForTest(kZH_HansFont)); + std::shared_ptr fontB(new MinikinFontForTest(kZH_HansFont)); - MinikinAutoUnref dummyFamily(new FontFamily( - std::vector({ Font(dummyFont.get(), FontStyle()) }))); - MinikinAutoUnref familyA(new FontFamily( - std::vector({ Font(fontA.get(), FontStyle()) }))); - MinikinAutoUnref familyB(new FontFamily( - std::vector({ Font(fontB.get(), FontStyle()) }))); + std::shared_ptr dummyFamily(new FontFamily( + std::vector({ Font(dummyFont, FontStyle()) }))); + std::shared_ptr familyA(new FontFamily( + std::vector({ Font(fontA, FontStyle()) }))); + std::shared_ptr familyB(new FontFamily( + std::vector({ Font(fontB, FontStyle()) }))); - std::vector families = - { dummyFamily.get(), familyA.get(), familyB.get() }; - std::vector reversedFamilies = - { dummyFamily.get(), familyB.get(), familyA.get() }; + std::vector> families = + { dummyFamily, familyA, familyB }; + std::vector> reversedFamilies = + { dummyFamily, familyB, familyA }; - MinikinAutoUnref collection(new FontCollection(families)); - MinikinAutoUnref reversedCollection(new FontCollection(reversedFamilies)); + std::shared_ptr collection(new FontCollection(families)); + std::shared_ptr reversedCollection(new FontCollection(reversedFamilies)); // Both fontA/fontB support U+35A8 but don't support U+35A8 U+E0100. The first font should be // selected. std::vector runs; - itemize(collection.get(), "U+35A8 U+E0100", kDefaultFontStyle, &runs); + itemize(collection, "U+35A8 U+E0100", kDefaultFontStyle, &runs); EXPECT_EQ(fontA.get(), runs[0].fakedFont.font); - itemize(reversedCollection.get(), "U+35A8 U+E0100", kDefaultFontStyle, &runs); + itemize(reversedCollection, "U+35A8 U+E0100", kDefaultFontStyle, &runs); EXPECT_EQ(fontB.get(), runs[0].fakedFont.font); } @@ -1446,34 +1441,34 @@ TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS) { TEST_F(FontCollectionItemizeTest, itemizeShouldKeepOrderForVS2) { const FontStyle kDefaultFontStyle; - MinikinAutoUnref dummyFont(new MinikinFontForTest(kNoGlyphFont)); - MinikinAutoUnref hasCmapFormat14Font( + std::shared_ptr dummyFont(new MinikinFontForTest(kNoGlyphFont)); + std::shared_ptr hasCmapFormat14Font( new MinikinFontForTest(kHasCmapFormat14Font)); - MinikinAutoUnref noCmapFormat14Font( + std::shared_ptr noCmapFormat14Font( new MinikinFontForTest(kNoCmapFormat14Font)); - MinikinAutoUnref dummyFamily(new FontFamily( - std::vector({ Font(dummyFont.get(), FontStyle()) }))); - MinikinAutoUnref hasCmapFormat14Family(new FontFamily( - std::vector({ Font(hasCmapFormat14Font.get(), FontStyle()) }))); - MinikinAutoUnref noCmapFormat14Family(new FontFamily( - std::vector({ Font(noCmapFormat14Font.get(), FontStyle()) }))); + std::shared_ptr dummyFamily(new FontFamily( + std::vector({ Font(dummyFont, FontStyle()) }))); + std::shared_ptr hasCmapFormat14Family(new FontFamily( + std::vector({ Font(hasCmapFormat14Font, FontStyle()) }))); + std::shared_ptr noCmapFormat14Family(new FontFamily( + std::vector({ Font(noCmapFormat14Font, FontStyle()) }))); - std::vector families = - { dummyFamily.get(), hasCmapFormat14Family.get(), noCmapFormat14Family.get() }; - std::vector reversedFamilies = - { dummyFamily.get(), noCmapFormat14Family.get(), hasCmapFormat14Family.get() }; + std::vector> families = + { dummyFamily, hasCmapFormat14Family, noCmapFormat14Family }; + std::vector> reversedFamilies = + { dummyFamily, noCmapFormat14Family, hasCmapFormat14Family }; - MinikinAutoUnref collection(new FontCollection(families)); - MinikinAutoUnref reversedCollection(new FontCollection(reversedFamilies)); + std::shared_ptr collection(new FontCollection(families)); + std::shared_ptr reversedCollection(new FontCollection(reversedFamilies)); // Both hasCmapFormat14Font/noCmapFormat14Font support U+5380 but don't support U+5380 U+E0100. // The first font should be selected. std::vector runs; - itemize(collection.get(), "U+5380 U+E0100", kDefaultFontStyle, &runs); + itemize(collection, "U+5380 U+E0100", kDefaultFontStyle, &runs); EXPECT_EQ(hasCmapFormat14Font.get(), runs[0].fakedFont.font); - itemize(reversedCollection.get(), "U+5380 U+E0100", kDefaultFontStyle, &runs); + itemize(reversedCollection, "U+5380 U+E0100", kDefaultFontStyle, &runs); EXPECT_EQ(noCmapFormat14Font.get(), runs[0].fakedFont.font); } diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index 68fe582aa3..100e206975 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -57,11 +57,11 @@ void expectVSGlyphs(const FontCollection* fc, uint32_t codepoint, const std::set } TEST(FontCollectionTest, hasVariationSelectorTest) { - MinikinAutoUnref font(new MinikinFontForTest(kVsTestFont)); - MinikinAutoUnref family(new FontFamily( - std::vector({ Font(font.get(), FontStyle()) }))); - std::vector families({family.get()}); - MinikinAutoUnref fc(new FontCollection(families)); + std::shared_ptr font(new MinikinFontForTest(kVsTestFont)); + std::shared_ptr family(new FontFamily( + std::vector({ Font(font, FontStyle()) }))); + std::vector> families({ family }); + std::shared_ptr fc(new FontCollection(families)); EXPECT_FALSE(fc->hasVariationSelector(0x82A6, 0)); expectVSGlyphs(fc.get(), 0x82A6, std::set({0xFE00, 0xE0100, 0xE0101, 0xE0102})); @@ -79,7 +79,7 @@ TEST(FontCollectionTest, hasVariationSelectorTest) { const char kEmojiXmlFile[] = kTestFontDir "emoji.xml"; TEST(FontCollectionTest, hasVariationSelectorTest_emoji) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); // Both text/color font have cmap format 14 subtable entry for VS15/VS16 respectively. EXPECT_TRUE(collection->hasVariationSelector(0x2623, 0xFE0E)); @@ -109,7 +109,7 @@ TEST(FontCollectionTest, hasVariationSelectorTest_emoji) { } TEST(FontCollectionTest, newEmojiTest) { - MinikinAutoUnref collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); + std::shared_ptr collection(getFontCollection(kTestFontDir, kEmojiXmlFile)); // U+2695, U+2640, U+2642 are not in emoji catrgory in Unicode 9 but they are now in emoji // category. Should return true even if U+FE0E was appended. @@ -126,17 +126,17 @@ TEST(FontCollectionTest, createWithVariations) { const char kMultiAxisFont[] = kTestFontDir "/MultiAxis.ttf"; const char kNoAxisFont[] = kTestFontDir "/Regular.ttf"; - MinikinAutoUnref multiAxisFont(new MinikinFontForTest(kMultiAxisFont)); - MinikinAutoUnref multiAxisFamily(new FontFamily( - std::vector({ Font(multiAxisFont.get(), FontStyle()) }))); - std::vector multiAxisFamilies({multiAxisFamily.get()}); - MinikinAutoUnref multiAxisFc(new FontCollection(multiAxisFamilies)); + std::shared_ptr multiAxisFont(new MinikinFontForTest(kMultiAxisFont)); + std::shared_ptr multiAxisFamily(new FontFamily( + std::vector({ Font(multiAxisFont, FontStyle()) }))); + std::vector> multiAxisFamilies({multiAxisFamily}); + std::shared_ptr multiAxisFc(new FontCollection(multiAxisFamilies)); - MinikinAutoUnref noAxisFont(new MinikinFontForTest(kNoAxisFont)); - MinikinAutoUnref noAxisFamily(new FontFamily( - std::vector({ Font(noAxisFont.get(), FontStyle()) }))); - std::vector noAxisFamilies({noAxisFamily.get()}); - MinikinAutoUnref noAxisFc(new FontCollection(noAxisFamilies)); + std::shared_ptr noAxisFont(new MinikinFontForTest(kNoAxisFont)); + std::shared_ptr noAxisFamily(new FontFamily( + std::vector({ Font(noAxisFont, FontStyle()) }))); + std::vector> noAxisFamilies({noAxisFamily}); + std::shared_ptr noAxisFc(new FontCollection(noAxisFamilies)); { // Do not ceate new instance if none of variations are specified. @@ -150,7 +150,7 @@ TEST(FontCollectionTest, createWithVariations) { std::vector variations = { { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f } }; - MinikinAutoUnref newFc( + std::shared_ptr newFc( multiAxisFc->createCollectionWithVariation(variations)); EXPECT_NE(nullptr, newFc.get()); EXPECT_NE(multiAxisFc.get(), newFc.get()); @@ -163,7 +163,7 @@ TEST(FontCollectionTest, createWithVariations) { { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, { MinikinFont::MakeTag('w', 'g', 'h', 't'), 1.0f } }; - MinikinAutoUnref newFc( + std::shared_ptr newFc( multiAxisFc->createCollectionWithVariation(variations)); EXPECT_NE(nullptr, newFc.get()); EXPECT_NE(multiAxisFc.get(), newFc.get()); @@ -184,7 +184,7 @@ TEST(FontCollectionTest, createWithVariations) { { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } }; - MinikinAutoUnref newFc( + std::shared_ptr newFc( multiAxisFc->createCollectionWithVariation(variations)); EXPECT_NE(nullptr, newFc.get()); EXPECT_NE(multiAxisFc.get(), newFc.get()); diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index fb917500f0..5285f2642b 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -529,12 +529,9 @@ void expectVSGlyphs(FontFamily* family, uint32_t codepoint, const std::set - minikinFont(new MinikinFontForTest(kVsTestFont)); - MinikinAutoUnref family( - new FontFamily(std::vector{ - Font(minikinFont.get(), FontStyle()) - })); + std::shared_ptr minikinFont(new MinikinFontForTest(kVsTestFont)); + std::shared_ptr family( + new FontFamily(std::vector{ Font(minikinFont, FontStyle()) })); android::AutoMutex _l(gMinikinLock); @@ -585,10 +582,10 @@ TEST_F(FontFamilyTest, hasVSTableTest) { "Font " + testCase.fontPath + " should have a variation sequence table." : "Font " + testCase.fontPath + " shouldn't have a variation sequence table."); - MinikinAutoUnref minikinFont( + std::shared_ptr minikinFont( new MinikinFontForTest(testCase.fontPath)); - MinikinAutoUnref family(new FontFamily( - std::vector{ Font(minikinFont.get(), FontStyle()) })); + std::shared_ptr family(new FontFamily( + std::vector{ Font(minikinFont, FontStyle()) })); android::AutoMutex _l(gMinikinLock); EXPECT_EQ(testCase.hasVSTable, family->hasVSTable()); } @@ -599,13 +596,15 @@ TEST_F(FontFamilyTest, createFamilyWithVariationTest) { const char kMultiAxisFont[] = kTestFontDir "/MultiAxis.ttf"; const char kNoAxisFont[] = kTestFontDir "/Regular.ttf"; - MinikinAutoUnref multiAxisFont(new MinikinFontForTest(kMultiAxisFont)); - MinikinAutoUnref multiAxisFamily(new FontFamily( - std::vector({Font(multiAxisFont.get(), FontStyle())}))); + std::shared_ptr multiAxisFont(new MinikinFontForTest(kMultiAxisFont)); + std::shared_ptr multiAxisFamily( + std::shared_ptr(new FontFamily( + std::vector({Font(multiAxisFont, FontStyle())})))); - MinikinAutoUnref noAxisFont(new MinikinFontForTest(kNoAxisFont)); - MinikinAutoUnref noAxisFamily(new FontFamily( - std::vector({Font(noAxisFont.get(), FontStyle())}))); + std::shared_ptr noAxisFont(new MinikinFontForTest(kNoAxisFont)); + std::shared_ptr noAxisFamily( + std::shared_ptr(new FontFamily( + std::vector({Font(noAxisFont, FontStyle())})))); { // Do not ceate new instance if none of variations are specified. @@ -617,7 +616,7 @@ TEST_F(FontFamilyTest, createFamilyWithVariationTest) { { // New instance should be used for supported variation. std::vector variations = {{MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f}}; - MinikinAutoUnref newFamily( + std::shared_ptr newFamily( multiAxisFamily->createFamilyWithVariation(variations)); EXPECT_NE(nullptr, newFamily.get()); EXPECT_NE(multiAxisFamily.get(), newFamily.get()); @@ -629,7 +628,7 @@ TEST_F(FontFamilyTest, createFamilyWithVariationTest) { { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, { MinikinFont::MakeTag('w', 'g', 'h', 't'), 1.0f } }; - MinikinAutoUnref newFamily( + std::shared_ptr newFamily( multiAxisFamily->createFamilyWithVariation(variations)); EXPECT_NE(nullptr, newFamily.get()); EXPECT_NE(multiAxisFamily.get(), newFamily.get()); @@ -649,7 +648,7 @@ TEST_F(FontFamilyTest, createFamilyWithVariationTest) { { MinikinFont::MakeTag('w', 'd', 't', 'h'), 1.0f }, { MinikinFont::MakeTag('Z', 'Z', 'Z', 'Z'), 1.0f } }; - MinikinAutoUnref newFamily( + std::shared_ptr newFamily( multiAxisFamily->createFamilyWithVariation(variations)); EXPECT_NE(nullptr, newFamily.get()); EXPECT_NE(multiAxisFamily.get(), newFamily.get()); diff --git a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp index 9a7e63fb2c..a5581a27b8 100644 --- a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp @@ -20,6 +20,8 @@ #include #include +#include + #include #include "MinikinInternal.h" @@ -37,13 +39,13 @@ public: }; TEST_F(HbFontCacheTest, getHbFontLockedTest) { - MinikinAutoUnref fontA( + std::shared_ptr fontA( new MinikinFontForTest(kTestFontDir "Regular.ttf")); - MinikinAutoUnref fontB( + std::shared_ptr fontB( new MinikinFontForTest(kTestFontDir "Bold.ttf")); - MinikinAutoUnref fontC( + std::shared_ptr fontC( new MinikinFontForTest(kTestFontDir "BoldItalic.ttf")); android::AutoMutex _l(gMinikinLock); @@ -65,7 +67,7 @@ TEST_F(HbFontCacheTest, getHbFontLockedTest) { } TEST_F(HbFontCacheTest, purgeCacheTest) { - MinikinAutoUnref minikinFont( + std::shared_ptr minikinFont( new MinikinFontForTest(kTestFontDir "Regular.ttf")); android::AutoMutex _l(gMinikinLock); diff --git a/engine/src/flutter/tests/unittest/LayoutTest.cpp b/engine/src/flutter/tests/unittest/LayoutTest.cpp index c023625b16..4a849aa3eb 100644 --- a/engine/src/flutter/tests/unittest/LayoutTest.cpp +++ b/engine/src/flutter/tests/unittest/LayoutTest.cpp @@ -53,14 +53,14 @@ protected: virtual ~LayoutTest() {} virtual void SetUp() override { - mCollection = getFontCollection(SYSTEM_FONT_PATH, SYSTEM_FONT_XML); + mCollection = std::shared_ptr( + getFontCollection(SYSTEM_FONT_PATH, SYSTEM_FONT_XML)); } virtual void TearDown() override { - mCollection->Unref(); } - FontCollection* mCollection; + std::shared_ptr mCollection; }; TEST_F(LayoutTest, doLayoutTest) { @@ -70,8 +70,7 @@ TEST_F(LayoutTest, doLayoutTest) { float advances[kMaxAdvanceLength]; std::vector expectedValues; - Layout layout; - layout.setFontCollection(mCollection); + Layout layout(mCollection); std::vector text; // The mock implementation returns 10.0f advance and 0,0-10x10 bounds for all glyph. @@ -157,8 +156,7 @@ TEST_F(LayoutTest, doLayoutTest_wordSpacing) { std::vector expectedValues; std::vector text; - Layout layout; - layout.setFontCollection(mCollection); + Layout layout(mCollection); paint.wordSpacing = 5.0f; @@ -252,8 +250,7 @@ TEST_F(LayoutTest, doLayoutTest_negativeWordSpacing) { float advances[kMaxAdvanceLength]; std::vector expectedValues; - Layout layout; - layout.setFontCollection(mCollection); + Layout layout(mCollection); std::vector text; // Negative word spacing also should work. @@ -338,6 +335,27 @@ TEST_F(LayoutTest, doLayoutTest_negativeWordSpacing) { } } +TEST_F(LayoutTest, doLayoutTest_rtlTest) { + MinikinPaint paint; + + std::vector text = parseUnicodeString("'a' 'b' U+3042 U+3043 'c' 'd'"); + + Layout ltrLayout(mCollection); + ltrLayout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + + Layout rtlLayout(mCollection); + rtlLayout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_RTL, FontStyle(), paint); + + ASSERT_EQ(ltrLayout.nGlyphs(), rtlLayout.nGlyphs()); + ASSERT_EQ(6u, ltrLayout.nGlyphs()); + + size_t nGlyphs = ltrLayout.nGlyphs(); + for (size_t i = 0; i < nGlyphs; ++i) { + EXPECT_EQ(ltrLayout.getFont(i), rtlLayout.getFont(nGlyphs - i - 1)); + EXPECT_EQ(ltrLayout.getGlyphId(i), rtlLayout.getGlyphId(nGlyphs - i - 1)); + } +} + // TODO: Add more test cases, e.g. measure text, letter spacing. } // namespace minikin diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index e29a2fe534..27a693e16d 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -32,7 +32,7 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { xmlDoc* doc = xmlReadFile(fontXml, NULL, 0); xmlNode* familySet = xmlDocGetRootElement(doc); - std::vector families; + std::vector> families; for (xmlNode* familyNode = familySet->children; familyNode; familyNode = familyNode->next) { if (xmlStrcmp(familyNode->name, (const xmlChar*)"family") != 0) { continue; @@ -69,34 +69,29 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { } if (index == nullptr) { - MinikinAutoUnref - minikinFont(new MinikinFontForTest(fontPath)); - fonts.push_back(Font(minikinFont.get(), FontStyle(weight, italic))); + std::shared_ptr minikinFont(new MinikinFontForTest(fontPath)); + fonts.push_back(Font(minikinFont, FontStyle(weight, italic))); } else { - MinikinAutoUnref - minikinFont(new MinikinFontForTest(fontPath, atoi((const char*)index))); - fonts.push_back(Font(minikinFont.get(), FontStyle(weight, italic))); + std::shared_ptr minikinFont( + new MinikinFontForTest(fontPath, atoi((const char*)index))); + fonts.push_back(Font(minikinFont, FontStyle(weight, italic))); } } xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); - FontFamily* family; + std::shared_ptr family; if (lang == nullptr) { - family = new FontFamily(variant, std::move(fonts)); + family.reset(new FontFamily(variant, std::move(fonts))); } else { uint32_t langId = FontStyle::registerLanguageList( std::string((const char*)lang, xmlStrlen(lang))); - family = new FontFamily(langId, variant, std::move(fonts)); + family.reset(new FontFamily(langId, variant, std::move(fonts))); } families.push_back(family); } xmlFreeDoc(doc); - FontCollection* collection = new FontCollection(families); - for (size_t i = 0; i < families.size(); ++i) { - families[i]->Unref(); - } - return collection; + return new FontCollection(families); } } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.cpp b/engine/src/flutter/tests/util/MinikinFontForTest.cpp index f191f07d6e..723e86ac2d 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.cpp +++ b/engine/src/flutter/tests/util/MinikinFontForTest.cpp @@ -69,9 +69,9 @@ void MinikinFontForTest::GetBounds(MinikinRect* bounds, uint32_t /* glyph_id */, bounds->mBottom = 10.0f; } -MinikinFont* MinikinFontForTest::createFontWithVariation( +std::shared_ptr MinikinFontForTest::createFontWithVariation( const std::vector& variations) const { - return new MinikinFontForTest(mFontPath, mFontIndex, variations); + return std::shared_ptr(new MinikinFontForTest(mFontPath, mFontIndex, variations)); } } // namespace minikin diff --git a/engine/src/flutter/tests/util/MinikinFontForTest.h b/engine/src/flutter/tests/util/MinikinFontForTest.h index 1d0628319b..6e230e1d31 100644 --- a/engine/src/flutter/tests/util/MinikinFontForTest.h +++ b/engine/src/flutter/tests/util/MinikinFontForTest.h @@ -43,7 +43,8 @@ public: size_t GetFontSize() const { return mFontSize; } int GetFontIndex() const { return mFontIndex; } const std::vector& GetAxes() const { return mVariations; } - MinikinFont* createFontWithVariation(const std::vector& variations) const; + std::shared_ptr createFontWithVariation( + const std::vector& variations) const; private: MinikinFontForTest() = delete; MinikinFontForTest(const MinikinFontForTest&) = delete; diff --git a/engine/src/flutter/tests/util/UnicodeUtils.cpp b/engine/src/flutter/tests/util/UnicodeUtils.cpp index 2f811daec2..e66ff93489 100644 --- a/engine/src/flutter/tests/util/UnicodeUtils.cpp +++ b/engine/src/flutter/tests/util/UnicodeUtils.cpp @@ -88,6 +88,17 @@ void ParseUnicode(uint16_t* buf, size_t buf_size, const char* src, size_t* resul LOG_ALWAYS_FATAL_IF(!seen_offset && offset != nullptr); } +std::vector parseUnicodeStringWithOffset(const std::string& in, size_t* offset) { + std::unique_ptr buffer(new uint16_t[in.size()]); + size_t result_size = 0; + ParseUnicode(buffer.get(), in.size(), in.c_str(), &result_size, offset); + return std::vector(buffer.get(), buffer.get() + result_size); +} + +std::vector parseUnicodeString(const std::string& in) { + return parseUnicodeStringWithOffset(in, nullptr); +} + std::vector utf8ToUtf16(const std::string& text) { std::vector result; int32_t i = 0; diff --git a/engine/src/flutter/tests/util/UnicodeUtils.h b/engine/src/flutter/tests/util/UnicodeUtils.h index 571be7a31e..6ce2fcbd90 100644 --- a/engine/src/flutter/tests/util/UnicodeUtils.h +++ b/engine/src/flutter/tests/util/UnicodeUtils.h @@ -19,6 +19,9 @@ namespace minikin { void ParseUnicode(uint16_t* buf, size_t buf_size, const char* src, size_t* result_size, size_t* offset); +std::vector parseUnicodeStringWithOffset(const std::string& in, size_t* offset); +std::vector parseUnicodeString(const std::string& in); + // Converts UTF-8 to UTF-16. std::vector utf8ToUtf16(const std::string& text); From 131392748fe6b4d14a4dcbf3f5c79e56b2f0f142 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Wed, 22 Feb 2017 18:48:18 -0800 Subject: [PATCH 235/364] Add exception for Bulgarian to mk_hyb_file MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The Bulgarian hyphenation patterns contain a line consisting of '0ь0' which has no practical effect on hyphenation. Add an exception in roundtrip testing to make sure we don't fail while comparing our tables with the input data. Test: make -j works and creates .hyb files for bg and cu Change-Id: Ia46b8a45fe522f5194d8105d31b34b0e27528cc9 (cherry picked from commit 6308ea4c4b4652f061a646d164d5fdc941a25ba2) --- engine/src/flutter/tools/mk_hyb_file.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/engine/src/flutter/tools/mk_hyb_file.py b/engine/src/flutter/tools/mk_hyb_file.py index 978c082b27..a9b8932c95 100755 --- a/engine/src/flutter/tools/mk_hyb_file.py +++ b/engine/src/flutter/tools/mk_hyb_file.py @@ -539,6 +539,12 @@ def verify_hyb_file(hyb_fn, pat_fn, chr_fn, hyp_fn): patterns = [] exceptions = [] traverse_trie(0, '', trie_data, ch_map, pattern_data, patterns, exceptions) + + # EXCEPTION for Bulgarian (bg), which contains an ineffectual line of <0, U+044C, 0> + if u'\u044c' in patterns: + patterns.remove(u'\u044c') + patterns.append(u'0\u044c0') + assert verify_file_sorted(patterns, pat_fn), 'pattern table not verified' assert verify_file_sorted(exceptions, hyp_fn), 'exception table not verified' From 319073941ed7f9523960872fd1b73d615f3ce52b Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Fri, 17 Feb 2017 18:55:02 -0800 Subject: [PATCH 236/364] Correct hyphenation for various complex cases MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This adds better support for Arabic script languages, Armenian, Catalan, Hebrew, Kannada, Malayalam, Polish, Tamil, and Telugu by adding various hyphenation types and edits appropriate for the locales. For Arabic script languages, soft hyphens act transparently with regard to joining: If a line is broken at a soft hyphen where the two characters around the soft hyphen were joining each other before, they will continue to appear joining if the line is broken at the soft hyphen and a hyphen glyph is inserted. This is needed for Central Asian languages such as Uighur. For Armenian, U+058A ARMENIAN HYPHEN is used for line breaks caused by either automatic hyphenation or soft hyphens. For Catalan, nonstandard line breaks are implemented for "l·l", which hyphenates as "l-/l". For Polish, when there is a line break at a hyphen, the hyphen is repeated at the next line. For the South Indic languages, when breaks happen due to soft breaks or automatic hyphenation, no visible hyphen is inserted, although a penalty is added. For Hebrew, support for using U+05BE HEBREW PUNCTUATION MAQAF has been implemented, but it's turned off pending confirmation of desirability. Also, hard hyphens, which previously had no penalty added for breaking the line after them, now have the same penalty as an automatic or soft break, with the difference that no hyphen is inserted when they break. Finally, some bugs have been fixed with hyphenating multiscript and multi-font words. Bug: 19950445 Bug: 19955011 Bug: 25623243 Bug: 26154469 Bug: 26154471 Bug: 33387871 Bug: 33560754 Bug: 33752592 Bug: 33754204 Test: Unit tests added, plus thorough manual testing Change-Id: Iaccf776ce8d1d434ee8b1c534ff3659d80fdc338 --- engine/src/flutter/app/HyphTool.cpp | 8 +- .../src/flutter/include/minikin/Hyphenator.h | 124 ++++++- .../src/flutter/include/minikin/LineBreaker.h | 9 +- .../src/flutter/include/minikin/MinikinFont.h | 14 +- .../flutter/libs/minikin/FontCollection.cpp | 7 +- .../src/flutter/libs/minikin/Hyphenator.cpp | 244 +++++++++++-- engine/src/flutter/libs/minikin/Layout.cpp | 219 ++++++++++-- .../src/flutter/libs/minikin/LineBreaker.cpp | 74 ++-- .../src/flutter/libs/minikin/WordBreaker.cpp | 4 +- .../flutter/tests/perftests/Hyphenator.cpp | 9 +- engine/src/flutter/tests/unittest/Android.mk | 2 + .../flutter/tests/unittest/HyphenatorTest.cpp | 335 ++++++++++++++++++ .../src/flutter/tests/unittest/LayoutTest.cpp | 47 +++ .../tests/unittest/WordBreakerTests.cpp | 49 ++- 14 files changed, 985 insertions(+), 160 deletions(-) create mode 100644 engine/src/flutter/tests/unittest/HyphenatorTest.cpp diff --git a/engine/src/flutter/app/HyphTool.cpp b/engine/src/flutter/app/HyphTool.cpp index 88245fea33..cdb1466f40 100644 --- a/engine/src/flutter/app/HyphTool.cpp +++ b/engine/src/flutter/app/HyphTool.cpp @@ -2,11 +2,13 @@ #include #include +#include "unicode/locid.h" #include "utils/Log.h" #include #include +using minikin::HyphenationType; using minikin::Hyphenator; Hyphenator* loadHybFile(const char* fn) { @@ -35,7 +37,7 @@ Hyphenator* loadHybFile(const char* fn) { int main(int argc, char** argv) { Hyphenator* hyph = loadHybFile("/tmp/en.hyb"); // should also be configurable - std::vector result; + std::vector result; std::vector word; if (argc < 2) { fprintf(stderr, "usage: hyphtool word\n"); @@ -51,9 +53,9 @@ int main(int argc, char** argv) { // ASCII (or possibly ISO Latin 1), but kinda painful to do utf conversion :( word.push_back(c); } - hyph->hyphenate(&result, word.data(), word.size()); + hyph->hyphenate(&result, word.data(), word.size(), icu::Locale::getUS()); for (size_t i = 0; i < len; i++) { - if (result[i] != 0) { + if (result[i] != HyphenationType::DONT_BREAK) { printf("-"); } printf("%c", word[i]); diff --git a/engine/src/flutter/include/minikin/Hyphenator.h b/engine/src/flutter/include/minikin/Hyphenator.h index f922dcbfb7..ea81813745 100644 --- a/engine/src/flutter/include/minikin/Hyphenator.h +++ b/engine/src/flutter/include/minikin/Hyphenator.h @@ -18,6 +18,7 @@ * An implementation of Liang's hyphenation algorithm. */ +#include "unicode/locid.h" #include #include @@ -26,38 +27,131 @@ namespace minikin { +enum class HyphenationType : uint8_t { + // Note: There are implicit assumptions scattered in the code that DONT_BREAK is 0. + + // Do not break. + DONT_BREAK = 0, + // Break the line and insert a normal hyphen. + BREAK_AND_INSERT_HYPHEN = 1, + // Break the line and insert an Armenian hyphen (U+058A). + BREAK_AND_INSERT_ARMENIAN_HYPHEN = 2, + // Break the line and insert a maqaf (Hebrew hyphen, U+05BE). + BREAK_AND_INSERT_MAQAF = 3, + // Break the line and insert a Canadian Syllabics hyphen (U+1400). + BREAK_AND_INSERT_UCAS_HYPHEN = 4, + // Break the line, but don't insert a hyphen. Used for cases when there is already a hyphen + // present or the script does not use a hyphen (e.g. in Malayalam). + BREAK_AND_DONT_INSERT_HYPHEN = 5, + // Break and replace the last code unit with hyphen. Used for Catalan "l·l" which hyphenates + // as "l-/l". + BREAK_AND_REPLACE_WITH_HYPHEN = 6, + // Break the line, and repeat the hyphen (which is the last character) at the beginning of the + // next line. Used in Polish, where "czerwono-niebieska" should hyphenate as + // "czerwono-/-niebieska". + BREAK_AND_INSERT_HYPHEN_AT_NEXT_LINE = 7, + // Break the line, insert a ZWJ and hyphen at the first line, and a ZWJ at the second line. + // This is used in Arabic script, mostly for writing systems of Central Asia. It's our default + // behavior when a soft hyphen is used in Arabic script. + BREAK_AND_INSERT_HYPHEN_AND_ZWJ = 8 +}; + +// The hyphen edit represents an edit to the string when a word is +// hyphenated. The most common hyphen edit is adding a "-" at the end +// of a syllable, but nonstandard hyphenation allows for more choices. +// Note that a HyphenEdit can hold two types of edits at the same time, +// One at the beginning of the string/line and one at the end. +class HyphenEdit { +public: + static const uint32_t NO_EDIT = 0x00; + + static const uint32_t INSERT_HYPHEN_AT_END = 0x01; + static const uint32_t INSERT_ARMENIAN_HYPHEN_AT_END = 0x02; + static const uint32_t INSERT_MAQAF_AT_END = 0x03; + static const uint32_t INSERT_UCAS_HYPHEN_AT_END = 0x04; + static const uint32_t INSERT_ZWJ_AND_HYPHEN_AT_END = 0x05; + static const uint32_t REPLACE_WITH_HYPHEN_AT_END = 0x06; + static const uint32_t BREAK_AT_END = 0x07; + + static const uint32_t INSERT_HYPHEN_AT_START = 0x01 << 3; + static const uint32_t INSERT_ZWJ_AT_START = 0x02 << 3; + static const uint32_t BREAK_AT_START = 0x03 << 3; + + // Keep in sync with the definitions in the Java code at: + // frameworks/base/graphics/java/android/graphics/Paint.java + static const uint32_t MASK_END_OF_LINE = 0x07; + static const uint32_t MASK_START_OF_LINE = 0x03 << 3; + + inline static bool isReplacement(uint32_t hyph) { + return hyph == REPLACE_WITH_HYPHEN_AT_END; + } + + inline static bool isInsertion(uint32_t hyph) { + return (hyph == INSERT_HYPHEN_AT_END + || hyph == INSERT_ARMENIAN_HYPHEN_AT_END + || hyph == INSERT_MAQAF_AT_END + || hyph == INSERT_UCAS_HYPHEN_AT_END + || hyph == INSERT_ZWJ_AND_HYPHEN_AT_END + || hyph == INSERT_HYPHEN_AT_START + || hyph == INSERT_ZWJ_AT_START); + } + + const static uint32_t* getHyphenString(uint32_t hyph); + static uint32_t editForThisLine(HyphenationType type); + static uint32_t editForNextLine(HyphenationType type); + + HyphenEdit() : hyphen(NO_EDIT) { } + HyphenEdit(uint32_t hyphenInt) : hyphen(hyphenInt) { } // NOLINT(implicit) + uint32_t getHyphen() const { return hyphen; } + bool operator==(const HyphenEdit &other) const { return hyphen == other.hyphen; } + + uint32_t getEnd() const { return hyphen & MASK_END_OF_LINE; } + uint32_t getStart() const { return hyphen & MASK_START_OF_LINE; } + +private: + uint32_t hyphen; +}; + // hyb file header; implementation details are in the .cpp file struct Header; class Hyphenator { public: - // Note: this will also require a locale, for proper case folding behavior - static Hyphenator* load(const uint16_t* patternData, size_t size); + // Compute the hyphenation of a word, storing the hyphenation in result vector. Each entry in + // the vector is a "hyphenation type" for a potential hyphenation that can be applied at the + // corresponding code unit offset in the word. + // + // Example: word is "hyphen", result is the following, corresponding to "hy-phen": + // [DONT_BREAK, DONT_BREAK, BREAK_AND_INSERT_HYPHEN, DONT_BREAK, DONT_BREAK, DONT_BREAK] + void hyphenate(std::vector* result, const uint16_t* word, size_t len, + const icu::Locale& locale); - // Compute the hyphenation of a word, storing the hyphenation in result vector. Each - // entry in the vector is a "hyphen edit" to be applied at the corresponding code unit - // offset in the word. Currently 0 means no hyphen and 1 means insert hyphen and break, - // but this will be expanded to other edits for nonstandard hyphenation. - // Example: word is "hyphen", result is [0 0 1 0 0 0], corresponding to "hy-phen". - void hyphenate(std::vector* result, const uint16_t* word, size_t len); + // Returns true if the codepoint is like U+2010 HYPHEN in line breaking and usage: a character + // immediately after which line breaks are allowed, but words containing it should not be + // automatically hyphenated. + static bool isLineBreakingHyphen(uint32_t cp); // pattern data is in binary format, as described in doc/hyb_file_format.md. Note: // the caller is responsible for ensuring that the lifetime of the pattern data is // at least as long as the Hyphenator object. - // Note: nullptr is valid input, in which case the hyphenator only processes soft hyphens + // Note: nullptr is valid input, in which case the hyphenator only processes soft hyphens. static Hyphenator* loadBinary(const uint8_t* patternData); private: - // apply soft hyphens only, ignoring patterns - void hyphenateSoft(uint8_t* result, const uint16_t* word, size_t len); + // apply various hyphenation rules including hard and soft hyphens, ignoring patterns + void hyphenateWithNoPatterns(HyphenationType* result, const uint16_t* word, size_t len, + const icu::Locale& locale); - // try looking up word in alphabet table, return false if any code units fail to map - // Note that this methor writes len+2 entries into alpha_codes (including start and stop) - bool alphabetLookup(uint16_t* alpha_codes, const uint16_t* word, size_t len); + // Try looking up word in alphabet table, return DONT_BREAK if any code units fail to map. + // Otherwise, returns BREAK_AND_INSERT_HYPHEN, BREAK_AND_INSERT_ARMENIAN_HYPHEN, or + // BREAK_AND_DONT_INSERT_HYPHEN based on the the script of the characters seen. + // Note that this method writes len+2 entries into alpha_codes (including start and stop) + HyphenationType alphabetLookup(uint16_t* alpha_codes, const uint16_t* word, size_t len); // calculate hyphenation from patterns, assuming alphabet lookup has already been done - void hyphenateFromCodes(uint8_t* result, const uint16_t* codes, size_t len); + void hyphenateFromCodes(HyphenationType* result, const uint16_t* codes, size_t len, + HyphenationType hyphenValue); // TODO: these should become parameters, as they might vary by locale, screen size, and // possibly explicit user control. diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index e93953666b..ce8eb7d571 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -198,18 +198,18 @@ class LineBreaker { size_t lineNumber; // only updated for non-constant line widths size_t preSpaceCount; // preceding space count before breaking size_t postSpaceCount; // preceding space count after breaking - uint8_t hyphenEdit; + HyphenationType hyphenType; }; float currentLineWidth() const; void addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth postBreak, - size_t preSpaceCount, size_t postSpaceCount, float penalty, uint8_t hyph); + size_t preSpaceCount, size_t postSpaceCount, float penalty, HyphenationType hyph); void addCandidate(Candidate cand); // push an actual break to the output. Takes care of setting flags for tab - void pushBreak(int offset, float width, uint8_t hyph); + void pushBreak(int offset, float width, uint8_t hyphenEdit); float getSpaceWidth() const; @@ -220,11 +220,12 @@ class LineBreaker { void finishBreaksOptimal(); WordBreaker mWordBreaker; + icu::Locale mLocale; std::vectormTextBuf; std::vectormCharWidths; Hyphenator* mHyphenator; - std::vector mHyphBuf; + std::vector mHyphBuf; // layout parameters BreakStrategy mStrategy = kBreakStrategy_Greedy; diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 1d5ebb774a..52263f529a 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -21,25 +21,13 @@ #include #include +#include // An abstraction for platform fonts, allowing Minikin to be used with // multiple actual implementations of fonts. namespace minikin { -// The hyphen edit represents an edit to the string when a word is -// hyphenated. The most common hyphen edit is adding a "-" at the end -// of a syllable, but nonstandard hyphenation allows for more choices. -class HyphenEdit { -public: - HyphenEdit() : hyphen(0) { } - HyphenEdit(uint32_t hyphenInt) : hyphen(hyphenInt) { } // NOLINT(implicit) - bool hasHyphen() const { return hyphen != 0; } - bool operator==(const HyphenEdit &other) const { return hyphen == other.hyphen; } -private: - uint32_t hyphen; -}; - class MinikinFont; // Possibly move into own .h file? diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index c351c3a58d..8ec302b5ea 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -328,7 +328,8 @@ const std::shared_ptr& FontCollection::getFamilyForChar(uint32_t ch, return familyVec[bestFamilyIndex]; } -const uint32_t NBSP = 0xA0; +const uint32_t NBSP = 0x00A0; +const uint32_t SOFT_HYPHEN = 0x00AD; const uint32_t ZWJ = 0x200C; const uint32_t ZWNJ = 0x200D; const uint32_t HYPHEN = 0x2010; @@ -421,8 +422,8 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty if (isStickyWhitelisted(ch)) { // Continue using existing font as long as it has coverage and is whitelisted shouldContinueRun = lastFamily->getCoverage().get(ch); - } else if (isVariationSelector(ch)) { - // Always continue if the character is a variation selector. + } else if (ch == SOFT_HYPHEN || isVariationSelector(ch)) { + // Always continue if the character is the soft hyphen or a variation selector. shouldContinueRun = true; } } diff --git a/engine/src/flutter/libs/minikin/Hyphenator.cpp b/engine/src/flutter/libs/minikin/Hyphenator.cpp index c170c6bd48..5ec82feb50 100644 --- a/engine/src/flutter/libs/minikin/Hyphenator.cpp +++ b/engine/src/flutter/libs/minikin/Hyphenator.cpp @@ -19,6 +19,7 @@ #include #include #include +#include // HACK: for reading pattern file #include @@ -32,7 +33,10 @@ using std::vector; namespace minikin { +static const uint16_t CHAR_HYPHEN_MINUS = 0x002D; static const uint16_t CHAR_SOFT_HYPHEN = 0x00AD; +static const uint16_t CHAR_MIDDLE_DOT = 0x00B7; +static const uint16_t CHAR_HYPHEN = 0x2010; // The following are structs that correspond to tables inside the hyb file format @@ -110,34 +114,216 @@ Hyphenator* Hyphenator::loadBinary(const uint8_t* patternData) { return result; } -void Hyphenator::hyphenate(vector* result, const uint16_t* word, size_t len) { +void Hyphenator::hyphenate(vector* result, const uint16_t* word, size_t len, + const icu::Locale& locale) { result->clear(); result->resize(len); const size_t paddedLen = len + 2; // start and stop code each count for 1 if (patternData != nullptr && (int)len >= MIN_PREFIX + MIN_SUFFIX && paddedLen <= MAX_HYPHENATED_SIZE) { uint16_t alpha_codes[MAX_HYPHENATED_SIZE]; - if (alphabetLookup(alpha_codes, word, len)) { - hyphenateFromCodes(result->data(), alpha_codes, paddedLen); + const HyphenationType hyphenValue = alphabetLookup(alpha_codes, word, len); + if (hyphenValue != HyphenationType::DONT_BREAK) { + hyphenateFromCodes(result->data(), alpha_codes, paddedLen, hyphenValue); return; } // TODO: try NFC normalization // TODO: handle non-BMP Unicode (requires remapping of offsets) } - hyphenateSoft(result->data(), word, len); + // Note that we will always get here if the word contains a hyphen or a soft hyphen, because the + // alphabet is not expected to contain a hyphen or a soft hyphen character, so alphabetLookup + // would return DONT_BREAK. + hyphenateWithNoPatterns(result->data(), word, len, locale); } -// If any soft hyphen is present in the word, use soft hyphens to decide hyphenation, -// as recommended in UAX #14 (Use of Soft Hyphen) -void Hyphenator::hyphenateSoft(uint8_t* result, const uint16_t* word, size_t len) { - result[0] = 0; +// This function determines whether a character is like U+2010 HYPHEN in +// line breaking and usage: a character immediately after which line breaks +// are allowed, but words containing it should not be automatically +// hyphenated using patterns. This is a curated set, created by manually +// inspecting all the characters that have the Unicode line breaking +// property of BA or HY and seeing which ones are hyphens. +bool Hyphenator::isLineBreakingHyphen(uint32_t c) { + return (c == 0x002D || // HYPHEN-MINUS + c == 0x058A || // ARMENIAN HYPHEN + c == 0x05BE || // HEBREW PUNCTUATION MAQAF + c == 0x1400 || // CANADIAN SYLLABICS HYPHEN + c == 0x2010 || // HYPHEN + c == 0x2013 || // EN DASH + c == 0x2027 || // HYPHENATION POINT + c == 0x2E17 || // DOUBLE OBLIQUE HYPHEN + c == 0x2E40); // DOUBLE HYPHEN +} + +const static uint32_t HYPHEN_STR[] = {0x2010, 0}; +const static uint32_t ARMENIAN_HYPHEN_STR[] = {0x058A, 0}; +const static uint32_t MAQAF_STR[] = {0x05BE, 0}; +const static uint32_t UCAS_HYPHEN_STR[] = {0x1400, 0}; +const static uint32_t ZWJ_STR[] = {0x200D, 0}; +const static uint32_t ZWJ_AND_HYPHEN_STR[] = {0x200D, 0x2010, 0}; + +const uint32_t* HyphenEdit::getHyphenString(uint32_t hyph) { + switch (hyph) { + case INSERT_HYPHEN_AT_END: + case REPLACE_WITH_HYPHEN_AT_END: + case INSERT_HYPHEN_AT_START: + return HYPHEN_STR; + case INSERT_ARMENIAN_HYPHEN_AT_END: + return ARMENIAN_HYPHEN_STR; + case INSERT_MAQAF_AT_END: + return MAQAF_STR; + case INSERT_UCAS_HYPHEN_AT_END: + return UCAS_HYPHEN_STR; + case INSERT_ZWJ_AND_HYPHEN_AT_END: + return ZWJ_AND_HYPHEN_STR; + case INSERT_ZWJ_AT_START: + return ZWJ_STR; + default: + return nullptr; + } +} + +uint32_t HyphenEdit::editForThisLine(HyphenationType type) { + switch (type) { + case HyphenationType::DONT_BREAK: + return NO_EDIT; + case HyphenationType::BREAK_AND_INSERT_HYPHEN: + return INSERT_HYPHEN_AT_END; + case HyphenationType::BREAK_AND_INSERT_ARMENIAN_HYPHEN: + return INSERT_ARMENIAN_HYPHEN_AT_END; + case HyphenationType::BREAK_AND_INSERT_MAQAF: + return INSERT_MAQAF_AT_END; + case HyphenationType::BREAK_AND_INSERT_UCAS_HYPHEN: + return INSERT_UCAS_HYPHEN_AT_END; + case HyphenationType::BREAK_AND_REPLACE_WITH_HYPHEN: + return REPLACE_WITH_HYPHEN_AT_END; + case HyphenationType::BREAK_AND_INSERT_HYPHEN_AND_ZWJ: + return INSERT_ZWJ_AND_HYPHEN_AT_END; + default: + return BREAK_AT_END; + } +} + +uint32_t HyphenEdit::editForNextLine(HyphenationType type) { + switch (type) { + case HyphenationType::DONT_BREAK: + return NO_EDIT; + case HyphenationType::BREAK_AND_INSERT_HYPHEN_AT_NEXT_LINE: + return INSERT_HYPHEN_AT_START; + case HyphenationType::BREAK_AND_INSERT_HYPHEN_AND_ZWJ: + return INSERT_ZWJ_AT_START; + default: + return BREAK_AT_START; + } +} + +static UScriptCode getScript(uint32_t codePoint) { + UErrorCode errorCode = U_ZERO_ERROR; + const UScriptCode script = uscript_getScript(static_cast(codePoint), &errorCode); + if (U_SUCCESS(errorCode)) { + return script; + } else { + return USCRIPT_INVALID_CODE; + } +} + +static HyphenationType hyphenationTypeBasedOnScript(uint32_t codePoint) { + // Note: It's not clear what the best hyphen for Hebrew is. While maqaf is the "correct" hyphen + // for Hebrew, modern practice may have shifted towards Western hyphens. We use normal hyphens + // for now to be safe. BREAK_AND_INSERT_MAQAF is already implemented, so if we want to switch + // to maqaf for Hebrew, we can simply add a condition here. + const UScriptCode script = getScript(codePoint); + if (script == USCRIPT_KANNADA + || script == USCRIPT_MALAYALAM + || script == USCRIPT_TAMIL + || script == USCRIPT_TELUGU) { + // Grantha is not included, since we don't support non-BMP hyphenation yet. + return HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN; + } else if (script == USCRIPT_ARMENIAN) { + return HyphenationType::BREAK_AND_INSERT_ARMENIAN_HYPHEN; + } else if (script == USCRIPT_CANADIAN_ABORIGINAL) { + return HyphenationType::BREAK_AND_INSERT_UCAS_HYPHEN; + } else { + return HyphenationType::BREAK_AND_INSERT_HYPHEN; + } +} + +static inline int32_t getJoiningType(UChar32 codepoint) { + return u_getIntPropertyValue(codepoint, UCHAR_JOINING_TYPE); +} + +// Assumption for caller: location must be >= 2 and word[location] == CHAR_SOFT_HYPHEN. +// This function decides if the letters before and after the hyphen should appear as joining. +static inline HyphenationType getHyphTypeForArabic(const uint16_t* word, size_t len, + size_t location) { + ssize_t i = location; + int32_t type = U_JT_NON_JOINING; + while (static_cast(i) < len && (type = getJoiningType(word[i])) == U_JT_TRANSPARENT) { + i++; + } + if (type == U_JT_DUAL_JOINING || type == U_JT_RIGHT_JOINING || type == U_JT_JOIN_CAUSING) { + // The next character is of the type that may join the last character. See if the last + // character is also of the right type. + i = location - 2; // Skip the soft hyphen + type = U_JT_NON_JOINING; + while (i >= 0 && (type = getJoiningType(word[i])) == U_JT_TRANSPARENT) { + i--; + } + if (type == U_JT_DUAL_JOINING || type == U_JT_LEFT_JOINING || type == U_JT_JOIN_CAUSING) { + return HyphenationType::BREAK_AND_INSERT_HYPHEN_AND_ZWJ; + } + } + return HyphenationType::BREAK_AND_INSERT_HYPHEN; +} + +// Use various recommendations of UAX #14 Unicode Line Breaking Algorithm for hyphenating words +// that didn't match patterns, especially words that contain hyphens or soft hyphens (See sections +// 5.3, Use of Hyphen, and 5.4, Use of Soft Hyphen). +void Hyphenator::hyphenateWithNoPatterns(HyphenationType* result, const uint16_t* word, size_t len, + const icu::Locale& locale) { + result[0] = HyphenationType::DONT_BREAK; for (size_t i = 1; i < len; i++) { - result[i] = word[i - 1] == CHAR_SOFT_HYPHEN; + const uint16_t prevChar = word[i - 1]; + if (i > 1 && isLineBreakingHyphen(prevChar)) { + // Break after hyphens, but only if they don't start the word. + + if ((prevChar == CHAR_HYPHEN_MINUS || prevChar == CHAR_HYPHEN) + && strcmp(locale.getLanguage(), "pl") == 0 + && getScript(word[i]) == USCRIPT_LATIN ) { + // In Polish, hyphens get repeated at the next line. To be safe, + // we will do this only if the next character is Latin. + result[i] = HyphenationType::BREAK_AND_INSERT_HYPHEN_AT_NEXT_LINE; + } else { + result[i] = HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN; + } + } else if (i > 1 && prevChar == CHAR_SOFT_HYPHEN) { + // Break after soft hyphens, but only if they don't start the word (a soft hyphen + // starting the word doesn't give any useful break opportunities). The type of the break + // is based on the script of the character we break on. + if (getScript(word[i]) == USCRIPT_ARABIC) { + // For Arabic, we need to look and see if the characters around the soft hyphen + // actually join. If they don't, we'll just insert a normal hyphen. + result[i] = getHyphTypeForArabic(word, len, i); + } else { + result[i] = hyphenationTypeBasedOnScript(word[i]); + } + } else if (prevChar == CHAR_MIDDLE_DOT + && MIN_PREFIX < i && i <= len - MIN_SUFFIX + && ((word[i - 2] == 'l' && word[i] == 'l') + || (word[i - 2] == 'L' && word[i] == 'L')) + && strcmp(locale.getLanguage(), "ca") == 0) { + // In Catalan, "l·l" should break as "l-" on the first line + // and "l" on the next line. + result[i] = HyphenationType::BREAK_AND_REPLACE_WITH_HYPHEN; + } else { + result[i] = HyphenationType::DONT_BREAK; + } } } -bool Hyphenator::alphabetLookup(uint16_t* alpha_codes, const uint16_t* word, size_t len) { +HyphenationType Hyphenator::alphabetLookup(uint16_t* alpha_codes, const uint16_t* word, + size_t len) { const Header* header = getHeader(); + HyphenationType result = HyphenationType::BREAK_AND_INSERT_HYPHEN; // TODO: check header magic uint32_t alphabetVersion = header->alphabetVersion(); if (alphabetVersion == 0) { @@ -148,16 +334,19 @@ bool Hyphenator::alphabetLookup(uint16_t* alpha_codes, const uint16_t* word, siz for (size_t i = 0; i < len; i++) { uint16_t c = word[i]; if (c < min_codepoint || c >= max_codepoint) { - return false; + return HyphenationType::DONT_BREAK; } uint8_t code = alphabet->data[c - min_codepoint]; if (code == 0) { - return false; + return HyphenationType::DONT_BREAK; + } + if (result == HyphenationType::BREAK_AND_INSERT_HYPHEN) { + result = hyphenationTypeBasedOnScript(c); } alpha_codes[i + 1] = code; } alpha_codes[len + 1] = 0; // word termination - return true; + return result; } else if (alphabetVersion == 1) { const AlphabetTable1* alphabet = header->alphabetTable1(); size_t n_entries = alphabet->n_entries; @@ -168,18 +357,21 @@ bool Hyphenator::alphabetLookup(uint16_t* alpha_codes, const uint16_t* word, siz uint16_t c = word[i]; auto p = std::lower_bound(begin, end, c << 11); if (p == end) { - return false; + return HyphenationType::DONT_BREAK; } uint32_t entry = *p; if (AlphabetTable1::codepoint(entry) != c) { - return false; + return HyphenationType::DONT_BREAK; + } + if (result == HyphenationType::BREAK_AND_INSERT_HYPHEN) { + result = hyphenationTypeBasedOnScript(c); } alpha_codes[i + 1] = AlphabetTable1::value(entry); } alpha_codes[len + 1] = 0; - return true; + return result; } - return false; + return HyphenationType::DONT_BREAK; } /** @@ -187,7 +379,12 @@ bool Hyphenator::alphabetLookup(uint16_t* alpha_codes, const uint16_t* word, siz * has been done by now, and all characters have been found in the alphabet. * Note: len here is the padded length including 0 codes at start and end. **/ -void Hyphenator::hyphenateFromCodes(uint8_t* result, const uint16_t* codes, size_t len) { +void Hyphenator::hyphenateFromCodes(HyphenationType* result, const uint16_t* codes, size_t len, + HyphenationType hyphenValue) { + static_assert(sizeof(HyphenationType) == sizeof(uint8_t), "HyphnationType must be uint8_t."); + // Reuse the result array as a buffer for calculating intermediate hyphenation numbers. + uint8_t* buffer = reinterpret_cast(result); + const Header* header = getHeader(); const Trie* trie = header->trieTable(); const Pattern* pattern = header->patternTable(); @@ -209,26 +406,27 @@ void Hyphenator::hyphenateFromCodes(uint8_t* result, const uint16_t* codes, size uint32_t pat_ix = trie->data[node] >> pattern_shift; // pat_ix contains a 3-tuple of length, shift (number of trailing zeros), and an offset // into the buf pool. This is the pattern for the substring (i..j) we just matched, - // which we combine (via point-wise max) into the result vector. + // which we combine (via point-wise max) into the buffer vector. if (pat_ix != 0) { uint32_t pat_entry = pattern->data[pat_ix]; int pat_len = Pattern::len(pat_entry); int pat_shift = Pattern::shift(pat_entry); const uint8_t* pat_buf = pattern->buf(pat_entry); int offset = j + 1 - (pat_len + pat_shift); - // offset is the index within result that lines up with the start of pat_buf + // offset is the index within buffer that lines up with the start of pat_buf int start = std::max(MIN_PREFIX - offset, 0); int end = std::min(pat_len, (int)maxOffset - offset); for (int k = start; k < end; k++) { - result[offset + k] = std::max(result[offset + k], pat_buf[k]); + buffer[offset + k] = std::max(buffer[offset + k], pat_buf[k]); } } } } // Since the above calculation does not modify values outside - // [MIN_PREFIX, len - MIN_SUFFIX], they are left as 0. + // [MIN_PREFIX, len - MIN_SUFFIX], they are left as 0 = DONT_BREAK. for (size_t i = MIN_PREFIX; i < maxOffset; i++) { - result[i] &= 1; + // Hyphenation opportunities happen when the hyphenation numbers are odd. + result[i] = (buffer[i] & 1u) ? hyphenValue : HyphenationType::DONT_BREAK; } } diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 6b28f57a33..743cb763ae 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -22,6 +22,7 @@ #include #include #include +#include #include #include @@ -242,7 +243,7 @@ android::hash_t LayoutCacheKey::computeHash() const { hash = android::JenkinsHashMix(hash, hash_type(mSkewX)); hash = android::JenkinsHashMix(hash, hash_type(mLetterSpacing)); hash = android::JenkinsHashMix(hash, hash_type(mPaintFlags)); - hash = android::JenkinsHashMix(hash, hash_type(mHyphenEdit.hasHyphen())); + hash = android::JenkinsHashMix(hash, hash_type(mHyphenEdit.getHyphen())); hash = android::JenkinsHashMix(hash, hash_type(mIsRtl)); hash = android::JenkinsHashMixShorts(hash, mChars, mNchars); return android::JenkinsHashWhiten(hash); @@ -623,7 +624,7 @@ float Layout::measureText(const uint16_t* buf, size_t start, size_t count, size_ float Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t bufSize, bool isRtl, LayoutContext* ctx, size_t dstStart, const std::shared_ptr& collection, Layout* layout, float* advances) { - HyphenEdit hyphen = ctx->paint.hyphenEdit; + const uint32_t originalHyphen = ctx->paint.hyphenEdit.getHyphen(); float advance = 0; if (!isRtl) { // left to right @@ -632,8 +633,15 @@ float Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t wordend; for (size_t iter = start; iter < start + count; iter = wordend) { wordend = getNextWordBreakForCache(buf, iter, bufSize); - // Only apply hyphen to the last word in the string. - ctx->paint.hyphenEdit = wordend >= start + count ? hyphen : HyphenEdit(); + // Only apply hyphen to the first or last word in the string. + uint32_t hyphen = originalHyphen; + if (iter != start) { // Not the first word + hyphen &= ~HyphenEdit::MASK_START_OF_LINE; + } + if (wordend < start + count) { // Not the last word + hyphen &= ~HyphenEdit::MASK_END_OF_LINE; + } + ctx->paint.hyphenEdit = hyphen; size_t wordcount = std::min(start + count, wordend) - iter; advance += doLayoutWord(buf + wordstart, iter - wordstart, wordcount, wordend - wordstart, isRtl, ctx, iter - dstStart, collection, layout, @@ -647,8 +655,15 @@ float Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, size_t wordend = end == 0 ? 0 : getNextWordBreakForCache(buf, end - 1, bufSize); for (size_t iter = end; iter > start; iter = wordstart) { wordstart = getPrevWordBreakForCache(buf, iter, bufSize); - // Only apply hyphen to the last (leftmost) word in the string. - ctx->paint.hyphenEdit = iter == end ? hyphen : HyphenEdit(); + // Only apply hyphen to the first (rightmost) or last (leftmost) word in the string. + uint32_t hyphen = originalHyphen; + if (wordstart > start) { // Not the first word + hyphen &= ~HyphenEdit::MASK_START_OF_LINE; + } + if (iter != end) { // Not the last word + hyphen &= ~HyphenEdit::MASK_END_OF_LINE; + } + ctx->paint.hyphenEdit = hyphen; size_t bufStart = std::max(start, wordstart); advance += doLayoutWord(buf + wordstart, bufStart - wordstart, iter - bufStart, wordend - wordstart, isRtl, ctx, bufStart - dstStart, collection, layout, @@ -719,6 +734,134 @@ static void addFeatures(const string &str, vector* features) { } } +static inline hb_codepoint_t determineHyphenChar(hb_codepoint_t preferredHyphen, hb_font_t* font) { + if (preferredHyphen == 0x2010 /* HYPHEN */ + || preferredHyphen == 0x058A /* ARMENIAN_HYPHEN */ + || preferredHyphen == 0x05BE /* HEBREW PUNCTUATION MAQAF */ + || preferredHyphen == 0x1400 /* CANADIAN SYLLABIC HYPHEN */) { + hb_codepoint_t glyph; + // Fallback to ASCII HYPHEN-MINUS if the font didn't have a glyph for the preferred hyphen. + // Note that we intentionally don't do anything special if the font doesn't have a + // HYPHEN-MINUS either, so a tofu could be shown, hinting towards something missing. + if (!hb_font_get_nominal_glyph(font, preferredHyphen, &glyph)) { + return 0x002D; // HYPHEN-MINUS + } + } + return preferredHyphen; +} + +static inline void addHyphenToHbBuffer(hb_buffer_t* buffer, hb_font_t* font, uint32_t hyphen, + uint32_t cluster) { + const uint32_t* hyphenStr = HyphenEdit::getHyphenString(hyphen); + while (*hyphenStr != 0) { + hb_codepoint_t hyphenChar = determineHyphenChar(*hyphenStr, font); + hb_buffer_add(buffer, hyphenChar, cluster); + hyphenStr++; + } +} + +// Returns the cluster value assigned to the first codepoint added to the buffer, which can be used +// to translate cluster values returned by HarfBuzz to input indices. +static inline uint32_t addToHbBuffer(hb_buffer_t* buffer, + const uint16_t* buf, size_t start, size_t count, size_t bufSize, + ssize_t scriptRunStart, ssize_t scriptRunEnd, + HyphenEdit hyphenEdit, hb_font_t* hbFont) { + + // Only hyphenate the very first script run for starting hyphens. + const uint32_t startHyphen = (scriptRunStart == 0) + ? hyphenEdit.getStart() + : HyphenEdit::NO_EDIT; + // Only hyphenate the very last script run for ending hyphens. + const uint32_t endHyphen = (static_cast(scriptRunEnd) == count) + ? hyphenEdit.getEnd() + : HyphenEdit::NO_EDIT; + + // In the following code, we drop the pre-context and/or post-context if there is a + // hyphen edit at that end. This is not absolutely necessary, since HarfBuzz uses + // contexts only for joining scripts at the moment, e.g. to determine if the first or + // last letter of a text range to shape should take a joining form based on an + // adjacent letter or joiner (that comes from the context). + // + // TODO: Revisit this for: + // 1. Desperate breaks for joining scripts like Arabic (where it may be better to keep + // the context); + // 2. Special features like start-of-word font features (not implemented in HarfBuzz + // yet). + + // We don't have any start-of-line replacement edit yet, so we don't need to check for + // those. + if (HyphenEdit::isInsertion(startHyphen)) { + // A cluster value of zero guarantees that the inserted hyphen will be in the same + // cluster with the next codepoint, since there is no pre-context. + addHyphenToHbBuffer(buffer, hbFont, startHyphen, 0 /* cluster value */); + } + + const uint16_t* hbText; + int hbTextLength; + unsigned int hbItemOffset; + unsigned int hbItemLength = scriptRunEnd - scriptRunStart; // This is >= 1. + + const bool hasEndInsertion = HyphenEdit::isInsertion(endHyphen); + const bool hasEndReplacement = HyphenEdit::isReplacement(endHyphen); + if (hasEndReplacement) { + // Skip the last code unit while copying the buffer for HarfBuzz if it's a replacement. We + // don't need to worry about non-BMP characters yet since replacements are only done for + // code units at the moment. + hbItemLength -= 1; + } + + if (startHyphen == HyphenEdit::NO_EDIT) { + // No edit at the beginning. Use the whole pre-context. + hbText = buf; + hbItemOffset = start + scriptRunStart; + } else { + // There's an edit at the beginning. Drop the pre-context and start the buffer at where we + // want to start shaping. + hbText = buf + start + scriptRunStart; + hbItemOffset = 0; + } + + if (endHyphen == HyphenEdit::NO_EDIT) { + // No edit at the end, use the whole post-context. + hbTextLength = (buf + bufSize) - hbText; + } else { + // There is an edit at the end. Drop the post-context. + hbTextLength = hbItemOffset + hbItemLength; + } + + hb_buffer_add_utf16(buffer, hbText, hbTextLength, hbItemOffset, hbItemLength); + + unsigned int numCodepoints; + hb_glyph_info_t* cpInfo = hb_buffer_get_glyph_infos(buffer, &numCodepoints); + + // Add the hyphen at the end, if there's any. + if (hasEndInsertion || hasEndReplacement) { + // When a hyphen is inserted, by assigning the added hyphen and the last + // codepoint added to the HarfBuzz buffer to the same cluster, we can make sure + // that they always remain in the same cluster, even if the last codepoint gets + // merged into another cluster (for example when it's a combining mark). + // + // When a replacement happens instead, we want it to get the cluster value of + // the character it's replacing, which is one "codepoint length" larger than + // the last cluster. But since the character replaced is always just one + // code unit, we can just add 1. + uint32_t hyphenCluster; + if (numCodepoints == 0) { + // Nothing was added to the HarfBuzz buffer. This can only happen if + // we have a replacement that is replacing a one-code unit script run. + hyphenCluster = 0; + } else { + hyphenCluster = cpInfo[numCodepoints - 1].cluster + (uint32_t) hasEndReplacement; + } + addHyphenToHbBuffer(buffer, hbFont, endHyphen, hyphenCluster); + // Since we have just added to the buffer, cpInfo no longer necessarily points to + // the right place. Refresh it. + cpInfo = hb_buffer_get_glyph_infos(buffer, nullptr /* we don't need the size */); + } + return cpInfo[0].cluster; +} + + void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, bool isRtl, LayoutContext* ctx) { hb_buffer_t* buffer = LayoutEngine::getInstance().hbBuffer; @@ -769,10 +912,21 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t // 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. - ssize_t srunend; - for (ssize_t srunstart = run.start; srunstart < run.end; srunstart = srunend) { - srunend = srunstart; - hb_script_t script = getScriptRun(buf + start, run.end, &srunend); + + // Note: scriptRunStart and scriptRunEnd, as well as run.start and run.end, run between 0 + // and count. + ssize_t scriptRunEnd; + for (ssize_t scriptRunStart = run.start; + scriptRunStart < run.end; + scriptRunStart = scriptRunEnd) { + scriptRunEnd = scriptRunStart; + hb_script_t script = getScriptRun(buf + start, run.end, &scriptRunEnd /* iterator */); + // After the last line, scriptRunEnd is guaranteed to have increased, since the only + // time getScriptRun does not increase its iterator is when it has already reached the + // end of the buffer. But that can't happen, since if we have already reached the end + // of the buffer, we should have had (scriptRunEnd == run.end), which means + // (scriptRunStart == run.end) which is impossible due to the exit condition of the for + // loop. So we can be sure that scriptRunEnd > scriptRunStart. double letterSpace = 0.0; double letterSpaceHalfLeft = 0.0; @@ -804,30 +958,29 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t } hb_buffer_set_language(buffer, hbLanguage->getHbLanguage()); } - hb_buffer_add_utf16(buffer, buf, bufSize, srunstart + start, srunend - srunstart); - if (ctx->paint.hyphenEdit.hasHyphen() && srunend > srunstart) { - // TODO: check whether this is really the desired semantics. It could have the - // effect of assigning the hyphen width to a nonspacing mark - unsigned int lastCluster = start + srunend - 1; - hb_codepoint_t hyphenChar = 0x2010; // HYPHEN - hb_codepoint_t glyph; - // Fallback to ASCII HYPHEN-MINUS if the font didn't have a glyph for HYPHEN. Note - // that we intentionally don't do anything special if the font doesn't have a - // HYPHEN-MINUS either, so a tofu could be shown, hinting towards something - // missing. - if (!hb_font_get_glyph(hbFont, hyphenChar, 0, &glyph)) { - hyphenChar = 0x002D; // HYPHEN-MINUS - } - hb_buffer_add(buffer, hyphenChar, lastCluster); - } + const uint32_t clusterStart = addToHbBuffer( + buffer, + buf, start, count, bufSize, + scriptRunStart, scriptRunEnd, + ctx->paint.hyphenEdit, hbFont); + hb_shape(hbFont, buffer, features.empty() ? NULL : &features[0], features.size()); unsigned int numGlyphs; hb_glyph_info_t* info = hb_buffer_get_glyph_infos(buffer, &numGlyphs); hb_glyph_position_t* positions = hb_buffer_get_glyph_positions(buffer, NULL); + + // At this point in the code, the cluster values in the info buffer correspond to the + // input characters with some shift. The cluster value clusterStart corresponds to the + // first character passed to HarfBuzz, which is at buf[start + scriptRunStart] whose + // advance needs to be saved into mAdvances[scriptRunStart]. So cluster values need to + // be reduced by (clusterStart - scriptRunStart) to get converted to indices of + // mAdvances. + const ssize_t clusterOffset = clusterStart - scriptRunStart; + if (numGlyphs) { - mAdvances[info[0].cluster - start] += letterSpaceHalfLeft; + mAdvances[info[0].cluster - clusterOffset] += letterSpaceHalfLeft; x += letterSpaceHalfLeft; } for (unsigned int i = 0; i < numGlyphs; i++) { @@ -840,8 +993,8 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t positions[i].x_offset, positions[i].y_offset); #endif if (i > 0 && info[i - 1].cluster != info[i].cluster) { - mAdvances[info[i - 1].cluster - start] += letterSpaceHalfRight; - mAdvances[info[i].cluster - start] += letterSpaceHalfLeft; + mAdvances[info[i - 1].cluster - clusterOffset] += letterSpaceHalfRight; + mAdvances[info[i].cluster - clusterOffset] += letterSpaceHalfLeft; x += letterSpace; } @@ -871,17 +1024,17 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t } glyphBounds.offset(x + xoff, y + yoff); mBounds.join(glyphBounds); - if (info[i].cluster - start < count) { - mAdvances[info[i].cluster - start] += xAdvance; + if (static_cast(info[i].cluster - clusterOffset) < count) { + mAdvances[info[i].cluster - clusterOffset] += xAdvance; } else { ALOGE("cluster %zu (start %zu) out of bounds of count %zu", - info[i].cluster - start, start, count); + info[i].cluster - clusterOffset, start, count); } x += xAdvance; } if (numGlyphs) { - mAdvances[info[numGlyphs - 1].cluster - start] += letterSpaceHalfRight; + mAdvances[info[numGlyphs - 1].cluster - clusterOffset] += letterSpaceHalfRight; x += letterSpaceHalfRight; } } diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 3965cbd4c8..b8814b63d4 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -63,7 +63,7 @@ const float SHRINKABILITY = 1.0 / 3.0; void LineBreaker::setLocale(const icu::Locale& locale, Hyphenator* hyphenator) { mWordBreaker.setLocale(locale); - + mLocale = locale; mHyphenator = hyphenator; } @@ -73,7 +73,7 @@ void LineBreaker::setText() { // handle initial break here because addStyleRun may never be called mWordBreaker.next(); mCandidates.clear(); - Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0, 0, 0, 0, 0}; + Candidate cand = {0, 0, 0.0, 0.0, 0.0, 0.0, 0, 0, 0, HyphenationType::DONT_BREAK}; mCandidates.push_back(cand); // reset greedy breaker state @@ -106,24 +106,6 @@ static bool isLineEndSpace(uint16_t c) { c == 0x205F || c == 0x3000; } -// This function determines whether a character is like U+2010 HYPHEN in -// line breaking and usage: a character immediately after which line breaks -// are allowed, but words containing it should not be automatically -// hyphenated. This is a curated set, created by manually inspecting all -// the characters that have the Unicode line breaking property of BA or HY -// and seeing which ones are hyphens. -static bool isLineBreakingHyphen(uint16_t c) { - return (c == 0x002D || // HYPHEN-MINUS - c == 0x058A || // ARMENIAN HYPHEN - c == 0x05BE || // HEBREW PUNCTUATION MAQAF - c == 0x1400 || // CANADIAN SYLLABICS HYPHEN - c == 0x2010 || // HYPHEN - c == 0x2013 || // EN DASH - c == 0x2027 || // HYPHENATION POINT - c == 0x2E17 || // DOUBLE OBLIQUE HYPHEN - c == 0x2E40); // DOUBLE HYPHEN -} - // Ordinarily, this method measures the text in the range given. However, when paint // is nullptr, it assumes the widths have already been calculated and stored in the // width buffer. @@ -161,7 +143,6 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const std::shared_ptr= start && wordEnd > wordStart && wordEnd - wordStart <= LONGEST_HYPHENATED_WORD) { - mHyphenator->hyphenate(&mHyphBuf, &mTextBuf[wordStart], wordEnd - wordStart); + mHyphenator->hyphenate(&mHyphBuf, + &mTextBuf[wordStart], + wordEnd - wordStart, + mLocale); #if VERBOSE_DEBUG std::string hyphenatedString; for (size_t j = wordStart; j < wordEnd; j++) { - if (mHyphBuf[j - wordStart]) hyphenatedString.push_back('-'); + if (mHyphBuf[j - wordStart] == HyphenationType::BREAK_AND_INSERT_HYPHEN) { + hyphenatedString.push_back('-'); + } // Note: only works with ASCII, should do UTF-8 conversion here hyphenatedString.push_back(buffer()[j]); } @@ -204,32 +186,33 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const std::shared_ptrhyphenEdit = hyph; - + HyphenationType hyph = mHyphBuf[j - wordStart]; + if (hyph != HyphenationType::DONT_BREAK) { + paint->hyphenEdit = HyphenEdit::editForThisLine(hyph); const float firstPartWidth = Layout::measureText(mTextBuf.data(), lastBreak, j - lastBreak, mTextBuf.size(), bidiFlags, style, *paint, typeface, nullptr); ParaWidth hyphPostBreak = lastBreakWidth + firstPartWidth; - paint->hyphenEdit = 0; + paint->hyphenEdit = HyphenEdit::editForNextLine(hyph); const float secondPartWidth = Layout::measureText(mTextBuf.data(), j, afterWord - j, mTextBuf.size(), bidiFlags, style, *paint, typeface, nullptr); ParaWidth hyphPreBreak = postBreak - secondPartWidth; + addWordBreak(j, hyphPreBreak, hyphPostBreak, postSpaceCount, postSpaceCount, hyphenPenalty, hyph); + + paint->hyphenEdit = HyphenEdit::NO_EDIT; } } } - // Skip hyphenating the next word if and only if the present word ends in a hyphen - temporarilySkipHyphenation = wordEndsInHyphen; // Skip break for zero-width characters inside replacement span if (paint != nullptr || current == end || mCharWidths[current] > 0) { float penalty = hyphenPenalty * mWordBreaker.breakBadness(); - addWordBreak(current, mWidth, postBreak, mSpaceCount, postSpaceCount, penalty, 0); + addWordBreak(current, mWidth, postBreak, mSpaceCount, postSpaceCount, penalty, + HyphenationType::DONT_BREAK); } lastBreak = current; lastBreakWidth = mWidth; @@ -243,7 +226,7 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const std::shared_ptr currentLineWidth()) { @@ -262,7 +245,7 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.preSpaceCount = postSpaceCount; cand.postSpaceCount = postSpaceCount; cand.penalty = SCORE_DESPERATE; - cand.hyphenEdit = 0; + cand.hyphenType = HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN; #if VERBOSE_DEBUG ALOGD("desperate cand: %zd %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); @@ -279,7 +262,7 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post cand.penalty = penalty; cand.preSpaceCount = preSpaceCount; cand.postSpaceCount = postSpaceCount; - cand.hyphenEdit = hyph; + cand.hyphenType = hyph; #if VERBOSE_DEBUG ALOGD("cand: %zd %g:%g", mCandidates.size(), cand.postBreak, cand.preBreak); #endif @@ -296,7 +279,7 @@ void LineBreaker::addCandidate(Candidate cand) { mBestBreak = candIndex; } pushBreak(mCandidates[mBestBreak].offset, mCandidates[mBestBreak].postBreak - mPreBreak, - mCandidates[mBestBreak].hyphenEdit); + HyphenEdit::editForThisLine(mCandidates[mBestBreak].hyphenType)); mBestScore = SCORE_INFTY; #if VERBOSE_DEBUG ALOGD("break: %d %g", mBreaks.back(), mWidths.back()); @@ -310,11 +293,11 @@ void LineBreaker::addCandidate(Candidate cand) { } } -void LineBreaker::pushBreak(int offset, float width, uint8_t hyph) { +void LineBreaker::pushBreak(int offset, float width, uint8_t hyphenEdit) { mBreaks.push_back(offset); mWidths.push_back(width); int flags = (mFirstTabIndex < mBreaks.back()) << kTab_Shift; - flags |= hyph; + flags |= hyphenEdit; mFlags.push_back(flags); mFirstTabIndex = INT_MAX; } @@ -345,7 +328,8 @@ void LineBreaker::computeBreaksGreedy() { // All breaks but the last have been added in addCandidate already. size_t nCand = mCandidates.size(); if (nCand == 1 || mLastBreak != nCand - 1) { - pushBreak(mCandidates[nCand - 1].offset, mCandidates[nCand - 1].postBreak - mPreBreak, 0); + pushBreak(mCandidates[nCand - 1].offset, mCandidates[nCand - 1].postBreak - mPreBreak, + HyphenEdit::NO_EDIT); // don't need to update mBestScore, because we're done #if VERBOSE_DEBUG ALOGD("final break: %d %g", mBreaks.back(), mWidths.back()); @@ -365,7 +349,11 @@ void LineBreaker::finishBreaksOptimal() { prev = mCandidates[i].prev; mBreaks.push_back(mCandidates[i].offset); mWidths.push_back(mCandidates[i].postBreak - mCandidates[prev].preBreak); - mFlags.push_back(mCandidates[i].hyphenEdit); + int flags = HyphenEdit::editForThisLine(mCandidates[i].hyphenType); + if (prev > 0) { + flags |= HyphenEdit::editForNextLine(mCandidates[prev].hyphenType); + } + mFlags.push_back(flags); } std::reverse(mBreaks.begin(), mBreaks.end()); std::reverse(mWidths.begin(), mWidths.end()); diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index 82596f8a04..7ad7242dff 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -19,6 +19,7 @@ #include #include +#include #include "MinikinInternal.h" #include @@ -74,7 +75,8 @@ static bool isBreakValid(const uint16_t* buf, size_t bufEnd, size_t i) { uint32_t codePoint; size_t prev_offset = i; U16_PREV(buf, 0, prev_offset, codePoint); - if (codePoint == CHAR_SOFT_HYPHEN) { + // Do not break on hard or soft hyphens. These are handled by automatic hyphenation. + if (Hyphenator::isLineBreakingHyphen(codePoint) || codePoint == CHAR_SOFT_HYPHEN) { return false; } // For Myanmar kinzi sequences, created by . This is to go diff --git a/engine/src/flutter/tests/perftests/Hyphenator.cpp b/engine/src/flutter/tests/perftests/Hyphenator.cpp index 692e06d2bf..1e6411f76d 100644 --- a/engine/src/flutter/tests/perftests/Hyphenator.cpp +++ b/engine/src/flutter/tests/perftests/Hyphenator.cpp @@ -22,13 +22,14 @@ namespace minikin { const char* enUsHyph = "/system/usr/hyphen-data/hyph-en-us.hyb"; +const icu::Locale& usLocale = icu::Locale::getUS(); static void BM_Hyphenator_short_word(benchmark::State& state) { Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(enUsHyph).data()); std::vector word = utf8ToUtf16("hyphen"); - std::vector result; + std::vector result; while (state.KeepRunning()) { - hyphenator->hyphenate(&result, word.data(), word.size()); + hyphenator->hyphenate(&result, word.data(), word.size(), usLocale); } Hyphenator::loadBinary(nullptr); } @@ -40,9 +41,9 @@ static void BM_Hyphenator_long_word(benchmark::State& state) { Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(enUsHyph).data()); std::vector word = utf8ToUtf16( "Pneumonoultramicroscopicsilicovolcanoconiosis"); - std::vector result; + std::vector result; while (state.KeepRunning()) { - hyphenator->hyphenate(&result, word.data(), word.size()); + hyphenator->hyphenate(&result, word.data(), word.size(), usLocale); } Hyphenator::loadBinary(nullptr); } diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index 7b3f60f8f9..da7851a3e7 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -62,6 +62,7 @@ LOCAL_STATIC_LIBRARIES += \ libxml2 LOCAL_SRC_FILES += \ + ../util/FileUtils.cpp \ ../util/FontTestUtils.cpp \ ../util/MinikinFontForTest.cpp \ ../util/UnicodeUtils.cpp \ @@ -70,6 +71,7 @@ LOCAL_SRC_FILES += \ FontFamilyTest.cpp \ FontLanguageListCacheTest.cpp \ HbFontCacheTest.cpp \ + HyphenatorTest.cpp \ MinikinInternalTest.cpp \ GraphemeBreakTests.cpp \ LayoutTest.cpp \ diff --git a/engine/src/flutter/tests/unittest/HyphenatorTest.cpp b/engine/src/flutter/tests/unittest/HyphenatorTest.cpp new file mode 100644 index 0000000000..6265c2c6c1 --- /dev/null +++ b/engine/src/flutter/tests/unittest/HyphenatorTest.cpp @@ -0,0 +1,335 @@ +/* + * Copyright (C) 2017 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 + +#include "ICUTestBase.h" +#include +#include + +#ifndef NELEM +#define NELEM(x) ((sizeof(x) / sizeof((x)[0]))) +#endif + +namespace minikin { + +const char* usHyph = "/system/usr/hyphen-data/hyph-en-us.hyb"; +const char* malayalamHyph = "/system/usr/hyphen-data/hyph-ml.hyb"; + +typedef ICUTestBase HyphenatorTest; + +const icu::Locale catalanLocale("ca", "ES", nullptr, nullptr); +const icu::Locale polishLocale("pl", "PL", nullptr, nullptr); +const icu::Locale& usLocale = icu::Locale::getUS(); + +const uint16_t HYPHEN_MINUS = 0x002D; +const uint16_t SOFT_HYPHEN = 0x00AD; +const uint16_t MIDDLE_DOT = 0x00B7; +const uint16_t GREEK_LOWER_ALPHA = 0x03B1; +const uint16_t ARMENIAN_AYB = 0x0531; +const uint16_t HEBREW_ALEF = 0x05D0; +const uint16_t ARABIC_ALEF = 0x0627; +const uint16_t ARABIC_BEH = 0x0628; +const uint16_t ARABIC_ZWARAKAY = 0x0659; +const uint16_t MALAYALAM_KA = 0x0D15; +const uint16_t UCAS_E = 0x1401; +const uint16_t HYPHEN = 0x2010; +const uint16_t EN_DASH = 0x2013; + +// Simple test for US English. This tests "table", which happens to be the in the exceptions list. +TEST_F(HyphenatorTest, usEnglishAutomaticHyphenation) { + Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(usHyph).data()); + const uint16_t word[] = {'t', 'a', 'b', 'l', 'e'}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 5, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_HYPHEN, result[2]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[3]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[4]); +} + +// Catalan l·l should break as l-/l +TEST_F(HyphenatorTest, catalanMiddleDot) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {'l', 'l', MIDDLE_DOT, 'l', 'l', 'l'}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), catalanLocale); + EXPECT_EQ((size_t) 6, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[2]); + EXPECT_EQ(HyphenationType::BREAK_AND_REPLACE_WITH_HYPHEN, result[3]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[4]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[5]); +} + +// Catalan l·l should not break if the word is too short. +TEST_F(HyphenatorTest, catalanMiddleDotShortWord) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {'l', MIDDLE_DOT, 'l'}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), catalanLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[2]); +} + +// If we break on a hyphen in Polish, the hyphen should be repeated on the next line. +TEST_F(HyphenatorTest, polishHyphen) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {'x', HYPHEN, 'y'}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), polishLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_HYPHEN_AT_NEXT_LINE, result[2]); +} + +// If the language is Polish but the script is not Latin, don't use Polish rules for hyphenation. +TEST_F(HyphenatorTest, polishHyphenButNonLatinWord) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {GREEK_LOWER_ALPHA, HYPHEN, GREEK_LOWER_ALPHA}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), polishLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN, result[2]); +} + +// Polish en dash doesn't repeat on next line (as far as we know), but just provides a break +// opportunity. +TEST_F(HyphenatorTest, polishEnDash) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {'x', EN_DASH, 'y'}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), polishLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN, result[2]); +} + +// In Latin script text, soft hyphens should insert a visible hyphen if broken at. +TEST_F(HyphenatorTest, latinSoftHyphen) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {'x', SOFT_HYPHEN, 'y'}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_HYPHEN, result[2]); +} + +// Soft hyphens at the beginning of a word are not useful in linebreaking. +TEST_F(HyphenatorTest, latinSoftHyphenStartingTheWord) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {SOFT_HYPHEN, 'y'}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 2, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); +} + +// In Malayalam script text, soft hyphens should not insert a visible hyphen if broken at. +TEST_F(HyphenatorTest, malayalamSoftHyphen) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {MALAYALAM_KA, SOFT_HYPHEN, MALAYALAM_KA}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN, result[2]); +} + +// In automatically hyphenated Malayalam script text, we should not insert a visible hyphen. +TEST_F(HyphenatorTest, malayalamAutomaticHyphenation) { + Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(malayalamHyph).data()); + const uint16_t word[] = { + MALAYALAM_KA, MALAYALAM_KA, MALAYALAM_KA, MALAYALAM_KA, MALAYALAM_KA}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 5, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN, result[2]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[3]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[4]); +} + +// In Armenian script text, soft hyphens should insert an Armenian hyphen if broken at. +TEST_F(HyphenatorTest, aremenianSoftHyphen) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {ARMENIAN_AYB, SOFT_HYPHEN, ARMENIAN_AYB}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_ARMENIAN_HYPHEN, result[2]); +} + +// In Hebrew script text, soft hyphens should insert a normal hyphen if broken at, for now. +// We may need to change this to maqaf later. +TEST_F(HyphenatorTest, hebrewSoftHyphen) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {HEBREW_ALEF, SOFT_HYPHEN, HEBREW_ALEF}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_HYPHEN, result[2]); +} + +// Soft hyphen between two Arabic letters that join should keep the joining +// behavior when broken across lines. +TEST_F(HyphenatorTest, arabicSoftHyphenConnecting) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {ARABIC_BEH, SOFT_HYPHEN, ARABIC_BEH}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_HYPHEN_AND_ZWJ, result[2]); +} + +// Arabic letters may be joining on one side, but if it's the wrong side, we +// should use the normal hyphen. +TEST_F(HyphenatorTest, arabicSoftHyphenNonConnecting) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {ARABIC_ALEF, SOFT_HYPHEN, ARABIC_BEH}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_HYPHEN, result[2]); +} + +// Skip transparent characters until you find a non-transparent one. +TEST_F(HyphenatorTest, arabicSoftHyphenSkipTransparents) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {ARABIC_BEH, ARABIC_ZWARAKAY, SOFT_HYPHEN, ARABIC_ZWARAKAY, ARABIC_BEH}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 5, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[2]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_HYPHEN_AND_ZWJ, result[3]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[4]); +} + +// Skip transparent characters until you find a non-transparent one. If we get to one end without +// finding anything, we are still non-joining. +TEST_F(HyphenatorTest, arabicSoftHyphenTransparentsAtEnd) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {ARABIC_BEH, ARABIC_ZWARAKAY, SOFT_HYPHEN, ARABIC_ZWARAKAY}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 4, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[2]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_HYPHEN, result[3]); +} + +// Skip transparent characters until you find a non-transparent one. If we get to one end without +// finding anything, we are still non-joining. +TEST_F(HyphenatorTest, arabicSoftHyphenTransparentsAtStart) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {ARABIC_ZWARAKAY, SOFT_HYPHEN, ARABIC_ZWARAKAY, ARABIC_BEH}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 4, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_HYPHEN, result[2]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[3]); +} + +// In Unified Canadian Aboriginal script (UCAS) text, soft hyphens should insert a UCAS hyphen. +TEST_F(HyphenatorTest, ucasSoftHyphen) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {UCAS_E, SOFT_HYPHEN, UCAS_E}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_UCAS_HYPHEN, result[2]); +} + +// Presently, soft hyphen looks at the character after it to determine hyphenation type. This is a +// little arbitrary, but let's test it anyway. +TEST_F(HyphenatorTest, mixedScriptSoftHyphen) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {'a', SOFT_HYPHEN, UCAS_E}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_INSERT_UCAS_HYPHEN, result[2]); +} + +// Hard hyphens provide a breaking opportunity with nothing extra inserted. +TEST_F(HyphenatorTest, hardHyphen) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {'x', HYPHEN, 'y'}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN, result[2]); +} + +// Hyphen-minuses also provide a breaking opportunity with nothing extra inserted. +TEST_F(HyphenatorTest, hyphenMinus) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {'x', HYPHEN_MINUS, 'y'}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 3, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); + EXPECT_EQ(HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN, result[2]); +} + +// If the word starts with a hard hyphen or hyphen-minus, it doesn't make sense to break +// it at that point. +TEST_F(HyphenatorTest, startingHyphenMinus) { + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + const uint16_t word[] = {HYPHEN_MINUS, 'y'}; + std::vector result; + hyphenator->hyphenate(&result, word, NELEM(word), usLocale); + EXPECT_EQ((size_t) 2, result.size()); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); + EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); +} + +} // namespace minikin + diff --git a/engine/src/flutter/tests/unittest/LayoutTest.cpp b/engine/src/flutter/tests/unittest/LayoutTest.cpp index 4a849aa3eb..ed41ca4574 100644 --- a/engine/src/flutter/tests/unittest/LayoutTest.cpp +++ b/engine/src/flutter/tests/unittest/LayoutTest.cpp @@ -356,6 +356,53 @@ TEST_F(LayoutTest, doLayoutTest_rtlTest) { } } +TEST_F(LayoutTest, hyphenationTest) { + Layout layout(mCollection); + std::vector text; + + // The mock implementation returns 10.0f advance for all glyphs. + { + SCOPED_TRACE("one word with no hyphen edit"); + text = utf8ToUtf16("oneword"); + MinikinPaint paint; + paint.hyphenEdit = HyphenEdit::NO_EDIT; + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(70.0f, layout.getAdvance()); + } + { + SCOPED_TRACE("one word with hyphen insertion at the end"); + text = utf8ToUtf16("oneword"); + MinikinPaint paint; + paint.hyphenEdit = HyphenEdit::INSERT_HYPHEN_AT_END; + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(80.0f, layout.getAdvance()); + } + { + SCOPED_TRACE("one word with hyphen replacement at the end"); + text = utf8ToUtf16("oneword"); + MinikinPaint paint; + paint.hyphenEdit = HyphenEdit::REPLACE_WITH_HYPHEN_AT_END; + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(70.0f, layout.getAdvance()); + } + { + SCOPED_TRACE("one word with hyphen insertion at the start"); + text = utf8ToUtf16("oneword"); + MinikinPaint paint; + paint.hyphenEdit = HyphenEdit::INSERT_HYPHEN_AT_START; + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(80.0f, layout.getAdvance()); + } + { + SCOPED_TRACE("one word with hyphen insertion at the both ends"); + text = utf8ToUtf16("oneword"); + MinikinPaint paint; + paint.hyphenEdit = HyphenEdit::INSERT_HYPHEN_AT_START | HyphenEdit::INSERT_HYPHEN_AT_END; + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + EXPECT_EQ(90.0f, layout.getAdvance()); + } +} + // TODO: Add more test cases, e.g. measure text, letter spacing. } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/WordBreakerTests.cpp b/engine/src/flutter/tests/unittest/WordBreakerTests.cpp index dc46c19d24..7971b49070 100644 --- a/engine/src/flutter/tests/unittest/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/unittest/WordBreakerTests.cpp @@ -39,7 +39,7 @@ typedef ICUTestBase WordBreakerTest; TEST_F(WordBreakerTest, basic) { uint16_t buf[] = {'h', 'e', 'l', 'l' ,'o', ' ', 'w', 'o', 'r', 'l', 'd'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(6, breaker.next()); // after "hello " @@ -57,7 +57,7 @@ TEST_F(WordBreakerTest, basic) { TEST_F(WordBreakerTest, softHyphen) { uint16_t buf[] = {'h', 'e', 'l', 0x00AD, 'l' ,'o', ' ', 'w', 'o', 'r', 'l', 'd'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(7, breaker.next()); // after "hel{SOFT HYPHEN}lo " @@ -70,10 +70,23 @@ TEST_F(WordBreakerTest, softHyphen) { EXPECT_EQ(0, breaker.breakBadness()); } +TEST_F(WordBreakerTest, hardHyphen) { + // Hyphens should not allow breaks anymore. + uint16_t buf[] = {'s', 'u', 'g', 'a', 'r', '-', 'f', 'r', 'e', 'e'}; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getUS()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); + EXPECT_EQ(0, breaker.wordStart()); + EXPECT_EQ((ssize_t)NELEM(buf), breaker.wordEnd()); + EXPECT_EQ(0, breaker.breakBadness()); +} + TEST_F(WordBreakerTest, postfixAndPrefix) { uint16_t buf[] = {'U', 'S', 0x00A2, ' ', 'J', 'P', 0x00A5}; // US¢ JP¥ WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); @@ -111,7 +124,7 @@ TEST_F(WordBreakerTest, zwjEmojiSequences) { UTF16(0x1F431), 0x200D, UTF16(0x1F464), }; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(7, breaker.next()); // after man + zwj + heart + zwj + man @@ -134,7 +147,7 @@ TEST_F(WordBreakerTest, emojiWithModifier) { 0x270C, 0xFE0F, UTF16(0x1F3FF) // victory hand + emoji style + type 6 fitzpatrick modifier }; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(4, breaker.next()); // after boy + type 1-2 fitzpatrick modifier @@ -157,7 +170,7 @@ TEST_F(WordBreakerTest, flagsSequenceSingleFlag) { ParseUnicode(buf, BUF_SIZE, flags.c_str(), &size, nullptr); WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, size); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(kFlagLength, breaker.next()); // end of the first flag @@ -182,7 +195,7 @@ TEST_F(WordBreakerTest, flagsSequence) { ParseUnicode(buf, BUF_SIZE, flagSequence.c_str(), &size, nullptr); WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, size); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(kFlagLength, breaker.next()); // end of the first flag sequence @@ -197,7 +210,7 @@ TEST_F(WordBreakerTest, punct) { uint16_t buf[] = {0x00A1, 0x00A1, 'h', 'e', 'l', 'l' ,'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', '!'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(9, breaker.next()); // after "¡¡hello, " @@ -214,7 +227,7 @@ TEST_F(WordBreakerTest, email) { uint16_t buf[] = {'f', 'o', 'o', '@', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', ' ', 'x'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(11, breaker.next()); // after "foo@example" @@ -233,7 +246,7 @@ TEST_F(WordBreakerTest, mailto) { uint16_t buf[] = {'m', 'a', 'i', 'l', 't', 'o', ':', 'f', 'o', 'o', '@', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', ' ', 'x'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(7, breaker.next()); // after "mailto:" @@ -257,7 +270,7 @@ TEST_F(WordBreakerTest, emailNonAscii) { uint16_t buf[] = {'f', 'o', 'o', '@', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', 0x4E00}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(11, breaker.next()); // after "foo@example" @@ -276,7 +289,7 @@ TEST_F(WordBreakerTest, emailCombining) { uint16_t buf[] = {'f', 'o', 'o', '@', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', 0x0303, ' ', 'x'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(11, breaker.next()); // after "foo@example" @@ -294,7 +307,7 @@ TEST_F(WordBreakerTest, emailCombining) { TEST_F(WordBreakerTest, lonelyAt) { uint16_t buf[] = {'a', ' ', '@', ' ', 'b'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(2, breaker.next()); // after "a " @@ -314,7 +327,7 @@ TEST_F(WordBreakerTest, url) { uint16_t buf[] = {'h', 't', 't', 'p', ':', '/', '/', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', ' ', 'x'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(5, breaker.next()); // after "http:" @@ -340,7 +353,7 @@ TEST_F(WordBreakerTest, urlBreakChars) { uint16_t buf[] = {'h', 't', 't', 'p', ':', '/', '/', 'a', '.', 'b', '/', '~', 'c', ',', 'd', '-', 'e', '?', 'f', '=', 'g', '&', 'h', '#', 'i', '%', 'j', '_', 'k', '/', 'l'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(5, breaker.next()); // after "http:" @@ -399,7 +412,7 @@ TEST_F(WordBreakerTest, urlBreakChars) { TEST_F(WordBreakerTest, urlNoHyphenBreak) { uint16_t buf[] = {'h', 't', 't', 'p', ':', '/', '/', 'a', '-', '/', 'b'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(5, breaker.next()); // after "http:" @@ -415,7 +428,7 @@ TEST_F(WordBreakerTest, urlNoHyphenBreak) { TEST_F(WordBreakerTest, urlEndsWithSlash) { uint16_t buf[] = {'h', 't', 't', 'p', ':', '/', '/', 'a', '/'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ(5, breaker.next()); // after "http:" @@ -431,7 +444,7 @@ TEST_F(WordBreakerTest, urlEndsWithSlash) { TEST_F(WordBreakerTest, emailStartsWithSlash) { uint16_t buf[] = {'/', 'a', '@', 'b'}; WordBreaker breaker; - breaker.setLocale(icu::Locale::getEnglish()); + breaker.setLocale(icu::Locale::getUS()); breaker.setText(buf, NELEM(buf)); EXPECT_EQ(0, breaker.current()); EXPECT_EQ((ssize_t)NELEM(buf), breaker.next()); // end From 22d4e7e3f34ebd01aac522a0a7022a43941e5269 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Mon, 6 Mar 2017 14:05:23 -0800 Subject: [PATCH 237/364] Remove sample directory Since there are no known users of Minikin outside Android yet, these files are simply a maintenance burden with no actual benefit. Removing the samples until there are potential external users. Test: Not needed Change-Id: If7f1fb775cae427fbe31b86c202d1380c701bf28 --- engine/src/flutter/sample/Android.mk | 69 ---------- engine/src/flutter/sample/MinikinSkia.cpp | 68 ---------- engine/src/flutter/sample/MinikinSkia.h | 40 ------ engine/src/flutter/sample/example.cpp | 100 -------------- engine/src/flutter/sample/example_skia.cpp | 150 --------------------- 5 files changed, 427 deletions(-) delete mode 100644 engine/src/flutter/sample/Android.mk delete mode 100644 engine/src/flutter/sample/MinikinSkia.cpp delete mode 100644 engine/src/flutter/sample/MinikinSkia.h delete mode 100644 engine/src/flutter/sample/example.cpp delete mode 100644 engine/src/flutter/sample/example_skia.cpp diff --git a/engine/src/flutter/sample/Android.mk b/engine/src/flutter/sample/Android.mk deleted file mode 100644 index c4a644d74d..0000000000 --- a/engine/src/flutter/sample/Android.mk +++ /dev/null @@ -1,69 +0,0 @@ -# Copyright (C) 2013 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -LOCAL_PATH:= $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_MODULE_TAGS := tests - -LOCAL_C_INCLUDES += \ - external/harfbuzz_ng/src \ - external/freetype/include \ - frameworks/minikin/include - -LOCAL_SRC_FILES:= example.cpp - -LOCAL_SHARED_LIBRARIES += \ - libutils \ - liblog \ - libcutils \ - libharfbuzz_ng \ - libicuuc \ - libft2 \ - libpng \ - libz \ - libminikin - -LOCAL_MODULE:= minikin_example - -include $(BUILD_EXECUTABLE) - - -include $(CLEAR_VARS) - -LOCAL_MODULE_TAG := tests - -LOCAL_C_INCLUDES += \ - external/harfbuzz_ng/src \ - external/freetype/include \ - frameworks/minikin/include \ - external/skia/src/core - -LOCAL_SRC_FILES:= example_skia.cpp \ - MinikinSkia.cpp - -LOCAL_SHARED_LIBRARIES += \ - libutils \ - liblog \ - libcutils \ - libharfbuzz_ng \ - libicuuc \ - libskia \ - libminikin \ - libft2 - -LOCAL_MODULE:= minikin_skia_example - -include $(BUILD_EXECUTABLE) diff --git a/engine/src/flutter/sample/MinikinSkia.cpp b/engine/src/flutter/sample/MinikinSkia.cpp deleted file mode 100644 index 1ba7cccb41..0000000000 --- a/engine/src/flutter/sample/MinikinSkia.cpp +++ /dev/null @@ -1,68 +0,0 @@ -#include -#include - -#include -#include "MinikinSkia.h" - -namespace minikin { - -MinikinFontSkia::MinikinFontSkia(sk_sp typeface) : - MinikinFont(typeface->uniqueID()), - mTypeface(std::move(typeface)) { -} - -static void MinikinFontSkia_SetSkiaPaint(sk_sp typeface, SkPaint* skPaint, const MinikinPaint& paint) { - skPaint->setTypeface(std::move(typeface)); - skPaint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); - // TODO: set more paint parameters from Minikin - skPaint->setTextSize(paint.size); -} - -float MinikinFontSkia::GetHorizontalAdvance(uint32_t glyph_id, - const MinikinPaint &paint) const { - SkPaint skPaint; - uint16_t glyph16 = glyph_id; - SkScalar skWidth; - MinikinFontSkia_SetSkiaPaint(mTypeface, &skPaint, paint); - skPaint.getTextWidths(&glyph16, sizeof(glyph16), &skWidth, NULL); -#ifdef VERBOSE - ALOGD("width for typeface %d glyph %d = %f", mTypeface->uniqueID(), glyph_id -#endif - return skWidth; -} - -void MinikinFontSkia::GetBounds(MinikinRect* bounds, uint32_t glyph_id, - const MinikinPaint& paint) const { - SkPaint skPaint; - uint16_t glyph16 = glyph_id; - SkRect skBounds; - MinikinFontSkia_SetSkiaPaint(mTypeface, &skPaint, paint); - skPaint.getTextWidths(&glyph16, sizeof(glyph16), NULL, &skBounds); - bounds->mLeft = skBounds.fLeft; - bounds->mTop = skBounds.fTop; - bounds->mRight = skBounds.fRight; - bounds->mBottom = skBounds.fBottom; -} - -const void* MinikinFontSkia::GetTable(uint32_t tag, size_t* size, - MinikinDestroyFunc* destroy) const { - // we don't have a buffer to the font data, copy to own buffer - const size_t tableSize = mTypeface->getTableSize(tag); - *size = tableSize; - if (tableSize == 0) { - return nullptr; - } - void* buf = malloc(tableSize); - if (buf == nullptr) { - return nullptr; - } - mTypeface->getTableData(tag, 0, tableSize, buf); - *destroy = free; - return buf; -} - -SkTypeface *MinikinFontSkia::GetSkTypeface() const { - return mTypeface.get(); -} - -} // namespace minikin diff --git a/engine/src/flutter/sample/MinikinSkia.h b/engine/src/flutter/sample/MinikinSkia.h deleted file mode 100644 index 5ebf1b6161..0000000000 --- a/engine/src/flutter/sample/MinikinSkia.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (C) 2016 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. - */ -namespace minikin { - -class MinikinFontSkia : public MinikinFont { -public: - explicit MinikinFontSkia(sk_sp typeface); - - float GetHorizontalAdvance(uint32_t glyph_id, - const MinikinPaint &paint) const; - - void GetBounds(MinikinRect* bounds, uint32_t glyph_id, - const MinikinPaint& paint) const; - - const std::vector& GetAxes() const { - return mAxes; - } - const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) const; - - SkTypeface *GetSkTypeface() const; - -private: - sk_sp mTypeface; - std::vector mAxes; -}; - -} // namespace minikin diff --git a/engine/src/flutter/sample/example.cpp b/engine/src/flutter/sample/example.cpp deleted file mode 100644 index 3df0905003..0000000000 --- a/engine/src/flutter/sample/example.cpp +++ /dev/null @@ -1,100 +0,0 @@ -/* - * Copyright (C) 2013 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// This is a test program that uses Minikin to layout and draw some text. -// At the moment, it just draws a string into /data/local/tmp/foo.pgm. - -#include -#include -#include - -#include -#include - -#include -#include - -using std::vector; -using namespace minikin; - -FT_Library library; // TODO: this should not be a global - -FontCollection *makeFontCollection() { - vector>typefaces; - const char *fns[] = { - "/system/fonts/Roboto-Regular.ttf", - "/system/fonts/Roboto-Italic.ttf", - "/system/fonts/Roboto-BoldItalic.ttf", - "/system/fonts/Roboto-Light.ttf", - "/system/fonts/Roboto-Thin.ttf", - "/system/fonts/Roboto-Bold.ttf", - "/system/fonts/Roboto-ThinItalic.ttf", - "/system/fonts/Roboto-LightItalic.ttf" - }; - - FT_Face face; - FT_Error error; - std::vector fonts; - for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { - const char *fn = fns[i]; - printf("adding %s\n", fn); - error = FT_New_Face(library, fn, 0, &face); - if (error != 0) { - printf("error loading %s, %d\n", fn, error); - } - std::shared_ptr font(new MinikinFontFreeType(face)); - fonts.push_back(Font(font, FontStyle())); - } - std::shared_ptr family(new FontFamily(std::move(fonts))); - typefaces.push_back(family); - -#if 1 - const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; - error = FT_New_Face(library, fn, 0, &face); - std::shared_ptr font(new MinikinFontFreeType(face)); - family.reset(new FontFamily(std::vector({ Font(font, FontStyle()) }))); - typefaces.push_back(family); -#endif - - return new FontCollection(typefaces); -} - -int runMinikinTest() { - FT_Error error = FT_Init_FreeType(&library); - if (error) { - return -1; - } - std::shared_ptr collection(makeFontCollection()); - Layout layout(collection); - const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87"; - int bidiFlags = 0; - FontStyle fontStyle; - MinikinPaint paint; - paint.size = 32; - icu::UnicodeString icuText = icu::UnicodeString::fromUTF8(text); - layout.doLayout(icuText.getBuffer(), 0, icuText.length(), icuText.length(), bidiFlags, fontStyle, paint); - layout.dump(); - Bitmap bitmap(250, 50); - layout.draw(&bitmap, 10, 40, 32); - std::ofstream o; - o.open("/data/local/tmp/foo.pgm", std::ios::out | std::ios::binary); - bitmap.writePnm(o); - return 0; -} - -int main() { - return runMinikinTest(); -} diff --git a/engine/src/flutter/sample/example_skia.cpp b/engine/src/flutter/sample/example_skia.cpp deleted file mode 100644 index 6fa788b9e7..0000000000 --- a/engine/src/flutter/sample/example_skia.cpp +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Copyright (C) 2013 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// This is a test program that uses Minikin to layout and draw some text. -// At the moment, it just draws a string into /data/local/tmp/foo.pgm. - -#include -#include -#include - -#include -#include - -#include -#include - -#include -#include -#include -#include -#include - -#include "MinikinSkia.h" - -using std::vector; - -namespace minikin { - -FT_Library library; // TODO: this should not be a global - -FontCollection *makeFontCollection() { - vector> typefaces; - const char *fns[] = { - "/system/fonts/Roboto-Regular.ttf", - "/system/fonts/Roboto-Italic.ttf", - "/system/fonts/Roboto-BoldItalic.ttf", - "/system/fonts/Roboto-Light.ttf", - "/system/fonts/Roboto-Thin.ttf", - "/system/fonts/Roboto-Bold.ttf", - "/system/fonts/Roboto-ThinItalic.ttf", - "/system/fonts/Roboto-LightItalic.ttf" - }; - - std::vector fonts; - for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) { - const char *fn = fns[i]; - sk_sp skFace = SkTypeface::MakeFromFile(fn); - std::shared_ptr font(new MinikinFontSkia(std::move(skFace))); - fonts.push_back(Font(font, FontStyle())); - } - std::shared_ptr family(new FontFamily(std::move(fonts))); - typefaces.push_back(family); - -#if 1 - const char *fn = "/system/fonts/DroidSansDevanagari-Regular.ttf"; - sk_sp skFace = SkTypeface::MakeFromFile(fn); - std::shared_ptr font(new MinikinFontSkia(std::move(skFace))); - family.reset(new FontFamily(std::vector({ Font(font, FontStyle()) }))); - typefaces.push_back(family); -#endif - return new FontCollection(typefaces); -} - -// Maybe move to MinikinSkia (esp. instead of opening GetSkTypeface publicly)? - -void drawToSkia(SkCanvas *canvas, SkPaint *paint, Layout *layout, float x, float y) { - size_t nGlyphs = layout->nGlyphs(); - uint16_t *glyphs = new uint16_t[nGlyphs]; - SkPoint *pos = new SkPoint[nGlyphs]; - SkTypeface *lastFace = NULL; - SkTypeface *skFace = NULL; - size_t start = 0; - - paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); - for (size_t i = 0; i < nGlyphs; i++) { - const MinikinFontSkia *mfs = static_cast(layout->getFont(i)); - skFace = mfs->GetSkTypeface(); - glyphs[i] = layout->getGlyphId(i); - pos[i].fX = x + layout->getX(i); - pos[i].fY = y + layout->getY(i); - if (i > 0 && skFace != lastFace) { - paint->setTypeface(sk_ref_sp(lastFace)); - canvas->drawPosText(glyphs + start, (i - start) << 1, pos + start, *paint); - start = i; - } - lastFace = skFace; - } - paint->setTypeface(sk_ref_sp(skFace)); - canvas->drawPosText(glyphs + start, (nGlyphs - start) << 1, pos + start, *paint); - delete[] glyphs; - delete[] pos; -} - -int runMinikinTest() { - FT_Error error = FT_Init_FreeType(&library); - if (error) { - return -1; - } - - std::shared_ptr collection(makeFontCollection()); - Layout layout(collection); - const char *text = "fine world \xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5\x87"; - int bidiFlags = 0; - FontStyle fontStyle(7); - MinikinPaint minikinPaint; - minikinPaint.size = 32; - icu::UnicodeString icuText = icu::UnicodeString::fromUTF8(text); - layout.doLayout(icuText.getBuffer(), 0, icuText.length(), icuText.length(), bidiFlags, fontStyle, minikinPaint); - layout.dump(); - - SkAutoGraphics ag; - - int width = 800; - int height = 600; - SkBitmap bitmap; - bitmap.allocN32Pixels(width, height); - SkCanvas canvas(bitmap); - SkPaint paint; - paint.setARGB(255, 0, 0, 128); - paint.setStyle(SkPaint::kStroke_Style); - paint.setStrokeWidth(2); - paint.setTextSize(100); - paint.setAntiAlias(true); - canvas.drawLine(10, 300, 10 + layout.getAdvance(), 300, paint); - paint.setStyle(SkPaint::kFill_Style); - drawToSkia(&canvas, &paint, &layout, 10, 300); - - SkFILEWStream file("/data/local/tmp/foo.png"); - SkEncodeImage(&file, bitmap, SkEncodedImageFormat::kPNG, 100); - return 0; -} - -} // namespace minikin - -int main(int argc, const char** argv) { - return minikin::runMinikinTest(); -} From 068c7ba2eab4cd546f74665d7a9bcc549584d5ce Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Mon, 27 Feb 2017 18:54:01 -0800 Subject: [PATCH 238/364] Customizable min suffix/prefix length for hyphenation in Minikin With this change, different languages can have a different minimum length for suffix and prefixes when hyphenating. Previously, the defaults used for English, 2 and 3, were used for every language. Bug: 35712376 Test: Minikin unit tests were updated and the pass Change-Id: Iffaf11c6b208c57d28d45b17246e177572dc1210 --- engine/src/flutter/app/HyphTool.cpp | 6 +-- .../src/flutter/include/minikin/Hyphenator.h | 8 +-- .../src/flutter/libs/minikin/Hyphenator.cpp | 16 +++--- .../flutter/tests/perftests/Hyphenator.cpp | 12 +++-- .../flutter/tests/unittest/HyphenatorTest.cpp | 51 +++++++++---------- 5 files changed, 47 insertions(+), 46 deletions(-) diff --git a/engine/src/flutter/app/HyphTool.cpp b/engine/src/flutter/app/HyphTool.cpp index cdb1466f40..403d37439a 100644 --- a/engine/src/flutter/app/HyphTool.cpp +++ b/engine/src/flutter/app/HyphTool.cpp @@ -11,7 +11,7 @@ using minikin::HyphenationType; using minikin::Hyphenator; -Hyphenator* loadHybFile(const char* fn) { +Hyphenator* loadHybFile(const char* fn, int minPrefix, int minSuffix) { struct stat statbuf; int status = stat(fn, &statbuf); if (status < 0) { @@ -32,11 +32,11 @@ Hyphenator* loadHybFile(const char* fn) { delete[] buf; return nullptr; } - return Hyphenator::loadBinary(buf); + return Hyphenator::loadBinary(buf, minPrefix, minSuffix); } int main(int argc, char** argv) { - Hyphenator* hyph = loadHybFile("/tmp/en.hyb"); // should also be configurable + Hyphenator* hyph = loadHybFile("/tmp/en.hyb", 2, 3); // should also be configurable std::vector result; std::vector word; if (argc < 2) { diff --git a/engine/src/flutter/include/minikin/Hyphenator.h b/engine/src/flutter/include/minikin/Hyphenator.h index ea81813745..2b8ccb71a7 100644 --- a/engine/src/flutter/include/minikin/Hyphenator.h +++ b/engine/src/flutter/include/minikin/Hyphenator.h @@ -136,7 +136,7 @@ public: // at least as long as the Hyphenator object. // Note: nullptr is valid input, in which case the hyphenator only processes soft hyphens. - static Hyphenator* loadBinary(const uint8_t* patternData); + static Hyphenator* loadBinary(const uint8_t* patternData, size_t minPrefix, size_t minSuffix); private: // apply various hyphenation rules including hard and soft hyphens, ignoring patterns @@ -153,17 +153,13 @@ private: void hyphenateFromCodes(HyphenationType* result, const uint16_t* codes, size_t len, HyphenationType hyphenValue); - // TODO: these should become parameters, as they might vary by locale, screen size, and - // possibly explicit user control. - static const int MIN_PREFIX = 2; - static const int MIN_SUFFIX = 3; - // See also LONGEST_HYPHENATED_WORD in LineBreaker.cpp. Here the constant is used so // that temporary buffers can be stack-allocated without waste, which is a slightly // different use case. It measures UTF-16 code units. static const size_t MAX_HYPHENATED_SIZE = 64; const uint8_t* patternData; + size_t minPrefix, minSuffix; // accessors for binary data const Header* getHeader() const { diff --git a/engine/src/flutter/libs/minikin/Hyphenator.cpp b/engine/src/flutter/libs/minikin/Hyphenator.cpp index 5ec82feb50..0605b27831 100644 --- a/engine/src/flutter/libs/minikin/Hyphenator.cpp +++ b/engine/src/flutter/libs/minikin/Hyphenator.cpp @@ -108,9 +108,11 @@ struct Header { } }; -Hyphenator* Hyphenator::loadBinary(const uint8_t* patternData) { +Hyphenator* Hyphenator::loadBinary(const uint8_t* patternData, size_t minPrefix, size_t minSuffix) { Hyphenator* result = new Hyphenator; result->patternData = patternData; + result->minPrefix = minPrefix; + result->minSuffix = minSuffix; return result; } @@ -120,7 +122,7 @@ void Hyphenator::hyphenate(vector* result, const uint16_t* word result->resize(len); const size_t paddedLen = len + 2; // start and stop code each count for 1 if (patternData != nullptr && - (int)len >= MIN_PREFIX + MIN_SUFFIX && paddedLen <= MAX_HYPHENATED_SIZE) { + len >= minPrefix + minSuffix && paddedLen <= MAX_HYPHENATED_SIZE) { uint16_t alpha_codes[MAX_HYPHENATED_SIZE]; const HyphenationType hyphenValue = alphabetLookup(alpha_codes, word, len); if (hyphenValue != HyphenationType::DONT_BREAK) { @@ -307,7 +309,7 @@ void Hyphenator::hyphenateWithNoPatterns(HyphenationType* result, const uint16_t result[i] = hyphenationTypeBasedOnScript(word[i]); } } else if (prevChar == CHAR_MIDDLE_DOT - && MIN_PREFIX < i && i <= len - MIN_SUFFIX + && minPrefix < i && i <= len - minSuffix && ((word[i - 2] == 'l' && word[i] == 'l') || (word[i - 2] == 'L' && word[i] == 'L')) && strcmp(locale.getLanguage(), "ca") == 0) { @@ -392,7 +394,7 @@ void Hyphenator::hyphenateFromCodes(HyphenationType* result, const uint16_t* cod uint32_t link_shift = trie->link_shift; uint32_t link_mask = trie->link_mask; uint32_t pattern_shift = trie->pattern_shift; - size_t maxOffset = len - MIN_SUFFIX - 1; + size_t maxOffset = len - minSuffix - 1; for (size_t i = 0; i < len - 1; i++) { uint32_t node = 0; // index into Trie table for (size_t j = i; j < len; j++) { @@ -414,7 +416,7 @@ void Hyphenator::hyphenateFromCodes(HyphenationType* result, const uint16_t* cod const uint8_t* pat_buf = pattern->buf(pat_entry); int offset = j + 1 - (pat_len + pat_shift); // offset is the index within buffer that lines up with the start of pat_buf - int start = std::max(MIN_PREFIX - offset, 0); + int start = std::max((int)minPrefix - offset, 0); int end = std::min(pat_len, (int)maxOffset - offset); for (int k = start; k < end; k++) { buffer[offset + k] = std::max(buffer[offset + k], pat_buf[k]); @@ -423,8 +425,8 @@ void Hyphenator::hyphenateFromCodes(HyphenationType* result, const uint16_t* cod } } // Since the above calculation does not modify values outside - // [MIN_PREFIX, len - MIN_SUFFIX], they are left as 0 = DONT_BREAK. - for (size_t i = MIN_PREFIX; i < maxOffset; i++) { + // [minPrefix, len - minSuffix], they are left as 0 = DONT_BREAK. + for (size_t i = minPrefix; i < maxOffset; i++) { // Hyphenation opportunities happen when the hyphenation numbers are odd. result[i] = (buffer[i] & 1u) ? hyphenValue : HyphenationType::DONT_BREAK; } diff --git a/engine/src/flutter/tests/perftests/Hyphenator.cpp b/engine/src/flutter/tests/perftests/Hyphenator.cpp index 1e6411f76d..2107e0575c 100644 --- a/engine/src/flutter/tests/perftests/Hyphenator.cpp +++ b/engine/src/flutter/tests/perftests/Hyphenator.cpp @@ -22,30 +22,34 @@ namespace minikin { const char* enUsHyph = "/system/usr/hyphen-data/hyph-en-us.hyb"; +const int enUsMinPrefix = 2; +const int enUsMinSuffix = 3; const icu::Locale& usLocale = icu::Locale::getUS(); static void BM_Hyphenator_short_word(benchmark::State& state) { - Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(enUsHyph).data()); + Hyphenator* hyphenator = Hyphenator::loadBinary( + readWholeFile(enUsHyph).data(), enUsMinPrefix, enUsMinSuffix); std::vector word = utf8ToUtf16("hyphen"); std::vector result; while (state.KeepRunning()) { hyphenator->hyphenate(&result, word.data(), word.size(), usLocale); } - Hyphenator::loadBinary(nullptr); + Hyphenator::loadBinary(nullptr, 2, 2); } // TODO: Use BENCHMARK_CAPTURE for parametrise. BENCHMARK(BM_Hyphenator_short_word); static void BM_Hyphenator_long_word(benchmark::State& state) { - Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(enUsHyph).data()); + Hyphenator* hyphenator = Hyphenator::loadBinary( + readWholeFile(enUsHyph).data(), enUsMinPrefix, enUsMinSuffix); std::vector word = utf8ToUtf16( "Pneumonoultramicroscopicsilicovolcanoconiosis"); std::vector result; while (state.KeepRunning()) { hyphenator->hyphenate(&result, word.data(), word.size(), usLocale); } - Hyphenator::loadBinary(nullptr); + Hyphenator::loadBinary(nullptr, 2, 2); } // TODO: Use BENCHMARK_CAPTURE for parametrise. diff --git a/engine/src/flutter/tests/unittest/HyphenatorTest.cpp b/engine/src/flutter/tests/unittest/HyphenatorTest.cpp index 6265c2c6c1..ecd58a2ea0 100644 --- a/engine/src/flutter/tests/unittest/HyphenatorTest.cpp +++ b/engine/src/flutter/tests/unittest/HyphenatorTest.cpp @@ -51,7 +51,7 @@ const uint16_t EN_DASH = 0x2013; // Simple test for US English. This tests "table", which happens to be the in the exceptions list. TEST_F(HyphenatorTest, usEnglishAutomaticHyphenation) { - Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(usHyph).data()); + Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(usHyph).data(), 2, 3); const uint16_t word[] = {'t', 'a', 'b', 'l', 'e'}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -65,22 +65,21 @@ TEST_F(HyphenatorTest, usEnglishAutomaticHyphenation) { // Catalan l·l should break as l-/l TEST_F(HyphenatorTest, catalanMiddleDot) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); - const uint16_t word[] = {'l', 'l', MIDDLE_DOT, 'l', 'l', 'l'}; + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); + const uint16_t word[] = {'l', 'l', MIDDLE_DOT, 'l', 'l'}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), catalanLocale); - EXPECT_EQ((size_t) 6, result.size()); + EXPECT_EQ((size_t) 5, result.size()); EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); EXPECT_EQ(HyphenationType::DONT_BREAK, result[2]); EXPECT_EQ(HyphenationType::BREAK_AND_REPLACE_WITH_HYPHEN, result[3]); EXPECT_EQ(HyphenationType::DONT_BREAK, result[4]); - EXPECT_EQ(HyphenationType::DONT_BREAK, result[5]); } // Catalan l·l should not break if the word is too short. TEST_F(HyphenatorTest, catalanMiddleDotShortWord) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {'l', MIDDLE_DOT, 'l'}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), catalanLocale); @@ -92,7 +91,7 @@ TEST_F(HyphenatorTest, catalanMiddleDotShortWord) { // If we break on a hyphen in Polish, the hyphen should be repeated on the next line. TEST_F(HyphenatorTest, polishHyphen) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {'x', HYPHEN, 'y'}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), polishLocale); @@ -104,7 +103,7 @@ TEST_F(HyphenatorTest, polishHyphen) { // If the language is Polish but the script is not Latin, don't use Polish rules for hyphenation. TEST_F(HyphenatorTest, polishHyphenButNonLatinWord) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {GREEK_LOWER_ALPHA, HYPHEN, GREEK_LOWER_ALPHA}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), polishLocale); @@ -117,7 +116,7 @@ TEST_F(HyphenatorTest, polishHyphenButNonLatinWord) { // Polish en dash doesn't repeat on next line (as far as we know), but just provides a break // opportunity. TEST_F(HyphenatorTest, polishEnDash) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {'x', EN_DASH, 'y'}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), polishLocale); @@ -129,7 +128,7 @@ TEST_F(HyphenatorTest, polishEnDash) { // In Latin script text, soft hyphens should insert a visible hyphen if broken at. TEST_F(HyphenatorTest, latinSoftHyphen) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {'x', SOFT_HYPHEN, 'y'}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -141,7 +140,7 @@ TEST_F(HyphenatorTest, latinSoftHyphen) { // Soft hyphens at the beginning of a word are not useful in linebreaking. TEST_F(HyphenatorTest, latinSoftHyphenStartingTheWord) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {SOFT_HYPHEN, 'y'}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -152,7 +151,7 @@ TEST_F(HyphenatorTest, latinSoftHyphenStartingTheWord) { // In Malayalam script text, soft hyphens should not insert a visible hyphen if broken at. TEST_F(HyphenatorTest, malayalamSoftHyphen) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {MALAYALAM_KA, SOFT_HYPHEN, MALAYALAM_KA}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -164,7 +163,7 @@ TEST_F(HyphenatorTest, malayalamSoftHyphen) { // In automatically hyphenated Malayalam script text, we should not insert a visible hyphen. TEST_F(HyphenatorTest, malayalamAutomaticHyphenation) { - Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(malayalamHyph).data()); + Hyphenator* hyphenator = Hyphenator::loadBinary(readWholeFile(malayalamHyph).data(), 2, 2); const uint16_t word[] = { MALAYALAM_KA, MALAYALAM_KA, MALAYALAM_KA, MALAYALAM_KA, MALAYALAM_KA}; std::vector result; @@ -173,13 +172,13 @@ TEST_F(HyphenatorTest, malayalamAutomaticHyphenation) { EXPECT_EQ(HyphenationType::DONT_BREAK, result[0]); EXPECT_EQ(HyphenationType::DONT_BREAK, result[1]); EXPECT_EQ(HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN, result[2]); - EXPECT_EQ(HyphenationType::DONT_BREAK, result[3]); + EXPECT_EQ(HyphenationType::BREAK_AND_DONT_INSERT_HYPHEN, result[3]); EXPECT_EQ(HyphenationType::DONT_BREAK, result[4]); } // In Armenian script text, soft hyphens should insert an Armenian hyphen if broken at. TEST_F(HyphenatorTest, aremenianSoftHyphen) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {ARMENIAN_AYB, SOFT_HYPHEN, ARMENIAN_AYB}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -192,7 +191,7 @@ TEST_F(HyphenatorTest, aremenianSoftHyphen) { // In Hebrew script text, soft hyphens should insert a normal hyphen if broken at, for now. // We may need to change this to maqaf later. TEST_F(HyphenatorTest, hebrewSoftHyphen) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {HEBREW_ALEF, SOFT_HYPHEN, HEBREW_ALEF}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -205,7 +204,7 @@ TEST_F(HyphenatorTest, hebrewSoftHyphen) { // Soft hyphen between two Arabic letters that join should keep the joining // behavior when broken across lines. TEST_F(HyphenatorTest, arabicSoftHyphenConnecting) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {ARABIC_BEH, SOFT_HYPHEN, ARABIC_BEH}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -218,7 +217,7 @@ TEST_F(HyphenatorTest, arabicSoftHyphenConnecting) { // Arabic letters may be joining on one side, but if it's the wrong side, we // should use the normal hyphen. TEST_F(HyphenatorTest, arabicSoftHyphenNonConnecting) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {ARABIC_ALEF, SOFT_HYPHEN, ARABIC_BEH}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -230,7 +229,7 @@ TEST_F(HyphenatorTest, arabicSoftHyphenNonConnecting) { // Skip transparent characters until you find a non-transparent one. TEST_F(HyphenatorTest, arabicSoftHyphenSkipTransparents) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {ARABIC_BEH, ARABIC_ZWARAKAY, SOFT_HYPHEN, ARABIC_ZWARAKAY, ARABIC_BEH}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -245,7 +244,7 @@ TEST_F(HyphenatorTest, arabicSoftHyphenSkipTransparents) { // Skip transparent characters until you find a non-transparent one. If we get to one end without // finding anything, we are still non-joining. TEST_F(HyphenatorTest, arabicSoftHyphenTransparentsAtEnd) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {ARABIC_BEH, ARABIC_ZWARAKAY, SOFT_HYPHEN, ARABIC_ZWARAKAY}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -259,7 +258,7 @@ TEST_F(HyphenatorTest, arabicSoftHyphenTransparentsAtEnd) { // Skip transparent characters until you find a non-transparent one. If we get to one end without // finding anything, we are still non-joining. TEST_F(HyphenatorTest, arabicSoftHyphenTransparentsAtStart) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {ARABIC_ZWARAKAY, SOFT_HYPHEN, ARABIC_ZWARAKAY, ARABIC_BEH}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -272,7 +271,7 @@ TEST_F(HyphenatorTest, arabicSoftHyphenTransparentsAtStart) { // In Unified Canadian Aboriginal script (UCAS) text, soft hyphens should insert a UCAS hyphen. TEST_F(HyphenatorTest, ucasSoftHyphen) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {UCAS_E, SOFT_HYPHEN, UCAS_E}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -285,7 +284,7 @@ TEST_F(HyphenatorTest, ucasSoftHyphen) { // Presently, soft hyphen looks at the character after it to determine hyphenation type. This is a // little arbitrary, but let's test it anyway. TEST_F(HyphenatorTest, mixedScriptSoftHyphen) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {'a', SOFT_HYPHEN, UCAS_E}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -297,7 +296,7 @@ TEST_F(HyphenatorTest, mixedScriptSoftHyphen) { // Hard hyphens provide a breaking opportunity with nothing extra inserted. TEST_F(HyphenatorTest, hardHyphen) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {'x', HYPHEN, 'y'}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -309,7 +308,7 @@ TEST_F(HyphenatorTest, hardHyphen) { // Hyphen-minuses also provide a breaking opportunity with nothing extra inserted. TEST_F(HyphenatorTest, hyphenMinus) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {'x', HYPHEN_MINUS, 'y'}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); @@ -322,7 +321,7 @@ TEST_F(HyphenatorTest, hyphenMinus) { // If the word starts with a hard hyphen or hyphen-minus, it doesn't make sense to break // it at that point. TEST_F(HyphenatorTest, startingHyphenMinus) { - Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr); + Hyphenator* hyphenator = Hyphenator::loadBinary(nullptr, 2, 2); const uint16_t word[] = {HYPHEN_MINUS, 'y'}; std::vector result; hyphenator->hyphenate(&result, word, NELEM(word), usLocale); From 684ac0b636cf0d9b0db0841e125a79c89ab39c03 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 17 Jan 2017 15:56:28 +0900 Subject: [PATCH 239/364] Reduce memory usage of FontCollection. This is 2nd attempt at I9e01d237c9adcb05e200932401cb1a4780049f86. The previous CL was reverted because 8-bit integers were too small to store the indices of mFamilyVec. This CL changes it to 16-bit integers since size_t is still unnecessary large. Theoretically, 32-bit integers are necessary for the indices of mFamilyVec since the size of mFamilyVec can be 0x10EE01. However, in practice, 16-bit integers are enough for the indices of mFamilyVec. The length of mFamilyVec for the system fonts is 2084. Even if the developers load their own very large fonts, it can only increase the number of elements in mFamilyVec to at most 0x10FF. As the result, memory usage of the FontCollections for the system fonts decreases as follows. 64-bit process: before: 398,264 bytes, after: 282,568 bytes (-115,696 bytes) 32-bit process: before: 199,132 bytes, after: 149,548 bytes (-49,584 bytes) Bug: 33562608 Test: Verified Emoji and CJK characters are present. Test: android.text.cts.EmojiTest passed Test: Minikin unit tests passed Change-Id: I6796fd55ac30fe30528a212ebf6097b1d672e2f8 --- .../flutter/include/minikin/FontCollection.h | 15 +++++++++---- .../flutter/libs/minikin/FontCollection.cpp | 21 +++++++++++-------- 2 files changed, 23 insertions(+), 13 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 2364538799..d5fc5a11bd 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -59,9 +59,14 @@ private: static const int kLogCharsPerPage = 8; static const int kPageMask = (1 << kLogCharsPerPage) - 1; + // mFamilyVec holds the indices of the mFamilies and mRanges holds the range of indices of + // mFamilyVec. The maximum number of pages is 0x10FF (U+10FFFF >> 8). The maximum number of + // the fonts is 0xFF. Thus, technically the maximum length of mFamilyVec is 0x10EE01 + // (0x10FF * 0xFF). However, in practice, 16-bit integers are enough since most fonts supports + // only limited range of code points. struct Range { - size_t start; - size_t end; + uint16_t start; + uint16_t end; }; // Initialize the FontCollection. @@ -96,10 +101,12 @@ private: // Following two vectors are pre-calculated tables for resolving coverage faster. // For example, to iterate over all fonts which support Unicode code point U+XXYYZZ, - // iterate font families from mFamilyVec[mRanges[0xXXYY].start] to + // iterate font families index from mFamilyVec[mRanges[0xXXYY].start] to // mFamilyVec[mRange[0xXXYY].end] instead of whole mFamilies. + // This vector contains indices into mFamilies. + // This vector can't be empty. std::vector mRanges; - std::vector> mFamilyVec; + std::vector mFamilyVec; // This vector has pointers to the font family instances which have cmap 14 subtables. std::vector> mVSFamilyVec; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 8ec302b5ea..a3d2d974e0 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -118,8 +118,9 @@ void FontCollection::init(const vector>& typefaces) nTypefaces = mFamilies.size(); LOG_ALWAYS_FATAL_IF(nTypefaces == 0, "Font collection must have at least one valid typeface"); + LOG_ALWAYS_FATAL_IF(nTypefaces > 254, + "Font collection may only have up to 254 font families."); size_t nPages = (mMaxChar + kPageMask) >> kLogCharsPerPage; - size_t offset = 0; // TODO: Use variation selector map for mRanges construction. // 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 @@ -131,12 +132,11 @@ void FontCollection::init(const vector>& typefaces) #ifdef VERBOSE_DEBUG ALOGD("i=%zd: range start = %zd\n", i, offset); #endif - range->start = offset; + range->start = mFamilyVec.size(); for (size_t j = 0; j < nTypefaces; j++) { if (lastChar[j] < (i + 1) << kLogCharsPerPage) { const std::shared_ptr& family = mFamilies[j]; - mFamilyVec.push_back(family); - offset++; + mFamilyVec.push_back(static_cast(j)); uint32_t nextChar = family->getCoverage().nextSetBit((i + 1) << kLogCharsPerPage); #ifdef VERBOSE_DEBUG ALOGD("nextChar = %d (j = %zd)\n", nextChar, j); @@ -144,8 +144,11 @@ void FontCollection::init(const vector>& typefaces) lastChar[j] = nextChar; } } - range->end = offset; + range->end = mFamilyVec.size(); } + // See the comment in Range for more details. + LOG_ALWAYS_FATAL_IF(mFamilyVec.size() >= 0xFFFF, + "Exceeded the maximum indexable cmap coverage."); } // Special scores for the font fallback. @@ -286,11 +289,10 @@ const std::shared_ptr& FontCollection::getFamilyForChar(uint32_t ch, return mFamilies[0]; } - const std::vector>& familyVec = (vs == 0) ? mFamilyVec : mFamilies; Range range = mRanges[ch >> kLogCharsPerPage]; if (vs != 0) { - range = { 0, mFamilies.size() }; + range = { 0, static_cast(mFamilies.size()) }; } #ifdef VERBOSE_DEBUG @@ -299,7 +301,8 @@ const std::shared_ptr& FontCollection::getFamilyForChar(uint32_t ch, int bestFamilyIndex = -1; uint32_t bestScore = kUnsupportedFontScore; for (size_t i = range.start; i < range.end; i++) { - const std::shared_ptr& family = familyVec[i]; + const std::shared_ptr& family = + vs == 0 ? mFamilies[mFamilyVec[i]] : mFamilies[i]; const uint32_t score = calcFamilyScore(ch, vs, variant, langListId, family); if (score == kFirstFontScore) { // If the first font family supports the given character or variation sequence, always @@ -325,7 +328,7 @@ const std::shared_ptr& FontCollection::getFamilyForChar(uint32_t ch, } return mFamilies[0]; } - return familyVec[bestFamilyIndex]; + return vs == 0 ? mFamilies[mFamilyVec[bestFamilyIndex]] : mFamilies[bestFamilyIndex]; } const uint32_t NBSP = 0x00A0; From 0eac702718a070e8ee226e63b5f540510b425e9a Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 21 Feb 2017 15:12:43 +0900 Subject: [PATCH 240/364] Use std::mutex instead of android::Mutex This CL includes: - Stop using utils/Mutex and use std::mutex instead. - Stop using utils/Singleton. Test: minikin_tests passed Change-Id: Ib3f75b83397a546472bb5f91e066e44506e78263 --- .../flutter/include/minikin/FontCollection.h | 9 +- .../src/flutter/include/minikin/FontFamily.h | 2 + .../flutter/libs/minikin/FontCollection.cpp | 34 +++--- .../src/flutter/libs/minikin/FontFamily.cpp | 18 +-- .../libs/minikin/FontLanguageListCache.cpp | 91 ++++++++------ .../libs/minikin/FontLanguageListCache.h | 36 ++---- .../src/flutter/libs/minikin/HbFontCache.cpp | 114 ++++++++++-------- engine/src/flutter/libs/minikin/Layout.cpp | 47 ++++---- .../src/flutter/libs/minikin/MinikinFont.cpp | 2 +- .../flutter/libs/minikin/MinikinInternal.cpp | 11 +- .../flutter/libs/minikin/MinikinInternal.h | 21 ++-- .../tests/perftests/FontCollection.cpp | 2 +- .../unittest/FontCollectionItemizeTest.cpp | 6 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 16 +-- .../unittest/FontLanguageListCacheTest.cpp | 49 ++++---- .../tests/unittest/HbFontCacheTest.cpp | 9 +- 16 files changed, 245 insertions(+), 222 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index d5fc5a11bd..a3396277ec 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -26,6 +26,8 @@ namespace minikin { +class FontLanguages; + class FontCollection { public: explicit FontCollection(const std::vector>& typefaces); @@ -73,15 +75,16 @@ private: void init(const std::vector>& typefaces); const std::shared_ptr& getFamilyForChar(uint32_t ch, uint32_t vs, - uint32_t langListId, int variant) const; + const FontLanguages& styleLanguages, int variant) const; - uint32_t calcFamilyScore(uint32_t ch, uint32_t vs, int variant, uint32_t langListId, + uint32_t calcFamilyScore(uint32_t ch, uint32_t vs, int variant, + const FontLanguages& styleLanguages, const std::shared_ptr& fontFamily) const; uint32_t calcCoverageScore(uint32_t ch, uint32_t vs, const std::shared_ptr& fontFamily) const; - static uint32_t calcLanguageMatchingScore(uint32_t userLangListId, + static uint32_t calcLanguageMatchingScore(const FontLanguages& styleLanguages, const FontFamily& fontFamily); static uint32_t calcVariantMatchingScore(int variant, const FontFamily& fontFamily); diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index c7018a6f8c..e6eeca3237 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -31,6 +31,7 @@ namespace minikin { class MinikinFont; +class FontLanguages; // FontStyle represents all style information needed to select an actual font // from a collection. The implementation is packed into two 32-bit words @@ -168,6 +169,7 @@ private: int mVariant; std::vector mFonts; std::unordered_set mSupportedAxes; + std::unique_ptr mLanguages; SparseBitSet mCoverage; bool mHasVSTable; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index a3d2d974e0..e8c05d7d77 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -91,7 +91,7 @@ FontCollection::FontCollection(const vector>& typefa } void FontCollection::init(const vector>& typefaces) { - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); mId = sNextId++; vector lastChar; size_t nTypefaces = typefaces.size(); @@ -171,7 +171,8 @@ const uint32_t kFirstFontScore = UINT32_MAX; // base character. // - kFirstFontScore: When the font is the first font family in the collection and it supports the // given character or variation sequence. -uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, uint32_t langListId, +uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, + const FontLanguages& styleLanguages, const std::shared_ptr& fontFamily) const { const uint32_t coverageScore = calcCoverageScore(ch, vs, fontFamily); @@ -180,7 +181,7 @@ uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, return coverageScore; } - const uint32_t languageScore = calcLanguageMatchingScore(langListId, *fontFamily); + const uint32_t languageScore = calcLanguageMatchingScore(styleLanguages, *fontFamily); const uint32_t variantScore = calcVariantMatchingScore(variant, *fontFamily); // Subscores are encoded into 31 bits representation to meet the subscore priority. @@ -222,7 +223,7 @@ uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, } if (vs == EMOJI_STYLE_VS || vs == TEXT_STYLE_VS) { - const FontLanguages& langs = FontLanguageListCache::getById(fontFamily->langId()); + const FontLanguages& langs = getFontLanguagesFromCacheLocked(fontFamily->langId()); bool hasEmojiFlag = false; for (size_t i = 0; i < langs.size(); ++i) { if (langs[i].getEmojiStyle() == FontLanguage::EMSTYLE_EMOJI) { @@ -259,14 +260,13 @@ uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, // Here, m is the maximum number of languages to be compared, and s(i) is the i-th language's // matching score. The possible values of s(i) are 0, 1, 2, 3 and 4. uint32_t FontCollection::calcLanguageMatchingScore( - uint32_t userLangListId, const FontFamily& fontFamily) { - const FontLanguages& langList = FontLanguageListCache::getById(userLangListId); - const FontLanguages& fontLanguages = FontLanguageListCache::getById(fontFamily.langId()); + const FontLanguages& styleLanguages, const FontFamily& fontFamily) { + const FontLanguages& fontLanguages = getFontLanguagesFromCacheLocked(fontFamily.langId()); - const size_t maxCompareNum = std::min(langList.size(), FONT_LANGUAGES_LIMIT); + const size_t maxCompareNum = std::min(styleLanguages.size(), FONT_LANGUAGES_LIMIT); uint32_t score = 0; for (size_t i = 0; i < maxCompareNum; ++i) { - score = score * 5u + langList[i].calcScoreFor(fontLanguages); + score = score * 5u + styleLanguages[i].calcScoreFor(fontLanguages); } return score; } @@ -284,7 +284,7 @@ uint32_t FontCollection::calcVariantMatchingScore(int variant, const FontFamily& // 3. Highest score wins, with ties resolved to the first font. // This method never returns nullptr. const std::shared_ptr& FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, - uint32_t langListId, int variant) const { + const FontLanguages& styleLanguages, int variant) const { if (ch >= mMaxChar) { return mFamilies[0]; } @@ -303,7 +303,7 @@ const std::shared_ptr& FontCollection::getFamilyForChar(uint32_t ch, for (size_t i = range.start; i < range.end; i++) { const std::shared_ptr& family = vs == 0 ? mFamilies[mFamilyVec[i]] : mFamilies[i]; - const uint32_t score = calcFamilyScore(ch, vs, variant, langListId, family); + const uint32_t score = calcFamilyScore(ch, vs, variant, styleLanguages, family); if (score == kFirstFontScore) { // If the first font family supports the given character or variation sequence, always // use it. @@ -323,7 +323,7 @@ const std::shared_ptr& FontCollection::getFamilyForChar(uint32_t ch, if (U_SUCCESS(errorCode) && len > 0) { int off = 0; U16_NEXT_UNSAFE(decomposed, off, ch); - return getFamilyForChar(ch, vs, langListId, variant); + return getFamilyForChar(ch, vs, styleLanguages, variant); } } return mFamilies[0]; @@ -368,7 +368,7 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, return false; } - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); // Currently mRanges can not be used here since it isn't aware of the variation sequence. for (size_t i = 0; i < mVSFamilyVec.size(); i++) { @@ -381,8 +381,7 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, // for emoji + U+FE0E case since we have special fallback rule for the sequence. if (isEmojiStyleVSBase(baseCodepoint) && variationSelector == TEXT_STYLE_VS) { for (size_t i = 0; i < mFamilies.size(); ++i) { - if (!mFamilies[i]->isColorEmojiFamily() && variationSelector == TEXT_STYLE_VS && - mFamilies[i]->hasGlyph(baseCodepoint, 0)) { + if (!mFamilies[i]->isColorEmojiFamily() && mFamilies[i]->hasGlyph(baseCodepoint, 0)) { return true; } } @@ -393,7 +392,8 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style, vector* result) const { - const uint32_t langListId = style.getLanguageListId(); + const FontLanguages& styleLanguages = + getFontLanguagesFromCacheLocked(style.getLanguageListId()); int variant = style.getVariant(); const FontFamily* lastFamily = nullptr; Run* run = NULL; @@ -433,7 +433,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty if (!shouldContinueRun) { const std::shared_ptr& family = getFamilyForChar( - ch, isVariationSelector(nextCh) ? nextCh : 0, langListId, variant); + ch, isVariationSelector(nextCh) ? nextCh : 0, styleLanguages, variant); if (utf16Pos == 0 || family.get() != lastFamily) { size_t start = utf16Pos; // Workaround for combining marks and emoji modifiers until we implement diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index d0a0138ef2..598929ae29 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -41,7 +41,7 @@ using std::vector; namespace minikin { FontStyle::FontStyle(int variant, int weight, bool italic) - : FontStyle(FontLanguageListCache::kEmptyListId, variant, weight, italic) { + : FontStyle(kEmptyLanguageListId, variant, weight, italic) { } FontStyle::FontStyle(uint32_t languageListId, int variant, int weight, bool italic) @@ -56,8 +56,8 @@ android::hash_t FontStyle::hash() const { // static uint32_t FontStyle::registerLanguageList(const std::string& languages) { - android::AutoMutex _l(gMinikinLock); - return FontLanguageListCache::getId(languages); + ScopedLock _l(gLock); + return putLanguageListToCacheLocked(languages); } // static @@ -76,7 +76,7 @@ Font::Font(std::shared_ptr&& typeface, FontStyle style) } void Font::loadAxes() { - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); const uint32_t fvarTag = MinikinFont::MakeTag('f', 'v', 'a', 'r'); HbBlob fvarTable(getFontTable(typeface.get(), fvarTag)); if (fvarTable.size() == 0) { @@ -104,7 +104,7 @@ FontFamily::FontFamily(std::vector&& fonts) : FontFamily(0 /* variant */, } FontFamily::FontFamily(int variant, std::vector&& fonts) - : FontFamily(FontLanguageListCache::kEmptyListId, variant, std::move(fonts)) { + : FontFamily(kEmptyLanguageListId, variant, std::move(fonts)) { } FontFamily::FontFamily(uint32_t langId, int variant, std::vector&& fonts) @@ -117,7 +117,7 @@ FontFamily::~FontFamily() { bool FontFamily::analyzeStyle(const std::shared_ptr& typeface, int* weight, bool* italic) { - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); HbBlob os2Table(getFontTable(typeface.get(), os2Tag)); if (os2Table.get() == nullptr) return false; @@ -162,7 +162,7 @@ FakedFont FontFamily::getClosestMatch(FontStyle style) const { } bool FontFamily::isColorEmojiFamily() const { - const FontLanguages& languageList = FontLanguageListCache::getById(mLangId); + const FontLanguages& languageList = getFontLanguagesFromCacheLocked(mLangId); for (size_t i = 0; i < languageList.size(); ++i) { if (languageList[i].getEmojiStyle() == FontLanguage::EMSTYLE_EMOJI) { return true; @@ -172,7 +172,7 @@ bool FontFamily::isColorEmojiFamily() const { } void FontFamily::computeCoverage() { - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); const FontStyle defaultStyle; const MinikinFont* typeface = getClosestMatch(defaultStyle).font; const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); @@ -190,7 +190,7 @@ void FontFamily::computeCoverage() { } bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const { - assertMinikinLocked(); + assertLocked(gLock); if (variationSelector != 0 && !mHasVSTable) { // Early exit if the variation selector is specified but the font doesn't have a cmap format // 14 subtable. diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp index f1e14f0a66..5323e580ce 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp @@ -20,6 +20,8 @@ #include #include +#include +#include #include @@ -28,8 +30,6 @@ namespace minikin { -const uint32_t FontLanguageListCache::kEmptyListId; - // Returns the text length of output. static size_t toLanguageTag(char* output, size_t outSize, const std::string& locale) { output[0] = '\0'; @@ -111,46 +111,61 @@ static std::vector parseLanguageList(const std::string& input) { return result; } -// static -uint32_t FontLanguageListCache::getId(const std::string& languages) { - FontLanguageListCache* inst = FontLanguageListCache::getInstance(); - std::unordered_map::const_iterator it = - inst->mLanguageListLookupTable.find(languages); - if (it != inst->mLanguageListLookupTable.end()) { - return it->second; - } - - // Given language list is not in cache. Insert it and return newly assigned ID. - const uint32_t nextId = inst->mLanguageLists.size(); - FontLanguages fontLanguages(parseLanguageList(languages)); - if (fontLanguages.empty()) { - return kEmptyListId; - } - inst->mLanguageLists.push_back(std::move(fontLanguages)); - inst->mLanguageListLookupTable.insert(std::make_pair(languages, nextId)); - return nextId; -} - -// static -const FontLanguages& FontLanguageListCache::getById(uint32_t id) { - FontLanguageListCache* inst = FontLanguageListCache::getInstance(); - LOG_ALWAYS_FATAL_IF(id >= inst->mLanguageLists.size(), "Lookup by unknown language list ID."); - return inst->mLanguageLists[id]; -} - -// static -FontLanguageListCache* FontLanguageListCache::getInstance() { - assertMinikinLocked(); - static FontLanguageListCache* instance = nullptr; - if (instance == nullptr) { - instance = new FontLanguageListCache(); - +class FontLanguageListCache { +public: + FontLanguageListCache() { // Insert an empty language list for mapping default language list to kEmptyListId. // The default language list has only one FontLanguage and it is the unsupported language. - instance->mLanguageLists.push_back(FontLanguages()); - instance->mLanguageListLookupTable.insert(std::make_pair("", kEmptyListId)); + mLanguageLists.emplace(kEmptyLanguageListId, FontLanguages()); + mLanguageListLookupTable.emplace("", kEmptyLanguageListId); } + + uint32_t put(const std::string& languages) { + assertLocked(gLock); + + const auto& it = mLanguageListLookupTable.find(languages); + if (it != mLanguageListLookupTable.end()) { + return it->second; + } + + // Given language list is not in cache. Insert it and return newly assigned ID. + const uint32_t nextId = mLanguageLists.size(); + FontLanguages fontLanguages(parseLanguageList(languages)); + if (fontLanguages.empty()) { + mLanguageListLookupTable.emplace(languages, kEmptyLanguageListId); + return kEmptyLanguageListId; + } + mLanguageLists.emplace(nextId, std::move(fontLanguages)); + mLanguageListLookupTable.emplace(languages, nextId); + return nextId; + } + + const FontLanguages& get(uint32_t id) { + assertLocked(gLock); + + return mLanguageLists[id]; + } + +private: + std::unordered_map mLanguageLists; + + // A map from string representation of the font language list to the ID. + std::unordered_map mLanguageListLookupTable; +}; + +static FontLanguageListCache& getInstance() { + static FontLanguageListCache instance; return instance; } +// static +uint32_t putLanguageListToCacheLocked(const std::string& languages) { + return getInstance().put(languages); +} + +// static +const FontLanguages& getFontLanguagesFromCacheLocked(uint32_t id) { + return getInstance().get(id); +} + } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.h b/engine/src/flutter/libs/minikin/FontLanguageListCache.h index 9bf156f9de..2eafab9151 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.h +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.h @@ -17,39 +17,21 @@ #ifndef MINIKIN_FONT_LANGUAGE_LIST_CACHE_H #define MINIKIN_FONT_LANGUAGE_LIST_CACHE_H -#include - -#include #include "FontLanguage.h" namespace minikin { -class FontLanguageListCache { -public: - // A special ID for the empty language list. - // This value must be 0 since the empty language list is inserted into mLanguageLists by - // default. - const static uint32_t kEmptyListId = 0; +// A special ID for the empty language list. +// This value must be 0 since the empty language list is inserted into mLanguageLists by default. +const uint32_t kEmptyLanguageListId = 0; - // Returns language list ID for the given string representation of FontLanguages. - // Caller should acquire a lock before calling the method. - static uint32_t getId(const std::string& languages); +// Looks up from internal cache and returns associated ID if FontLanguages constructed from given +// string is already registered. If it is new to internal cache, put it to internal cache and +// returns newly assigned ID. +uint32_t putLanguageListToCacheLocked(const std::string& languages); - // Caller should acquire a lock before calling the method. - static const FontLanguages& getById(uint32_t id); - -private: - FontLanguageListCache() {} // Singleton - ~FontLanguageListCache() {} - - // Caller should acquire a lock before calling the method. - static FontLanguageListCache* getInstance(); - - std::vector mLanguageLists; - - // A map from string representation of the font language list to the ID. - std::unordered_map mLanguageListLookupTable; -}; +// Returns FontLanguages associated with given ID. +const FontLanguages& getFontLanguagesFromCacheLocked(uint32_t id); } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index af3d783bc8..79aebe931e 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -62,70 +62,80 @@ private: android::LruCache mCache; }; -HbFontCache* getFontCacheLocked() { - assertMinikinLocked(); - static HbFontCache* cache = nullptr; - if (cache == nullptr) { - cache = new HbFontCache(); +class HbFontCacheHolder { +public: + HbFontCacheHolder() {} + + hb_font_t* getCachedFont(const MinikinFont* minikinFont) { + assertLocked(gLock); + + // TODO: get rid of nullFaceFont + static hb_font_t* nullFaceFont = nullptr; + if (minikinFont == nullptr) { + if (nullFaceFont == nullptr) { + nullFaceFont = hb_font_create(nullptr); + } + return hb_font_reference(nullFaceFont); + } + + const int32_t fontId = minikinFont->GetUniqueId(); + hb_font_t* font = mFontCache.get(fontId); + if (font != nullptr) { + return hb_font_reference(font); + } + + hb_face_t* face; + const void* buf = minikinFont->GetFontData(); + size_t size = minikinFont->GetFontSize(); + hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, + HB_MEMORY_MODE_READONLY, nullptr, nullptr); + face = hb_face_create(blob, minikinFont->GetFontIndex()); + hb_blob_destroy(blob); + + hb_font_t* parent_font = hb_font_create(face); + hb_ot_font_set_funcs(parent_font); + + unsigned int upem = hb_face_get_upem(face); + hb_font_set_scale(parent_font, upem, upem); + + font = hb_font_create_sub_font(parent_font); + hb_font_destroy(parent_font); + hb_face_destroy(face); + mFontCache.put(fontId, font); + return hb_font_reference(font); } - return cache; + + void clearFontCache() { + assertLocked(gLock); + mFontCache.clear(); + } + + void removeFont(const MinikinFont* minikinFont) { + assertLocked(gLock); + mFontCache.remove(minikinFont->GetUniqueId()); + } + +private: + HbFontCache mFontCache; +}; + +static HbFontCacheHolder& getInstance() { + static HbFontCacheHolder instance; + return instance; } void purgeHbFontCacheLocked() { - assertMinikinLocked(); - getFontCacheLocked()->clear(); + getInstance().clearFontCache(); } void purgeHbFontLocked(const MinikinFont* minikinFont) { - assertMinikinLocked(); - const int32_t fontId = minikinFont->GetUniqueId(); - getFontCacheLocked()->remove(fontId); + getInstance().removeFont(minikinFont); } // Returns a new reference to a hb_font_t object, caller is // responsible for calling hb_font_destroy() on it. hb_font_t* getHbFontLocked(const MinikinFont* minikinFont) { - assertMinikinLocked(); - // TODO: get rid of nullFaceFont - static hb_font_t* nullFaceFont = nullptr; - if (minikinFont == nullptr) { - if (nullFaceFont == nullptr) { - nullFaceFont = hb_font_create(nullptr); - } - return hb_font_reference(nullFaceFont); - } - - HbFontCache* fontCache = getFontCacheLocked(); - const int32_t fontId = minikinFont->GetUniqueId(); - hb_font_t* font = fontCache->get(fontId); - if (font != nullptr) { - return hb_font_reference(font); - } - - hb_face_t* face; - const void* buf = minikinFont->GetFontData(); - size_t size = minikinFont->GetFontSize(); - hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, - HB_MEMORY_MODE_READONLY, nullptr, nullptr); - face = hb_face_create(blob, minikinFont->GetFontIndex()); - hb_blob_destroy(blob); - - hb_font_t* parent_font = hb_font_create(face); - hb_ot_font_set_funcs(parent_font); - - unsigned int upem = hb_face_get_upem(face); - hb_font_set_scale(parent_font, upem, upem); - - font = hb_font_create_sub_font(parent_font); - std::vector variations; - for (const FontVariation& variation : minikinFont->GetAxes()) { - variations.push_back({variation.axisTag, variation.value}); - } - hb_font_set_variations(font, variations.data(), variations.size()); - hb_font_destroy(parent_font); - hb_face_destroy(face); - fontCache->put(fontId, font); - return hb_font_reference(font); + return getInstance().getCachedFont(minikinFont); } } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 743cb763ae..d85ddd79a3 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -28,7 +28,6 @@ #include #include #include -#include #include #include @@ -201,7 +200,7 @@ static unsigned int disabledDecomposeCompatibility(hb_unicode_funcs_t*, hb_codep return 0; } -class LayoutEngine : public ::android::Singleton { +class LayoutEngine { public: LayoutEngine() { unicodeFunctions = hb_unicode_funcs_create(hb_icu_get_unicode_funcs()); @@ -212,8 +211,26 @@ public: hb_buffer_set_unicode_funcs(hbBuffer, unicodeFunctions); } + Layout* getCachedLayout(LayoutCacheKey& key, LayoutContext* ctx, + const std::shared_ptr& collection) { + assertLocked(gLock); + return layoutCache.get(key, ctx, collection); + } + + void clearLayoutCache() { + assertLocked(gLock); + layoutCache.clear(); + } + hb_buffer_t* hbBuffer; hb_unicode_funcs_t* unicodeFunctions; + + static LayoutEngine& getInstance() { + static LayoutEngine instance; + return instance; + } + +private: LayoutCache layoutCache; }; @@ -288,8 +305,7 @@ static hb_bool_t harfbuzzGetGlyphHorizontalOrigin(hb_font_t* /* hbFont */, void* } hb_font_funcs_t* getHbFontFuncs(bool forColorBitmapFont) { - assertMinikinLocked(); - + assertLocked(gLock); static hb_font_funcs_t* hbFuncs = nullptr; static hb_font_funcs_t* hbFuncsForColorBitmap = nullptr; @@ -585,8 +601,7 @@ BidiText::BidiText(const uint16_t* buf, size_t start, size_t count, size_t bufSi void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint) { - android::AutoMutex _l(gMinikinLock); - + ScopedLock _l(gLock); LayoutContext ctx; ctx.style = style; ctx.paint = paint; @@ -604,8 +619,7 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu float Layout::measureText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint, const std::shared_ptr& collection, float* advances) { - android::AutoMutex _l(gMinikinLock); - + ScopedLock _l(gLock); LayoutContext ctx; ctx.style = style; ctx.paint = paint; @@ -677,7 +691,6 @@ float Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, float Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, bool isRtl, LayoutContext* ctx, size_t bufStart, const std::shared_ptr& collection, Layout* layout, float* advances) { - LayoutCache& cache = LayoutEngine::getInstance().layoutCache; LayoutCacheKey key(collection, ctx->paint, ctx->style, buf, start, count, bufSize, isRtl); float wordSpacing = count == 1 && isWordSpace(buf[start]) ? ctx->paint.wordSpacing : 0; @@ -694,7 +707,7 @@ float Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size } advance = layoutForWord.getAdvance(); } else { - Layout* layoutForWord = cache.get(key, ctx, collection); + Layout* layoutForWord = LayoutEngine::getInstance().getCachedLayout(key, ctx, collection); if (layout) { layout->appendLayout(layoutForWord, bufStart, wordSpacing); } @@ -947,7 +960,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_buffer_set_script(buffer, script); hb_buffer_set_direction(buffer, isRtl? HB_DIRECTION_RTL : HB_DIRECTION_LTR); const FontLanguages& langList = - FontLanguageListCache::getById(ctx->style.getLanguageListId()); + getFontLanguagesFromCacheLocked(ctx->style.getLanguageListId()); if (langList.size() != 0) { const FontLanguage* hbLanguage = &langList[0]; for (size_t i = 0; i < langList.size(); ++i) { @@ -1149,17 +1162,9 @@ void Layout::getBounds(MinikinRect* bounds) const { } void Layout::purgeCaches() { - android::AutoMutex _l(gMinikinLock); - LayoutCache& layoutCache = LayoutEngine::getInstance().layoutCache; - layoutCache.clear(); + ScopedLock _l(gLock); + LayoutEngine::getInstance().clearLayoutCache(); purgeHbFontCacheLocked(); } } // namespace minikin - -// Unable to define the static data member outside of android. -// TODO: introduce our own Singleton to drop android namespace. -namespace android { -ANDROID_SINGLETON_STATIC_INSTANCE(minikin::LayoutEngine); -} // namespace android - diff --git a/engine/src/flutter/libs/minikin/MinikinFont.cpp b/engine/src/flutter/libs/minikin/MinikinFont.cpp index 6bf6a4ae3b..f8e0d5b290 100644 --- a/engine/src/flutter/libs/minikin/MinikinFont.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFont.cpp @@ -21,7 +21,7 @@ namespace minikin { MinikinFont::~MinikinFont() { - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); purgeHbFontLocked(this); } diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index e766dce992..1d06e03aa6 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -25,13 +25,8 @@ namespace minikin { -android::Mutex gMinikinLock; - -void assertMinikinLocked() { -#ifdef ENABLE_RACE_DETECTION - LOG_ALWAYS_FATAL_IF(gMinikinLock.tryLock() == 0); -#endif -} +std::mutex gMutex; +std::unique_lock gLock(gMutex, std::defer_lock); bool isEmoji(uint32_t c) { // U+2695 U+2640 U+2642 are not in emoji category in Unicode 9 but they are now emoji category. @@ -86,7 +81,7 @@ bool isEmojiBase(uint32_t c) { } hb_blob_t* getFontTable(const MinikinFont* minikinFont, uint32_t tag) { - assertMinikinLocked(); + assertLocked(gLock); hb_font_t* font = getHbFontLocked(minikinFont); hb_face_t* face = hb_font_get_face(font); hb_blob_t* blob = hb_face_reference_table(face, tag); diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index 365f20cc0d..c374cb4656 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -21,20 +21,27 @@ #include -#include - #include +#include + +#include namespace minikin { // All external Minikin interfaces are designed to be thread-safe. -// Presently, that's implemented by through a global lock, and having -// all external interfaces take that lock. +// Presently, that's implemented by a global lock, and having all external interfaces take that +// lock. +extern std::unique_lock gLock; +typedef std::unique_lock> ScopedLock; -extern android::Mutex gMinikinLock; +#ifdef ENABLE_RACE_DETECTION +inline void assertLocked(const std::unique_lock& lock) { + LOG_ALWAYS_FATAL_IF(!lock.owns_lock()); +} +#else +inline void assertLocked(const std::unique_lock&) {} +#endif -// Aborts if gMinikinLock is not acquired. Do nothing on the release build. -void assertMinikinLocked(); // Returns true if c is emoji. bool isEmoji(uint32_t c); diff --git a/engine/src/flutter/tests/perftests/FontCollection.cpp b/engine/src/flutter/tests/perftests/FontCollection.cpp index 6f9d636ca3..304708f6c7 100644 --- a/engine/src/flutter/tests/perftests/FontCollection.cpp +++ b/engine/src/flutter/tests/perftests/FontCollection.cpp @@ -77,7 +77,7 @@ static void BM_FontCollection_itemize(benchmark::State& state) { std::vector result; FontStyle style(FontStyle::registerLanguageList(ITEMIZE_TEST_CASES[testIndex].languageTag)); - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); while (state.KeepRunning()) { result.clear(); collection->itemize(buffer, utf16_length, style, &result); diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index aa142cccdc..557458b80b 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -60,7 +60,7 @@ void itemize(const std::shared_ptr& collection, const char* str, result->clear(); ParseUnicode(buf, BUF_SIZE, str, &len, NULL); - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); collection->itemize(buf, len, style, result); } @@ -72,8 +72,8 @@ const std::string& getFontPath(const FontCollection::Run& run) { // Utility function to obtain FontLanguages from string. const FontLanguages& registerAndGetFontLanguages(const std::string& lang_string) { - android::AutoMutex _l(gMinikinLock); - return FontLanguageListCache::getById(FontLanguageListCache::getId(lang_string)); + ScopedLock _l(gLock); + return getFontLanguagesFromCacheLocked(putLanguageListToCacheLocked(lang_string)); } TEST_F(FontCollectionItemizeTest, itemize_latin) { diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 5285f2642b..81f595694c 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -30,15 +30,15 @@ typedef ICUTestBase FontLanguagesTest; typedef ICUTestBase FontLanguageTest; static const FontLanguages& createFontLanguages(const std::string& input) { - android::AutoMutex _l(gMinikinLock); - uint32_t langId = FontLanguageListCache::getId(input); - return FontLanguageListCache::getById(langId); + ScopedLock _l(gLock); + uint32_t langId = putLanguageListToCacheLocked(input); + return getFontLanguagesFromCacheLocked(langId); } static FontLanguage createFontLanguage(const std::string& input) { - android::AutoMutex _l(gMinikinLock); - uint32_t langId = FontLanguageListCache::getId(input); - return FontLanguageListCache::getById(langId)[0]; + ScopedLock _l(gLock); + uint32_t langId = putLanguageListToCacheLocked(input); + return getFontLanguagesFromCacheLocked(langId)[0]; } static FontLanguage createFontLanguageWithoutICUSanitization(const std::string& input) { @@ -533,7 +533,7 @@ TEST_F(FontFamilyTest, hasVariationSelectorTest) { std::shared_ptr family( new FontFamily(std::vector{ Font(minikinFont, FontStyle()) })); - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); const uint32_t kVS1 = 0xFE00; const uint32_t kVS2 = 0xFE01; @@ -586,7 +586,7 @@ TEST_F(FontFamilyTest, hasVSTableTest) { new MinikinFontForTest(testCase.fontPath)); std::shared_ptr family(new FontFamily( std::vector{ Font(minikinFont, FontStyle()) })); - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); EXPECT_EQ(testCase.hasVSTable, family->hasVSTable()); } } diff --git a/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp index 81d84a8a28..bd82e0f994 100644 --- a/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp @@ -31,40 +31,43 @@ TEST_F(FontLanguageListCacheTest, getId) { EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en,zh-Hans")); - android::AutoMutex _l(gMinikinLock); - EXPECT_EQ(0UL, FontLanguageListCache::getId("")); + ScopedLock _l(gLock); - EXPECT_EQ(FontLanguageListCache::getId("en"), FontLanguageListCache::getId("en")); - EXPECT_NE(FontLanguageListCache::getId("en"), FontLanguageListCache::getId("jp")); + EXPECT_EQ(0UL, putLanguageListToCacheLocked("")); - EXPECT_EQ(FontLanguageListCache::getId("en,zh-Hans"), - FontLanguageListCache::getId("en,zh-Hans")); - EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), - FontLanguageListCache::getId("zh-Hans,en")); - EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), - FontLanguageListCache::getId("jp")); - EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), - FontLanguageListCache::getId("en")); - EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), - FontLanguageListCache::getId("en,zh-Hant")); + EXPECT_EQ(putLanguageListToCacheLocked("en"), putLanguageListToCacheLocked("en")); + EXPECT_NE(putLanguageListToCacheLocked("en"), putLanguageListToCacheLocked("jp")); + + EXPECT_EQ(putLanguageListToCacheLocked("en,zh-Hans"), + putLanguageListToCacheLocked("en,zh-Hans")); + EXPECT_NE(putLanguageListToCacheLocked("en,zh-Hans"), + putLanguageListToCacheLocked("zh-Hans,en")); + EXPECT_NE(putLanguageListToCacheLocked("en,zh-Hans"), + putLanguageListToCacheLocked("jp")); + EXPECT_NE(putLanguageListToCacheLocked("en,zh-Hans"), + putLanguageListToCacheLocked("en")); + EXPECT_NE(putLanguageListToCacheLocked("en,zh-Hans"), + putLanguageListToCacheLocked("en,zh-Hant")); } TEST_F(FontLanguageListCacheTest, getById) { - android::AutoMutex _l(gMinikinLock); - uint32_t enLangId = FontLanguageListCache::getId("en"); - uint32_t jpLangId = FontLanguageListCache::getId("jp"); - FontLanguage english = FontLanguageListCache::getById(enLangId)[0]; - FontLanguage japanese = FontLanguageListCache::getById(jpLangId)[0]; + ScopedLock _l(gLock); - const FontLanguages& defLangs = FontLanguageListCache::getById(0); + uint32_t enLangId = putLanguageListToCacheLocked("en"); + uint32_t jpLangId = putLanguageListToCacheLocked("jp"); + FontLanguage english = getFontLanguagesFromCacheLocked(enLangId)[0]; + FontLanguage japanese = getFontLanguagesFromCacheLocked(jpLangId)[0]; + + const FontLanguages& defLangs = getFontLanguagesFromCacheLocked(0); EXPECT_TRUE(defLangs.empty()); - const FontLanguages& langs = FontLanguageListCache::getById(FontLanguageListCache::getId("en")); + const FontLanguages& langs = getFontLanguagesFromCacheLocked( + putLanguageListToCacheLocked("en")); ASSERT_EQ(1UL, langs.size()); EXPECT_EQ(english, langs[0]); - const FontLanguages& langs2 = - FontLanguageListCache::getById(FontLanguageListCache::getId("en,jp")); + const FontLanguages& langs2 = getFontLanguagesFromCacheLocked( + putLanguageListToCacheLocked("en,jp")); ASSERT_EQ(2UL, langs2.size()); EXPECT_EQ(english, langs2[0]); EXPECT_EQ(japanese, langs2[1]); diff --git a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp index a5581a27b8..7691b8421e 100644 --- a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp @@ -18,7 +18,6 @@ #include #include -#include #include @@ -33,7 +32,7 @@ namespace minikin { class HbFontCacheTest : public testing::Test { public: virtual void TearDown() { - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); purgeHbFontCacheLocked(); } }; @@ -48,7 +47,8 @@ TEST_F(HbFontCacheTest, getHbFontLockedTest) { std::shared_ptr fontC( new MinikinFontForTest(kTestFontDir "BoldItalic.ttf")); - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); + // Never return NULL. EXPECT_NE(nullptr, getHbFontLocked(fontA.get())); EXPECT_NE(nullptr, getHbFontLocked(fontB.get())); @@ -70,7 +70,8 @@ TEST_F(HbFontCacheTest, purgeCacheTest) { std::shared_ptr minikinFont( new MinikinFontForTest(kTestFontDir "Regular.ttf")); - android::AutoMutex _l(gMinikinLock); + ScopedLock _l(gLock); + hb_font_t* font = getHbFontLocked(minikinFont.get()); ASSERT_NE(nullptr, font); From ff9a6740ed0c3648cae2facaac54a742a5a949ec Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 5 Jan 2017 20:44:14 +0900 Subject: [PATCH 241/364] Make SparseBitSet serializable. To share the calculated coverage information across the processes, make SparseBitSet serializable. Bug: 34042446 Test: minikin_tests passes Change-Id: I0463138adcf234739bb3ce1cdadf382021921f3e --- .../src/flutter/include/minikin/FontFamily.h | 17 +++ .../flutter/include/minikin/SparseBitSet.h | 25 +++- .../src/flutter/libs/minikin/FontFamily.cpp | 24 +++ .../src/flutter/libs/minikin/SparseBitSet.cpp | 106 +++++++++++-- engine/src/flutter/tests/perftests/Android.mk | 1 + .../flutter/tests/perftests/FontFamily.cpp | 54 +++++++ engine/src/flutter/tests/unittest/Android.mk | 1 + .../tests/unittest/SparseBitSetTest.cpp | 140 ++++++++++++++++++ 8 files changed, 348 insertions(+), 20 deletions(-) create mode 100644 engine/src/flutter/tests/perftests/FontFamily.cpp create mode 100644 engine/src/flutter/tests/unittest/SparseBitSetTest.cpp diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index c7018a6f8c..4186c2baab 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -128,8 +128,23 @@ public: FontFamily(int variant, std::vector&& fonts); FontFamily(uint32_t langId, int variant, std::vector&& fonts); + // The accelerator table won't be copied. Do not release the memory until the created FontFamily + // is destructed. + FontFamily(std::vector&& fonts, const uint8_t* acceleratorTable, size_t tableSize); + FontFamily(int variant, std::vector&& fonts, const uint8_t* acceleratorTable, + size_t tableSize); + FontFamily(uint32_t langId, int variant, std::vector&& fonts, + const uint8_t* acceleratorTable, size_t tableSize); + ~FontFamily(); + // Writes internal accelerator tables into the 'out' buffer. + // + // This method returns the number of bytes written to the buffer. By calling the method with + // 'out' set to nullptr, the method just returns the size needed, which the caller can then use + // for allocating a buffer for a second call. + size_t writeAcceleratorTable(uint8_t* out) const; + // TODO: Good to expose FontUtil.h. static bool analyzeStyle(const std::shared_ptr& typeface, int* weight, bool* italic); @@ -164,6 +179,8 @@ public: private: void computeCoverage(); + void readAcceleratorTable(const uint8_t* data, size_t size); + uint32_t mLangId; int mVariant; std::vector mFonts; diff --git a/engine/src/flutter/include/minikin/SparseBitSet.h b/engine/src/flutter/include/minikin/SparseBitSet.h index 2552d14d0b..491e68ae7f 100644 --- a/engine/src/flutter/include/minikin/SparseBitSet.h +++ b/engine/src/flutter/include/minikin/SparseBitSet.h @@ -34,7 +34,7 @@ namespace minikin { class SparseBitSet { public: - SparseBitSet(): mMaxVal(0) { + SparseBitSet(): mMaxVal(0), mOwnIndicesAndBitmaps(false) { } // Clear the set @@ -45,10 +45,21 @@ public: // inclusive of start, exclusive of end, laid out in a uint32 array. void initFromRanges(const uint32_t* ranges, size_t nRanges); + // Initializes the set with pre-calculted data. Returns false if the serialized data is invalid. + // Even if this function returns false, the internal data is cleared. + bool initFromBuffer(const uint8_t* data, size_t size); + + // Serialize the set and write into out. + // + // This method returns the number of bytes written to the buffer. By calling the method with + // 'out' set to nullptr, the method just returns the size needed, which the caller can then use + // for allocating a buffer for a second call. + size_t writeToBuffer(uint8_t* out) const; + // Determine whether the value is included in the set bool get(uint32_t ch) const { if (ch >= mMaxVal) return false; - uint32_t *bitmap = &mBitmaps[mIndices[ch >> kLogValuesPerPage]]; + const uint32_t *bitmap = &mBitmaps[mIndices[ch >> kLogValuesPerPage]]; uint32_t index = ch & kPageMask; return (bitmap[index >> kLogBitsPerEl] & (kElFirst >> (index & kElMask))) != 0; } @@ -80,8 +91,14 @@ private: static int CountLeadingZeros(element x); uint32_t mMaxVal; - std::unique_ptr mIndices; - std::unique_ptr mBitmaps; + + // True if this SparseBitSet is responsible for freeing mIndices and mBitamps. + bool mOwnIndicesAndBitmaps; + + uint32_t mIndexSize; + const uint32_t* mIndices; + uint32_t mBitmapSize; + const element* mBitmaps; uint32_t mZeroPageIndex; }; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index d0a0138ef2..4097e8fb23 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -112,6 +112,22 @@ FontFamily::FontFamily(uint32_t langId, int variant, std::vector&& fonts) computeCoverage(); } +FontFamily::FontFamily(std::vector&& fonts, const uint8_t* acceleratorTable, size_t tableSize) + : FontFamily(0 /* variant */, std::move(fonts), acceleratorTable, tableSize) { +} + +FontFamily::FontFamily(int variant, std::vector&& fonts, const uint8_t* acceleratorTable, + size_t tableSize) + : FontFamily(FontLanguageListCache::kEmptyListId, variant, std::move(fonts), acceleratorTable, + tableSize) { +} + +FontFamily::FontFamily(uint32_t langId, int variant, std::vector&& fonts, + const uint8_t* acceleratorTable, size_t tableSize) + : mLangId(langId), mVariant(variant), mFonts(std::move(fonts)), mHasVSTable(false) { + readAcceleratorTable(acceleratorTable, tableSize); +} + FontFamily::~FontFamily() { } @@ -247,4 +263,12 @@ std::shared_ptr FontFamily::createFamilyWithVariation( return std::shared_ptr(new FontFamily(mLangId, mVariant, std::move(fonts))); } +size_t FontFamily::writeAcceleratorTable(uint8_t* out) const { + return mCoverage.writeToBuffer(out); +} + +void FontFamily::readAcceleratorTable(const uint8_t* data, size_t size) { + bool result = mCoverage.initFromBuffer(data, size); + LOG_ALWAYS_FATAL_IF(!result, "Failed to reconstruct accelerator table from buffer"); +} } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp index 85eddaef35..a95af4d716 100644 --- a/engine/src/flutter/libs/minikin/SparseBitSet.cpp +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -29,8 +29,13 @@ const uint32_t SparseBitSet::kNotFound; void SparseBitSet::clear() { mMaxVal = 0; - mIndices.reset(); - mBitmaps.reset(); + if (mOwnIndicesAndBitmaps) { + delete[] mIndices; + delete[] mBitmaps; + mIndexSize = 0; + mBitmapSize = 0; + mOwnIndicesAndBitmaps = false; + } } uint32_t SparseBitSet::calcNumPages(const uint32_t* ranges, size_t nRanges) { @@ -59,17 +64,17 @@ uint32_t SparseBitSet::calcNumPages(const uint32_t* ranges, size_t nRanges) { void SparseBitSet::initFromRanges(const uint32_t* ranges, size_t nRanges) { if (nRanges == 0) { - mMaxVal = 0; - mIndices.reset(); - mBitmaps.reset(); + clear(); return; } mMaxVal = ranges[nRanges * 2 - 1]; - size_t indexSize = (mMaxVal + kPageMask) >> kLogValuesPerPage; - mIndices.reset(new uint32_t[indexSize]); + mIndexSize = (mMaxVal + kPageMask) >> kLogValuesPerPage; + uint32_t* indices = new uint32_t[mIndexSize]; uint32_t nPages = calcNumPages(ranges, nRanges); - mBitmaps.reset(new element[nPages << (kLogValuesPerPage - kLogBitsPerEl)]); - memset(mBitmaps.get(), 0, nPages << (kLogValuesPerPage - 3)); + mBitmapSize = nPages << (kLogValuesPerPage - kLogBitsPerEl); + element* bitmaps = new element[mBitmapSize]; + mOwnIndicesAndBitmaps = true; + memset(bitmaps, 0, nPages << (kLogValuesPerPage - 3)); mZeroPageIndex = noZeroPage; uint32_t nonzeroPageEnd = 0; uint32_t currentPage = 0; @@ -85,30 +90,99 @@ void SparseBitSet::initFromRanges(const uint32_t* ranges, size_t nRanges) { mZeroPageIndex = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl); } for (uint32_t j = nonzeroPageEnd; j < startPage; j++) { - mIndices[j] = mZeroPageIndex; + indices[j] = mZeroPageIndex; } } - mIndices[startPage] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl); + indices[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] |= (kElAllOnes >> (start & kElMask)) & + bitmaps[index] |= (kElAllOnes >> (start & kElMask)) & (kElAllOnes << ((~end + 1) & kElMask)); } else { - mBitmaps[index] |= kElAllOnes >> (start & kElMask); + bitmaps[index] |= kElAllOnes >> (start & kElMask); for (size_t j = 1; j < nElements - 1; j++) { - mBitmaps[index + j] = kElAllOnes; + bitmaps[index + j] = kElAllOnes; } - mBitmaps[index + nElements - 1] |= kElAllOnes << ((~end + 1) & kElMask); + bitmaps[index + nElements - 1] |= kElAllOnes << ((~end + 1) & kElMask); } for (size_t j = startPage + 1; j < endPage + 1; j++) { - mIndices[j] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl); + indices[j] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl); } nonzeroPageEnd = endPage + 1; } + mBitmaps = bitmaps; + mIndices = indices; +} + +struct SparseBitSetHeader { + uint32_t maxValue; + uint32_t zeroPageIndex; + uint32_t indexSize; + uint32_t bitmapSize; +}; + +bool SparseBitSet::initFromBuffer(const uint8_t* data, size_t size) { + // No need to be concerned about endianness here since Intel x86 CPUs are little-endian. ARM + // CPUs are bi-endian but the endianness is only changeable at reset time and is impossible to + // change at runtime. Thus incoming data is guaranteed to have the same endianness as when it + // was created. + + if (data == nullptr || size < sizeof(SparseBitSetHeader)) { + clear(); + return false; + } + + // The serialized data starts with SparseBitSetHeader. + const SparseBitSetHeader* header = reinterpret_cast(data); + mMaxVal = header->maxValue; + mZeroPageIndex = header->zeroPageIndex; + mIndexSize = header->indexSize; + mBitmapSize = header->bitmapSize; + + mOwnIndicesAndBitmaps = false; + if (mIndexSize == 0 || mBitmapSize == 0 || mMaxVal == 0) { + const bool isValidEmptyBitSet = (mIndexSize == 0 && mBitmapSize == 0 && mMaxVal == 0); + if (!isValidEmptyBitSet) { + clear(); + } + return isValidEmptyBitSet; + } + + const size_t indicesSizeInBytes = sizeof(mIndices[0]) * mIndexSize; + const size_t bitmapsSizeInBytes = sizeof(mBitmaps[0]) * mBitmapSize; + if (size != sizeof(SparseBitSetHeader) + indicesSizeInBytes + bitmapsSizeInBytes) { + clear(); + return false; + } + data += sizeof(SparseBitSetHeader); + mIndices = reinterpret_cast(data); + data += indicesSizeInBytes; + mBitmaps = reinterpret_cast(data); + return true; +} + +size_t SparseBitSet::writeToBuffer(uint8_t* out) const{ + // See comments in SparseBitSet::initFromBuffer for the data structure. + const size_t indicesSizeInBytes = sizeof(mIndices[0]) * mIndexSize; + const size_t bitmapsSizeInBytes = sizeof(mBitmaps[0]) * mBitmapSize; + size_t necessarySize = sizeof(SparseBitSetHeader) + indicesSizeInBytes + bitmapsSizeInBytes; + if (out != nullptr) { + SparseBitSetHeader* header = reinterpret_cast(out); + header->maxValue = mMaxVal; + header->zeroPageIndex = mZeroPageIndex; + header->indexSize = mIndexSize; + header->bitmapSize = mBitmapSize; + + out += sizeof(SparseBitSetHeader); + memcpy(out, mIndices, indicesSizeInBytes); + out += indicesSizeInBytes; + memcpy(out, mBitmaps, bitmapsSizeInBytes); + } + return necessarySize; } int SparseBitSet::CountLeadingZeros(element x) { diff --git a/engine/src/flutter/tests/perftests/Android.mk b/engine/src/flutter/tests/perftests/Android.mk index de5769c743..c60123a83d 100644 --- a/engine/src/flutter/tests/perftests/Android.mk +++ b/engine/src/flutter/tests/perftests/Android.mk @@ -22,6 +22,7 @@ perftest_src_files := \ ../util/MinikinFontForTest.cpp \ ../util/UnicodeUtils.cpp \ FontCollection.cpp \ + FontFamily.cpp \ FontLanguage.cpp \ GraphemeBreak.cpp \ Hyphenator.cpp \ diff --git a/engine/src/flutter/tests/perftests/FontFamily.cpp b/engine/src/flutter/tests/perftests/FontFamily.cpp new file mode 100644 index 0000000000..a731ef640f --- /dev/null +++ b/engine/src/flutter/tests/perftests/FontFamily.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2017 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 + +#include +#include "../util/MinikinFontForTest.h" + +namespace minikin { + +static void BM_FontFamily_create(benchmark::State& state) { + std::shared_ptr minikinFont = + std::make_shared("/system/fonts/NotoSansCJK-Regular.ttc", 0); + + while (state.KeepRunning()) { + std::shared_ptr family = std::make_shared( + std::vector({Font(minikinFont, FontStyle())})); + } +} + +BENCHMARK(BM_FontFamily_create); + +static void BM_FontFamily_create_fromBuffer(benchmark::State& state) { + std::shared_ptr minikinFont = + std::make_shared("/system/fonts/NotoSansCJK-Regular.ttc", 0); + + std::shared_ptr family = std::make_shared( + std::vector({Font(minikinFont, FontStyle())})); + + size_t bufSize = family->writeAcceleratorTable(nullptr); + std::unique_ptr buffer(new uint8_t[bufSize]); + family->writeAcceleratorTable(buffer.get()); + + while (state.KeepRunning()) { + std::shared_ptr family = std::make_shared( + std::vector({Font(minikinFont, FontStyle())}), buffer.get(), bufSize); + } +} + +BENCHMARK(BM_FontFamily_create_fromBuffer); + +} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index da7851a3e7..fdcc0c4e47 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -76,6 +76,7 @@ LOCAL_SRC_FILES += \ GraphemeBreakTests.cpp \ LayoutTest.cpp \ LayoutUtilsTest.cpp \ + SparseBitSetTest.cpp \ UnicodeUtilsTest.cpp \ WordBreakerTests.cpp diff --git a/engine/src/flutter/tests/unittest/SparseBitSetTest.cpp b/engine/src/flutter/tests/unittest/SparseBitSetTest.cpp new file mode 100644 index 0000000000..ab38f6ca75 --- /dev/null +++ b/engine/src/flutter/tests/unittest/SparseBitSetTest.cpp @@ -0,0 +1,140 @@ +/* + * Copyright (C) 2017 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 + +#include +#include + +namespace minikin { + +TEST(SparseBitSetTest, randomTest) { + const uint32_t kTestRangeNum = 4096; + + std::mt19937 mt; // Fix seeds to be able to reproduce the result. + std::uniform_int_distribution distribution(1, 512); + + std::vector range { distribution(mt) }; + for (size_t i = 1; i < kTestRangeNum * 2; ++i) { + range.push_back((range.back() - 1) + distribution(mt)); + } + + SparseBitSet bitset; + bitset.initFromRanges(range.data(), range.size() / 2); + + uint32_t ch = 0; + for (size_t i = 0; i < range.size() / 2; ++i) { + uint32_t start = range[i * 2]; + uint32_t end = range[i * 2 + 1]; + + for (; ch < start; ch++) { + ASSERT_FALSE(bitset.get(ch)) << std::hex << ch; + } + for (; ch < end; ch++) { + ASSERT_TRUE(bitset.get(ch)) << std::hex << ch; + } + } + for (; ch < 0x1FFFFFF; ++ch) { + ASSERT_FALSE(bitset.get(ch)) << std::hex << ch; + } +} + +TEST(SparseBitSetTest, randomTest_restoredFromBuffer) { + const uint32_t kTestRangeNum = 4096; + + std::mt19937 mt; // Fix seeds to be able to reproduce the result. + std::uniform_int_distribution distribution(1, 512); + + std::vector range { distribution(mt) }; + for (size_t i = 1; i < kTestRangeNum * 2; ++i) { + range.push_back((range.back() - 1) + distribution(mt)); + } + + SparseBitSet tmpBitset; + tmpBitset.initFromRanges(range.data(), range.size() / 2); + + size_t bufSize = tmpBitset.writeToBuffer(nullptr); + ASSERT_NE(0U, bufSize); + std::vector buffer(bufSize); + tmpBitset.writeToBuffer(buffer.data()); + + SparseBitSet bitset; + bitset.initFromBuffer(buffer.data(), buffer.size()); + + uint32_t ch = 0; + for (size_t i = 0; i < range.size() / 2; ++i) { + uint32_t start = range[i * 2]; + uint32_t end = range[i * 2 + 1]; + + for (; ch < start; ch++) { + ASSERT_FALSE(bitset.get(ch)) << std::hex << ch; + } + for (; ch < end; ch++) { + ASSERT_TRUE(bitset.get(ch)) << std::hex << ch; + } + } + for (; ch < 0x1FFFFFF; ++ch) { + ASSERT_FALSE(bitset.get(ch)) << std::hex << ch; + } +} + +TEST(SparseBitSetTest, emptyBitSet) { + SparseBitSet bitset; + uint32_t empty_bitset[4] = { + 0 /* max value */, 0 /* zero page index */, 0 /* index size */, 0 /* bitmap size */ + }; + EXPECT_TRUE(bitset.initFromBuffer( + reinterpret_cast(empty_bitset), sizeof(empty_bitset))); +} + +TEST(SparseBitSetTest, invalidData) { + SparseBitSet bitset; + EXPECT_FALSE(bitset.initFromBuffer(nullptr, 0)); + + // Buffer is too small. + uint32_t small_buffer[3] = { 0, 0, 0 }; + EXPECT_FALSE(bitset.initFromBuffer( + reinterpret_cast(small_buffer), sizeof(small_buffer))); + + // Buffer size does not match with necessary size. + uint32_t invalid_size_buffer[4] = { + 0x12345678 /* max value */, 0 /* zero page index */, 0x50 /* index size*/, + 0x80 /* bitmap size */ + }; + EXPECT_FALSE(bitset.initFromBuffer( + reinterpret_cast(invalid_size_buffer), sizeof(invalid_size_buffer))); + + // max value, index size, bitmap size must be zero if the bitset is empty. + uint32_t invalid_empty_bitset1[4] = { + 1 /* max value */, 0 /* zero page index */, 0 /* index size */, 0 /* bitmap size */ + }; + EXPECT_FALSE(bitset.initFromBuffer( + reinterpret_cast(invalid_empty_bitset1), sizeof(invalid_empty_bitset1))); + + uint32_t invalid_empty_bitset2[4] = { + 0 /* max value */, 0 /* zero page index */, 1 /* index size */, 0 /* bitmap size */ + }; + EXPECT_FALSE(bitset.initFromBuffer( + reinterpret_cast(invalid_empty_bitset2), sizeof(invalid_empty_bitset2))); + + uint32_t invalid_empty_bitset3[4] = { + 0 /* max value */, 0 /* zero page index */, 0 /* index size */, 1 /* bitmap size */ + }; + EXPECT_FALSE(bitset.initFromBuffer( + reinterpret_cast(invalid_empty_bitset3), sizeof(invalid_empty_bitset3))); +} + +} // namespace minikin From 7945b2d01967b9ff765a666071c752d1f93669c9 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Mon, 13 Mar 2017 16:42:46 -0700 Subject: [PATCH 242/364] Fix build failure due to unexpected merge. FontLanguageListCache::kEmptyListId is gone, use kEmptyLanguageListId instead. Test: N/A Change-Id: I96075849c53f23fbce8dbc180a51d8f97e45f316 --- engine/src/flutter/libs/minikin/FontFamily.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index b5190c0ed3..e434f24689 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -118,7 +118,7 @@ FontFamily::FontFamily(std::vector&& fonts, const uint8_t* acceleratorTabl FontFamily::FontFamily(int variant, std::vector&& fonts, const uint8_t* acceleratorTable, size_t tableSize) - : FontFamily(FontLanguageListCache::kEmptyListId, variant, std::move(fonts), acceleratorTable, + : FontFamily(kEmptyLanguageListId, variant, std::move(fonts), acceleratorTable, tableSize) { } From 44914ce013af80626aad3b19b48b2e4fb6b718bc Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 14 Mar 2017 10:46:11 -0700 Subject: [PATCH 243/364] Revert "Use std::mutex instead of android::Mutex" This reverts commit 0eac702718a070e8ee226e63b5f540510b425e9a. Bug: 36208043 Test: N/A Change-Id: I165ab7a0718ea50a8034adb6277809e271fd762c --- .../flutter/include/minikin/FontCollection.h | 9 +- .../src/flutter/include/minikin/FontFamily.h | 2 - .../flutter/libs/minikin/FontCollection.cpp | 34 +++--- .../src/flutter/libs/minikin/FontFamily.cpp | 20 +-- .../libs/minikin/FontLanguageListCache.cpp | 91 ++++++-------- .../libs/minikin/FontLanguageListCache.h | 36 ++++-- .../src/flutter/libs/minikin/HbFontCache.cpp | 114 ++++++++---------- engine/src/flutter/libs/minikin/Layout.cpp | 47 ++++---- .../src/flutter/libs/minikin/MinikinFont.cpp | 2 +- .../flutter/libs/minikin/MinikinInternal.cpp | 11 +- .../flutter/libs/minikin/MinikinInternal.h | 21 ++-- .../tests/perftests/FontCollection.cpp | 2 +- .../unittest/FontCollectionItemizeTest.cpp | 6 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 16 +-- .../unittest/FontLanguageListCacheTest.cpp | 49 ++++---- .../tests/unittest/HbFontCacheTest.cpp | 9 +- 16 files changed, 223 insertions(+), 246 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index a3396277ec..d5fc5a11bd 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -26,8 +26,6 @@ namespace minikin { -class FontLanguages; - class FontCollection { public: explicit FontCollection(const std::vector>& typefaces); @@ -75,16 +73,15 @@ private: void init(const std::vector>& typefaces); const std::shared_ptr& getFamilyForChar(uint32_t ch, uint32_t vs, - const FontLanguages& styleLanguages, int variant) const; + uint32_t langListId, int variant) const; - uint32_t calcFamilyScore(uint32_t ch, uint32_t vs, int variant, - const FontLanguages& styleLanguages, + uint32_t calcFamilyScore(uint32_t ch, uint32_t vs, int variant, uint32_t langListId, const std::shared_ptr& fontFamily) const; uint32_t calcCoverageScore(uint32_t ch, uint32_t vs, const std::shared_ptr& fontFamily) const; - static uint32_t calcLanguageMatchingScore(const FontLanguages& styleLanguages, + static uint32_t calcLanguageMatchingScore(uint32_t userLangListId, const FontFamily& fontFamily); static uint32_t calcVariantMatchingScore(int variant, const FontFamily& fontFamily); diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index a44b9c312f..4186c2baab 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -31,7 +31,6 @@ namespace minikin { class MinikinFont; -class FontLanguages; // FontStyle represents all style information needed to select an actual font // from a collection. The implementation is packed into two 32-bit words @@ -186,7 +185,6 @@ private: int mVariant; std::vector mFonts; std::unordered_set mSupportedAxes; - std::unique_ptr mLanguages; SparseBitSet mCoverage; bool mHasVSTable; diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index e8c05d7d77..a3d2d974e0 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -91,7 +91,7 @@ FontCollection::FontCollection(const vector>& typefa } void FontCollection::init(const vector>& typefaces) { - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); mId = sNextId++; vector lastChar; size_t nTypefaces = typefaces.size(); @@ -171,8 +171,7 @@ const uint32_t kFirstFontScore = UINT32_MAX; // base character. // - kFirstFontScore: When the font is the first font family in the collection and it supports the // given character or variation sequence. -uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, - const FontLanguages& styleLanguages, +uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, uint32_t langListId, const std::shared_ptr& fontFamily) const { const uint32_t coverageScore = calcCoverageScore(ch, vs, fontFamily); @@ -181,7 +180,7 @@ uint32_t FontCollection::calcFamilyScore(uint32_t ch, uint32_t vs, int variant, return coverageScore; } - const uint32_t languageScore = calcLanguageMatchingScore(styleLanguages, *fontFamily); + const uint32_t languageScore = calcLanguageMatchingScore(langListId, *fontFamily); const uint32_t variantScore = calcVariantMatchingScore(variant, *fontFamily); // Subscores are encoded into 31 bits representation to meet the subscore priority. @@ -223,7 +222,7 @@ uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, } if (vs == EMOJI_STYLE_VS || vs == TEXT_STYLE_VS) { - const FontLanguages& langs = getFontLanguagesFromCacheLocked(fontFamily->langId()); + const FontLanguages& langs = FontLanguageListCache::getById(fontFamily->langId()); bool hasEmojiFlag = false; for (size_t i = 0; i < langs.size(); ++i) { if (langs[i].getEmojiStyle() == FontLanguage::EMSTYLE_EMOJI) { @@ -260,13 +259,14 @@ uint32_t FontCollection::calcCoverageScore(uint32_t ch, uint32_t vs, // Here, m is the maximum number of languages to be compared, and s(i) is the i-th language's // matching score. The possible values of s(i) are 0, 1, 2, 3 and 4. uint32_t FontCollection::calcLanguageMatchingScore( - const FontLanguages& styleLanguages, const FontFamily& fontFamily) { - const FontLanguages& fontLanguages = getFontLanguagesFromCacheLocked(fontFamily.langId()); + uint32_t userLangListId, const FontFamily& fontFamily) { + const FontLanguages& langList = FontLanguageListCache::getById(userLangListId); + const FontLanguages& fontLanguages = FontLanguageListCache::getById(fontFamily.langId()); - const size_t maxCompareNum = std::min(styleLanguages.size(), FONT_LANGUAGES_LIMIT); + const size_t maxCompareNum = std::min(langList.size(), FONT_LANGUAGES_LIMIT); uint32_t score = 0; for (size_t i = 0; i < maxCompareNum; ++i) { - score = score * 5u + styleLanguages[i].calcScoreFor(fontLanguages); + score = score * 5u + langList[i].calcScoreFor(fontLanguages); } return score; } @@ -284,7 +284,7 @@ uint32_t FontCollection::calcVariantMatchingScore(int variant, const FontFamily& // 3. Highest score wins, with ties resolved to the first font. // This method never returns nullptr. const std::shared_ptr& FontCollection::getFamilyForChar(uint32_t ch, uint32_t vs, - const FontLanguages& styleLanguages, int variant) const { + uint32_t langListId, int variant) const { if (ch >= mMaxChar) { return mFamilies[0]; } @@ -303,7 +303,7 @@ const std::shared_ptr& FontCollection::getFamilyForChar(uint32_t ch, for (size_t i = range.start; i < range.end; i++) { const std::shared_ptr& family = vs == 0 ? mFamilies[mFamilyVec[i]] : mFamilies[i]; - const uint32_t score = calcFamilyScore(ch, vs, variant, styleLanguages, family); + const uint32_t score = calcFamilyScore(ch, vs, variant, langListId, family); if (score == kFirstFontScore) { // If the first font family supports the given character or variation sequence, always // use it. @@ -323,7 +323,7 @@ const std::shared_ptr& FontCollection::getFamilyForChar(uint32_t ch, if (U_SUCCESS(errorCode) && len > 0) { int off = 0; U16_NEXT_UNSAFE(decomposed, off, ch); - return getFamilyForChar(ch, vs, styleLanguages, variant); + return getFamilyForChar(ch, vs, langListId, variant); } } return mFamilies[0]; @@ -368,7 +368,7 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, return false; } - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); // Currently mRanges can not be used here since it isn't aware of the variation sequence. for (size_t i = 0; i < mVSFamilyVec.size(); i++) { @@ -381,7 +381,8 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, // for emoji + U+FE0E case since we have special fallback rule for the sequence. if (isEmojiStyleVSBase(baseCodepoint) && variationSelector == TEXT_STYLE_VS) { for (size_t i = 0; i < mFamilies.size(); ++i) { - if (!mFamilies[i]->isColorEmojiFamily() && mFamilies[i]->hasGlyph(baseCodepoint, 0)) { + if (!mFamilies[i]->isColorEmojiFamily() && variationSelector == TEXT_STYLE_VS && + mFamilies[i]->hasGlyph(baseCodepoint, 0)) { return true; } } @@ -392,8 +393,7 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, void FontCollection::itemize(const uint16_t *string, size_t string_size, FontStyle style, vector* result) const { - const FontLanguages& styleLanguages = - getFontLanguagesFromCacheLocked(style.getLanguageListId()); + const uint32_t langListId = style.getLanguageListId(); int variant = style.getVariant(); const FontFamily* lastFamily = nullptr; Run* run = NULL; @@ -433,7 +433,7 @@ void FontCollection::itemize(const uint16_t *string, size_t string_size, FontSty if (!shouldContinueRun) { const std::shared_ptr& family = getFamilyForChar( - ch, isVariationSelector(nextCh) ? nextCh : 0, styleLanguages, variant); + ch, isVariationSelector(nextCh) ? nextCh : 0, langListId, variant); if (utf16Pos == 0 || family.get() != lastFamily) { size_t start = utf16Pos; // Workaround for combining marks and emoji modifiers until we implement diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index e434f24689..4097e8fb23 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -41,7 +41,7 @@ using std::vector; namespace minikin { FontStyle::FontStyle(int variant, int weight, bool italic) - : FontStyle(kEmptyLanguageListId, variant, weight, italic) { + : FontStyle(FontLanguageListCache::kEmptyListId, variant, weight, italic) { } FontStyle::FontStyle(uint32_t languageListId, int variant, int weight, bool italic) @@ -56,8 +56,8 @@ android::hash_t FontStyle::hash() const { // static uint32_t FontStyle::registerLanguageList(const std::string& languages) { - ScopedLock _l(gLock); - return putLanguageListToCacheLocked(languages); + android::AutoMutex _l(gMinikinLock); + return FontLanguageListCache::getId(languages); } // static @@ -76,7 +76,7 @@ Font::Font(std::shared_ptr&& typeface, FontStyle style) } void Font::loadAxes() { - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); const uint32_t fvarTag = MinikinFont::MakeTag('f', 'v', 'a', 'r'); HbBlob fvarTable(getFontTable(typeface.get(), fvarTag)); if (fvarTable.size() == 0) { @@ -104,7 +104,7 @@ FontFamily::FontFamily(std::vector&& fonts) : FontFamily(0 /* variant */, } FontFamily::FontFamily(int variant, std::vector&& fonts) - : FontFamily(kEmptyLanguageListId, variant, std::move(fonts)) { + : FontFamily(FontLanguageListCache::kEmptyListId, variant, std::move(fonts)) { } FontFamily::FontFamily(uint32_t langId, int variant, std::vector&& fonts) @@ -118,7 +118,7 @@ FontFamily::FontFamily(std::vector&& fonts, const uint8_t* acceleratorTabl FontFamily::FontFamily(int variant, std::vector&& fonts, const uint8_t* acceleratorTable, size_t tableSize) - : FontFamily(kEmptyLanguageListId, variant, std::move(fonts), acceleratorTable, + : FontFamily(FontLanguageListCache::kEmptyListId, variant, std::move(fonts), acceleratorTable, tableSize) { } @@ -133,7 +133,7 @@ FontFamily::~FontFamily() { bool FontFamily::analyzeStyle(const std::shared_ptr& typeface, int* weight, bool* italic) { - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); HbBlob os2Table(getFontTable(typeface.get(), os2Tag)); if (os2Table.get() == nullptr) return false; @@ -178,7 +178,7 @@ FakedFont FontFamily::getClosestMatch(FontStyle style) const { } bool FontFamily::isColorEmojiFamily() const { - const FontLanguages& languageList = getFontLanguagesFromCacheLocked(mLangId); + const FontLanguages& languageList = FontLanguageListCache::getById(mLangId); for (size_t i = 0; i < languageList.size(); ++i) { if (languageList[i].getEmojiStyle() == FontLanguage::EMSTYLE_EMOJI) { return true; @@ -188,7 +188,7 @@ bool FontFamily::isColorEmojiFamily() const { } void FontFamily::computeCoverage() { - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); const FontStyle defaultStyle; const MinikinFont* typeface = getClosestMatch(defaultStyle).font; const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); @@ -206,7 +206,7 @@ void FontFamily::computeCoverage() { } bool FontFamily::hasGlyph(uint32_t codepoint, uint32_t variationSelector) const { - assertLocked(gLock); + assertMinikinLocked(); if (variationSelector != 0 && !mHasVSTable) { // Early exit if the variation selector is specified but the font doesn't have a cmap format // 14 subtable. diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp index 5323e580ce..f1e14f0a66 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.cpp @@ -20,8 +20,6 @@ #include #include -#include -#include #include @@ -30,6 +28,8 @@ namespace minikin { +const uint32_t FontLanguageListCache::kEmptyListId; + // Returns the text length of output. static size_t toLanguageTag(char* output, size_t outSize, const std::string& locale) { output[0] = '\0'; @@ -111,61 +111,46 @@ static std::vector parseLanguageList(const std::string& input) { return result; } -class FontLanguageListCache { -public: - FontLanguageListCache() { +// static +uint32_t FontLanguageListCache::getId(const std::string& languages) { + FontLanguageListCache* inst = FontLanguageListCache::getInstance(); + std::unordered_map::const_iterator it = + inst->mLanguageListLookupTable.find(languages); + if (it != inst->mLanguageListLookupTable.end()) { + return it->second; + } + + // Given language list is not in cache. Insert it and return newly assigned ID. + const uint32_t nextId = inst->mLanguageLists.size(); + FontLanguages fontLanguages(parseLanguageList(languages)); + if (fontLanguages.empty()) { + return kEmptyListId; + } + inst->mLanguageLists.push_back(std::move(fontLanguages)); + inst->mLanguageListLookupTable.insert(std::make_pair(languages, nextId)); + return nextId; +} + +// static +const FontLanguages& FontLanguageListCache::getById(uint32_t id) { + FontLanguageListCache* inst = FontLanguageListCache::getInstance(); + LOG_ALWAYS_FATAL_IF(id >= inst->mLanguageLists.size(), "Lookup by unknown language list ID."); + return inst->mLanguageLists[id]; +} + +// static +FontLanguageListCache* FontLanguageListCache::getInstance() { + assertMinikinLocked(); + static FontLanguageListCache* instance = nullptr; + if (instance == nullptr) { + instance = new FontLanguageListCache(); + // Insert an empty language list for mapping default language list to kEmptyListId. // The default language list has only one FontLanguage and it is the unsupported language. - mLanguageLists.emplace(kEmptyLanguageListId, FontLanguages()); - mLanguageListLookupTable.emplace("", kEmptyLanguageListId); + instance->mLanguageLists.push_back(FontLanguages()); + instance->mLanguageListLookupTable.insert(std::make_pair("", kEmptyListId)); } - - uint32_t put(const std::string& languages) { - assertLocked(gLock); - - const auto& it = mLanguageListLookupTable.find(languages); - if (it != mLanguageListLookupTable.end()) { - return it->second; - } - - // Given language list is not in cache. Insert it and return newly assigned ID. - const uint32_t nextId = mLanguageLists.size(); - FontLanguages fontLanguages(parseLanguageList(languages)); - if (fontLanguages.empty()) { - mLanguageListLookupTable.emplace(languages, kEmptyLanguageListId); - return kEmptyLanguageListId; - } - mLanguageLists.emplace(nextId, std::move(fontLanguages)); - mLanguageListLookupTable.emplace(languages, nextId); - return nextId; - } - - const FontLanguages& get(uint32_t id) { - assertLocked(gLock); - - return mLanguageLists[id]; - } - -private: - std::unordered_map mLanguageLists; - - // A map from string representation of the font language list to the ID. - std::unordered_map mLanguageListLookupTable; -}; - -static FontLanguageListCache& getInstance() { - static FontLanguageListCache instance; return instance; } -// static -uint32_t putLanguageListToCacheLocked(const std::string& languages) { - return getInstance().put(languages); -} - -// static -const FontLanguages& getFontLanguagesFromCacheLocked(uint32_t id) { - return getInstance().get(id); -} - } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontLanguageListCache.h b/engine/src/flutter/libs/minikin/FontLanguageListCache.h index 2eafab9151..9bf156f9de 100644 --- a/engine/src/flutter/libs/minikin/FontLanguageListCache.h +++ b/engine/src/flutter/libs/minikin/FontLanguageListCache.h @@ -17,21 +17,39 @@ #ifndef MINIKIN_FONT_LANGUAGE_LIST_CACHE_H #define MINIKIN_FONT_LANGUAGE_LIST_CACHE_H +#include + +#include #include "FontLanguage.h" namespace minikin { -// A special ID for the empty language list. -// This value must be 0 since the empty language list is inserted into mLanguageLists by default. -const uint32_t kEmptyLanguageListId = 0; +class FontLanguageListCache { +public: + // A special ID for the empty language list. + // This value must be 0 since the empty language list is inserted into mLanguageLists by + // default. + const static uint32_t kEmptyListId = 0; -// Looks up from internal cache and returns associated ID if FontLanguages constructed from given -// string is already registered. If it is new to internal cache, put it to internal cache and -// returns newly assigned ID. -uint32_t putLanguageListToCacheLocked(const std::string& languages); + // Returns language list ID for the given string representation of FontLanguages. + // Caller should acquire a lock before calling the method. + static uint32_t getId(const std::string& languages); -// Returns FontLanguages associated with given ID. -const FontLanguages& getFontLanguagesFromCacheLocked(uint32_t id); + // Caller should acquire a lock before calling the method. + static const FontLanguages& getById(uint32_t id); + +private: + FontLanguageListCache() {} // Singleton + ~FontLanguageListCache() {} + + // Caller should acquire a lock before calling the method. + static FontLanguageListCache* getInstance(); + + std::vector mLanguageLists; + + // A map from string representation of the font language list to the ID. + std::unordered_map mLanguageListLookupTable; +}; } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index 79aebe931e..af3d783bc8 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -62,80 +62,70 @@ private: android::LruCache mCache; }; -class HbFontCacheHolder { -public: - HbFontCacheHolder() {} - - hb_font_t* getCachedFont(const MinikinFont* minikinFont) { - assertLocked(gLock); - - // TODO: get rid of nullFaceFont - static hb_font_t* nullFaceFont = nullptr; - if (minikinFont == nullptr) { - if (nullFaceFont == nullptr) { - nullFaceFont = hb_font_create(nullptr); - } - return hb_font_reference(nullFaceFont); - } - - const int32_t fontId = minikinFont->GetUniqueId(); - hb_font_t* font = mFontCache.get(fontId); - if (font != nullptr) { - return hb_font_reference(font); - } - - hb_face_t* face; - const void* buf = minikinFont->GetFontData(); - size_t size = minikinFont->GetFontSize(); - hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, - HB_MEMORY_MODE_READONLY, nullptr, nullptr); - face = hb_face_create(blob, minikinFont->GetFontIndex()); - hb_blob_destroy(blob); - - hb_font_t* parent_font = hb_font_create(face); - hb_ot_font_set_funcs(parent_font); - - unsigned int upem = hb_face_get_upem(face); - hb_font_set_scale(parent_font, upem, upem); - - font = hb_font_create_sub_font(parent_font); - hb_font_destroy(parent_font); - hb_face_destroy(face); - mFontCache.put(fontId, font); - return hb_font_reference(font); +HbFontCache* getFontCacheLocked() { + assertMinikinLocked(); + static HbFontCache* cache = nullptr; + if (cache == nullptr) { + cache = new HbFontCache(); } - - void clearFontCache() { - assertLocked(gLock); - mFontCache.clear(); - } - - void removeFont(const MinikinFont* minikinFont) { - assertLocked(gLock); - mFontCache.remove(minikinFont->GetUniqueId()); - } - -private: - HbFontCache mFontCache; -}; - -static HbFontCacheHolder& getInstance() { - static HbFontCacheHolder instance; - return instance; + return cache; } void purgeHbFontCacheLocked() { - getInstance().clearFontCache(); + assertMinikinLocked(); + getFontCacheLocked()->clear(); } void purgeHbFontLocked(const MinikinFont* minikinFont) { - getInstance().removeFont(minikinFont); + assertMinikinLocked(); + const int32_t fontId = minikinFont->GetUniqueId(); + getFontCacheLocked()->remove(fontId); } // Returns a new reference to a hb_font_t object, caller is // responsible for calling hb_font_destroy() on it. hb_font_t* getHbFontLocked(const MinikinFont* minikinFont) { - return getInstance().getCachedFont(minikinFont); + assertMinikinLocked(); + // TODO: get rid of nullFaceFont + static hb_font_t* nullFaceFont = nullptr; + if (minikinFont == nullptr) { + if (nullFaceFont == nullptr) { + nullFaceFont = hb_font_create(nullptr); + } + return hb_font_reference(nullFaceFont); + } + + HbFontCache* fontCache = getFontCacheLocked(); + const int32_t fontId = minikinFont->GetUniqueId(); + hb_font_t* font = fontCache->get(fontId); + if (font != nullptr) { + return hb_font_reference(font); + } + + hb_face_t* face; + const void* buf = minikinFont->GetFontData(); + size_t size = minikinFont->GetFontSize(); + hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, + HB_MEMORY_MODE_READONLY, nullptr, nullptr); + face = hb_face_create(blob, minikinFont->GetFontIndex()); + hb_blob_destroy(blob); + + hb_font_t* parent_font = hb_font_create(face); + hb_ot_font_set_funcs(parent_font); + + unsigned int upem = hb_face_get_upem(face); + hb_font_set_scale(parent_font, upem, upem); + + font = hb_font_create_sub_font(parent_font); + std::vector variations; + for (const FontVariation& variation : minikinFont->GetAxes()) { + variations.push_back({variation.axisTag, variation.value}); + } + hb_font_set_variations(font, variations.data(), variations.size()); + hb_font_destroy(parent_font); + hb_face_destroy(face); + fontCache->put(fontId, font); + return hb_font_reference(font); } } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index d85ddd79a3..743cb763ae 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -28,6 +28,7 @@ #include #include #include +#include #include #include @@ -200,7 +201,7 @@ static unsigned int disabledDecomposeCompatibility(hb_unicode_funcs_t*, hb_codep return 0; } -class LayoutEngine { +class LayoutEngine : public ::android::Singleton { public: LayoutEngine() { unicodeFunctions = hb_unicode_funcs_create(hb_icu_get_unicode_funcs()); @@ -211,26 +212,8 @@ public: hb_buffer_set_unicode_funcs(hbBuffer, unicodeFunctions); } - Layout* getCachedLayout(LayoutCacheKey& key, LayoutContext* ctx, - const std::shared_ptr& collection) { - assertLocked(gLock); - return layoutCache.get(key, ctx, collection); - } - - void clearLayoutCache() { - assertLocked(gLock); - layoutCache.clear(); - } - hb_buffer_t* hbBuffer; hb_unicode_funcs_t* unicodeFunctions; - - static LayoutEngine& getInstance() { - static LayoutEngine instance; - return instance; - } - -private: LayoutCache layoutCache; }; @@ -305,7 +288,8 @@ static hb_bool_t harfbuzzGetGlyphHorizontalOrigin(hb_font_t* /* hbFont */, void* } hb_font_funcs_t* getHbFontFuncs(bool forColorBitmapFont) { - assertLocked(gLock); + assertMinikinLocked(); + static hb_font_funcs_t* hbFuncs = nullptr; static hb_font_funcs_t* hbFuncsForColorBitmap = nullptr; @@ -601,7 +585,8 @@ BidiText::BidiText(const uint16_t* buf, size_t start, size_t count, size_t bufSi void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint) { - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); + LayoutContext ctx; ctx.style = style; ctx.paint = paint; @@ -619,7 +604,8 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu float Layout::measureText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint, const std::shared_ptr& collection, float* advances) { - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); + LayoutContext ctx; ctx.style = style; ctx.paint = paint; @@ -691,6 +677,7 @@ float Layout::doLayoutRunCached(const uint16_t* buf, size_t start, size_t count, float Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size_t bufSize, bool isRtl, LayoutContext* ctx, size_t bufStart, const std::shared_ptr& collection, Layout* layout, float* advances) { + LayoutCache& cache = LayoutEngine::getInstance().layoutCache; LayoutCacheKey key(collection, ctx->paint, ctx->style, buf, start, count, bufSize, isRtl); float wordSpacing = count == 1 && isWordSpace(buf[start]) ? ctx->paint.wordSpacing : 0; @@ -707,7 +694,7 @@ float Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size } advance = layoutForWord.getAdvance(); } else { - Layout* layoutForWord = LayoutEngine::getInstance().getCachedLayout(key, ctx, collection); + Layout* layoutForWord = cache.get(key, ctx, collection); if (layout) { layout->appendLayout(layoutForWord, bufStart, wordSpacing); } @@ -960,7 +947,7 @@ void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t hb_buffer_set_script(buffer, script); hb_buffer_set_direction(buffer, isRtl? HB_DIRECTION_RTL : HB_DIRECTION_LTR); const FontLanguages& langList = - getFontLanguagesFromCacheLocked(ctx->style.getLanguageListId()); + FontLanguageListCache::getById(ctx->style.getLanguageListId()); if (langList.size() != 0) { const FontLanguage* hbLanguage = &langList[0]; for (size_t i = 0; i < langList.size(); ++i) { @@ -1162,9 +1149,17 @@ void Layout::getBounds(MinikinRect* bounds) const { } void Layout::purgeCaches() { - ScopedLock _l(gLock); - LayoutEngine::getInstance().clearLayoutCache(); + android::AutoMutex _l(gMinikinLock); + LayoutCache& layoutCache = LayoutEngine::getInstance().layoutCache; + layoutCache.clear(); purgeHbFontCacheLocked(); } } // namespace minikin + +// Unable to define the static data member outside of android. +// TODO: introduce our own Singleton to drop android namespace. +namespace android { +ANDROID_SINGLETON_STATIC_INSTANCE(minikin::LayoutEngine); +} // namespace android + diff --git a/engine/src/flutter/libs/minikin/MinikinFont.cpp b/engine/src/flutter/libs/minikin/MinikinFont.cpp index f8e0d5b290..6bf6a4ae3b 100644 --- a/engine/src/flutter/libs/minikin/MinikinFont.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFont.cpp @@ -21,7 +21,7 @@ namespace minikin { MinikinFont::~MinikinFont() { - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); purgeHbFontLocked(this); } diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 1d06e03aa6..e766dce992 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -25,8 +25,13 @@ namespace minikin { -std::mutex gMutex; -std::unique_lock gLock(gMutex, std::defer_lock); +android::Mutex gMinikinLock; + +void assertMinikinLocked() { +#ifdef ENABLE_RACE_DETECTION + LOG_ALWAYS_FATAL_IF(gMinikinLock.tryLock() == 0); +#endif +} bool isEmoji(uint32_t c) { // U+2695 U+2640 U+2642 are not in emoji category in Unicode 9 but they are now emoji category. @@ -81,7 +86,7 @@ bool isEmojiBase(uint32_t c) { } hb_blob_t* getFontTable(const MinikinFont* minikinFont, uint32_t tag) { - assertLocked(gLock); + assertMinikinLocked(); hb_font_t* font = getHbFontLocked(minikinFont); hb_face_t* face = hb_font_get_face(font); hb_blob_t* blob = hb_face_reference_table(face, tag); diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index c374cb4656..365f20cc0d 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -21,27 +21,20 @@ #include -#include -#include +#include -#include +#include namespace minikin { // All external Minikin interfaces are designed to be thread-safe. -// Presently, that's implemented by a global lock, and having all external interfaces take that -// lock. -extern std::unique_lock gLock; -typedef std::unique_lock> ScopedLock; +// Presently, that's implemented by through a global lock, and having +// all external interfaces take that lock. -#ifdef ENABLE_RACE_DETECTION -inline void assertLocked(const std::unique_lock& lock) { - LOG_ALWAYS_FATAL_IF(!lock.owns_lock()); -} -#else -inline void assertLocked(const std::unique_lock&) {} -#endif +extern android::Mutex gMinikinLock; +// Aborts if gMinikinLock is not acquired. Do nothing on the release build. +void assertMinikinLocked(); // Returns true if c is emoji. bool isEmoji(uint32_t c); diff --git a/engine/src/flutter/tests/perftests/FontCollection.cpp b/engine/src/flutter/tests/perftests/FontCollection.cpp index 304708f6c7..6f9d636ca3 100644 --- a/engine/src/flutter/tests/perftests/FontCollection.cpp +++ b/engine/src/flutter/tests/perftests/FontCollection.cpp @@ -77,7 +77,7 @@ static void BM_FontCollection_itemize(benchmark::State& state) { std::vector result; FontStyle style(FontStyle::registerLanguageList(ITEMIZE_TEST_CASES[testIndex].languageTag)); - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); while (state.KeepRunning()) { result.clear(); collection->itemize(buffer, utf16_length, style, &result); diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 557458b80b..aa142cccdc 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -60,7 +60,7 @@ void itemize(const std::shared_ptr& collection, const char* str, result->clear(); ParseUnicode(buf, BUF_SIZE, str, &len, NULL); - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); collection->itemize(buf, len, style, result); } @@ -72,8 +72,8 @@ const std::string& getFontPath(const FontCollection::Run& run) { // Utility function to obtain FontLanguages from string. const FontLanguages& registerAndGetFontLanguages(const std::string& lang_string) { - ScopedLock _l(gLock); - return getFontLanguagesFromCacheLocked(putLanguageListToCacheLocked(lang_string)); + android::AutoMutex _l(gMinikinLock); + return FontLanguageListCache::getById(FontLanguageListCache::getId(lang_string)); } TEST_F(FontCollectionItemizeTest, itemize_latin) { diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 81f595694c..5285f2642b 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -30,15 +30,15 @@ typedef ICUTestBase FontLanguagesTest; typedef ICUTestBase FontLanguageTest; static const FontLanguages& createFontLanguages(const std::string& input) { - ScopedLock _l(gLock); - uint32_t langId = putLanguageListToCacheLocked(input); - return getFontLanguagesFromCacheLocked(langId); + android::AutoMutex _l(gMinikinLock); + uint32_t langId = FontLanguageListCache::getId(input); + return FontLanguageListCache::getById(langId); } static FontLanguage createFontLanguage(const std::string& input) { - ScopedLock _l(gLock); - uint32_t langId = putLanguageListToCacheLocked(input); - return getFontLanguagesFromCacheLocked(langId)[0]; + android::AutoMutex _l(gMinikinLock); + uint32_t langId = FontLanguageListCache::getId(input); + return FontLanguageListCache::getById(langId)[0]; } static FontLanguage createFontLanguageWithoutICUSanitization(const std::string& input) { @@ -533,7 +533,7 @@ TEST_F(FontFamilyTest, hasVariationSelectorTest) { std::shared_ptr family( new FontFamily(std::vector{ Font(minikinFont, FontStyle()) })); - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); const uint32_t kVS1 = 0xFE00; const uint32_t kVS2 = 0xFE01; @@ -586,7 +586,7 @@ TEST_F(FontFamilyTest, hasVSTableTest) { new MinikinFontForTest(testCase.fontPath)); std::shared_ptr family(new FontFamily( std::vector{ Font(minikinFont, FontStyle()) })); - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); EXPECT_EQ(testCase.hasVSTable, family->hasVSTable()); } } diff --git a/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp index bd82e0f994..81d84a8a28 100644 --- a/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp @@ -31,43 +31,40 @@ TEST_F(FontLanguageListCacheTest, getId) { EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en,zh-Hans")); - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); + EXPECT_EQ(0UL, FontLanguageListCache::getId("")); - EXPECT_EQ(0UL, putLanguageListToCacheLocked("")); + EXPECT_EQ(FontLanguageListCache::getId("en"), FontLanguageListCache::getId("en")); + EXPECT_NE(FontLanguageListCache::getId("en"), FontLanguageListCache::getId("jp")); - EXPECT_EQ(putLanguageListToCacheLocked("en"), putLanguageListToCacheLocked("en")); - EXPECT_NE(putLanguageListToCacheLocked("en"), putLanguageListToCacheLocked("jp")); - - EXPECT_EQ(putLanguageListToCacheLocked("en,zh-Hans"), - putLanguageListToCacheLocked("en,zh-Hans")); - EXPECT_NE(putLanguageListToCacheLocked("en,zh-Hans"), - putLanguageListToCacheLocked("zh-Hans,en")); - EXPECT_NE(putLanguageListToCacheLocked("en,zh-Hans"), - putLanguageListToCacheLocked("jp")); - EXPECT_NE(putLanguageListToCacheLocked("en,zh-Hans"), - putLanguageListToCacheLocked("en")); - EXPECT_NE(putLanguageListToCacheLocked("en,zh-Hans"), - putLanguageListToCacheLocked("en,zh-Hant")); + EXPECT_EQ(FontLanguageListCache::getId("en,zh-Hans"), + FontLanguageListCache::getId("en,zh-Hans")); + EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), + FontLanguageListCache::getId("zh-Hans,en")); + EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), + FontLanguageListCache::getId("jp")); + EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), + FontLanguageListCache::getId("en")); + EXPECT_NE(FontLanguageListCache::getId("en,zh-Hans"), + FontLanguageListCache::getId("en,zh-Hant")); } TEST_F(FontLanguageListCacheTest, getById) { - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); + uint32_t enLangId = FontLanguageListCache::getId("en"); + uint32_t jpLangId = FontLanguageListCache::getId("jp"); + FontLanguage english = FontLanguageListCache::getById(enLangId)[0]; + FontLanguage japanese = FontLanguageListCache::getById(jpLangId)[0]; - uint32_t enLangId = putLanguageListToCacheLocked("en"); - uint32_t jpLangId = putLanguageListToCacheLocked("jp"); - FontLanguage english = getFontLanguagesFromCacheLocked(enLangId)[0]; - FontLanguage japanese = getFontLanguagesFromCacheLocked(jpLangId)[0]; - - const FontLanguages& defLangs = getFontLanguagesFromCacheLocked(0); + const FontLanguages& defLangs = FontLanguageListCache::getById(0); EXPECT_TRUE(defLangs.empty()); - const FontLanguages& langs = getFontLanguagesFromCacheLocked( - putLanguageListToCacheLocked("en")); + const FontLanguages& langs = FontLanguageListCache::getById(FontLanguageListCache::getId("en")); ASSERT_EQ(1UL, langs.size()); EXPECT_EQ(english, langs[0]); - const FontLanguages& langs2 = getFontLanguagesFromCacheLocked( - putLanguageListToCacheLocked("en,jp")); + const FontLanguages& langs2 = + FontLanguageListCache::getById(FontLanguageListCache::getId("en,jp")); ASSERT_EQ(2UL, langs2.size()); EXPECT_EQ(english, langs2[0]); EXPECT_EQ(japanese, langs2[1]); diff --git a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp index 7691b8421e..a5581a27b8 100644 --- a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp @@ -18,6 +18,7 @@ #include #include +#include #include @@ -32,7 +33,7 @@ namespace minikin { class HbFontCacheTest : public testing::Test { public: virtual void TearDown() { - ScopedLock _l(gLock); + android::AutoMutex _l(gMinikinLock); purgeHbFontCacheLocked(); } }; @@ -47,8 +48,7 @@ TEST_F(HbFontCacheTest, getHbFontLockedTest) { std::shared_ptr fontC( new MinikinFontForTest(kTestFontDir "BoldItalic.ttf")); - ScopedLock _l(gLock); - + android::AutoMutex _l(gMinikinLock); // Never return NULL. EXPECT_NE(nullptr, getHbFontLocked(fontA.get())); EXPECT_NE(nullptr, getHbFontLocked(fontB.get())); @@ -70,8 +70,7 @@ TEST_F(HbFontCacheTest, purgeCacheTest) { std::shared_ptr minikinFont( new MinikinFontForTest(kTestFontDir "Regular.ttf")); - ScopedLock _l(gLock); - + android::AutoMutex _l(gMinikinLock); hb_font_t* font = getHbFontLocked(minikinFont.get()); ASSERT_NE(nullptr, font); From f4c0bd2e1b9cd2282bf5ac730a29203015f7c0d1 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Mon, 13 Mar 2017 21:52:52 -0700 Subject: [PATCH 244/364] Break grapheme clusters after viramas if they end a cluster Previously, we stayed on the conservative side and disallowed any grapheme breaks (and thus cursoring) where a virama was followed by a letter, since we did not know if the virama would be forming a cluster with the letter or not. This created problems with Indic languages with infrequent conjuncts, such as Tamil. Now we use the information in calculated advances to find if a cluster is formed. If there is no cluster, we break the grapheme and allow cursoring after the virama. Test: Unit tests added to GraphemeBreakTests and MeasurementTests. Test: Also manually tested Tamil sequences. Bug: 35721792 Change-Id: Ib159edb94b3ad6f693f0d3dad016b332b2cef447 --- .../flutter/include/minikin/GraphemeBreak.h | 12 ++-- .../flutter/libs/minikin/GraphemeBreak.cpp | 37 ++++++------ .../src/flutter/libs/minikin/Measurement.cpp | 7 ++- .../flutter/tests/perftests/GraphemeBreak.cpp | 6 +- engine/src/flutter/tests/unittest/Android.mk | 1 + .../tests/unittest/GraphemeBreakTests.cpp | 44 ++++++++++++-- .../tests/unittest/MeasurementTests.cpp | 60 +++++++++++++++++++ 7 files changed, 131 insertions(+), 36 deletions(-) create mode 100644 engine/src/flutter/tests/unittest/MeasurementTests.cpp diff --git a/engine/src/flutter/include/minikin/GraphemeBreak.h b/engine/src/flutter/include/minikin/GraphemeBreak.h index b501f6784f..f1b5102a0c 100644 --- a/engine/src/flutter/include/minikin/GraphemeBreak.h +++ b/engine/src/flutter/include/minikin/GraphemeBreak.h @@ -31,15 +31,15 @@ public: }; // Determine whether the given offset is a grapheme break. - // This implementation generally follows Unicode TR29 extended - // grapheme break, but with some tweaks to more closely match - // existing implementations. - static bool isGraphemeBreak(const uint16_t* buf, size_t start, size_t count, size_t offset); + // This implementation generally follows Unicode's UTR #29 extended + // grapheme break, with various tweaks. + static bool isGraphemeBreak(const float* advances, const uint16_t* buf, size_t start, + size_t count, size_t offset); // Matches Android's Java API. Note, return (size_t)-1 for AT to // signal non-break because unsigned return type. - static size_t getTextRunCursor(const uint16_t* buf, size_t start, size_t count, - size_t offset, MoveOpt opt); + static size_t getTextRunCursor(const float* advances, const uint16_t* buf, size_t start, + size_t count, size_t offset, MoveOpt opt); }; } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index 1b3d1ab33b..56f3a52a5d 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -55,8 +55,8 @@ bool isPureKiller(uint32_t c) { || c == 0xA953 || c == 0xABED || c == 0x11134 || c == 0x112EA || c == 0x1172B); } -bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t count, - size_t offset) { +bool GraphemeBreak::isGraphemeBreak(const float* advances, const uint16_t* buf, size_t start, + size_t count, const size_t offset) { // This implementation closely follows Unicode Standard Annex #29 on // Unicode Text Segmentation (http://www.unicode.org/reports/tr29/), // implementing a tailored version of extended grapheme clusters. @@ -73,8 +73,9 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co uint32_t c1 = 0; uint32_t c2 = 0; size_t offset_back = offset; + size_t offset_forward = offset; U16_PREV(buf, start, offset_back, c1); - U16_NEXT(buf, offset, start + count, c2); + U16_NEXT(buf, offset_forward, start + count, c2); int32_t p1 = tailoredGraphemeClusterBreak(c1); int32_t p2 = tailoredGraphemeClusterBreak(c2); // Rule GB3, CR x LF @@ -117,25 +118,23 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co } } - // Note that the offset has moved forwared 2 code units by U16_NEXT. // The number 4 comes from the number of code units in a whole flag. - return (offset - 2 - offset_back) % 4 == 0; + return (offset - offset_back) % 4 == 0; } // Rule GB9, x (Extend | ZWJ); Rule GB9a, x SpacingMark; Rule GB9b, Prepend x if (p2 == U_GCB_EXTEND || p2 == U_GCB_ZWJ || p2 == U_GCB_SPACING_MARK || p1 == U_GCB_PREPEND) { return false; } - // Cluster indic syllables together (tailoring of UAX #29) - // Known limitation: this is overly conservative, and assumes that the virama may form a - // conjunct with the following letter, which doesn't always happen. - // - // There is no easy solution to do this correctly. Even querying the font does not help (with - // the current font technoloies), since the font may be creating the conjunct using multiple - // glyphs, while the user may be perceiving that sequence of glyphs as one conjunct or one - // letter. + // Cluster Indic syllables together (tailoring of UAX #29). + // Immediately after each virama (that is not just a pure killer) followed by a letter, we + // check to see if the next character has a non-zero width assigned to it in the advances + // array. A zero width means a cluster is formed with the virama (so there is no grapheme + // break), while a non-zero width means a new cluster is started (so there may be a grapheme + // break). if (u_getIntPropertyValue(c1, UCHAR_CANONICAL_COMBINING_CLASS) == 9 // virama && !isPureKiller(c1) - && u_getIntPropertyValue(c2, UCHAR_GENERAL_CATEGORY) == U_OTHER_LETTER) { + && u_getIntPropertyValue(c2, UCHAR_GENERAL_CATEGORY) == U_OTHER_LETTER + && (advances == nullptr || advances[offset - start] == 0)) { return false; } // Tailoring: make emoji sequences with ZWJ a single grapheme cluster @@ -170,8 +169,8 @@ bool GraphemeBreak::isGraphemeBreak(const uint16_t* buf, size_t start, size_t co return true; } -size_t GraphemeBreak::getTextRunCursor(const uint16_t* buf, size_t start, size_t count, - size_t offset, MoveOpt opt) { +size_t GraphemeBreak::getTextRunCursor(const float* advances, const uint16_t* buf, size_t start, + size_t count, size_t offset, MoveOpt opt) { switch (opt) { case AFTER: if (offset < start + count) { @@ -179,7 +178,7 @@ size_t GraphemeBreak::getTextRunCursor(const uint16_t* buf, size_t start, size_t } // fall through case AT_OR_AFTER: - while (!isGraphemeBreak(buf, start, count, offset)) { + while (!isGraphemeBreak(advances, buf, start, count, offset)) { offset++; } break; @@ -189,12 +188,12 @@ size_t GraphemeBreak::getTextRunCursor(const uint16_t* buf, size_t start, size_t } // fall through case AT_OR_BEFORE: - while (!isGraphemeBreak(buf, start, count, offset)) { + while (!isGraphemeBreak(advances, buf, start, count, offset)) { offset--; } break; case AT: - if (!isGraphemeBreak(buf, start, count, offset)) { + if (!isGraphemeBreak(advances, buf, start, count, offset)) { offset = (size_t)-1; } break; diff --git a/engine/src/flutter/libs/minikin/Measurement.cpp b/engine/src/flutter/libs/minikin/Measurement.cpp index 0ed7a670bf..f0d15f24e8 100644 --- a/engine/src/flutter/libs/minikin/Measurement.cpp +++ b/engine/src/flutter/libs/minikin/Measurement.cpp @@ -54,7 +54,8 @@ static float getRunAdvance(const float* advances, const uint16_t* buf, size_t la int numGraphemeClustersAfter = 0; for (size_t i = lastCluster; i < nextCluster; i++) { bool isAfter = i >= offset; - if (GraphemeBreak::isGraphemeBreak(buf, start, count, i)) { + if (GraphemeBreak::isGraphemeBreak( + advances + (start - layoutStart), buf, start, count, i)) { numGraphemeClusters++; if (isAfter) { numGraphemeClustersAfter++; @@ -86,7 +87,7 @@ size_t getOffsetForAdvance(const float* advances, const uint16_t* buf, size_t st float x = 0.0f, xLastClusterStart = 0.0f, xSearchStart = 0.0f; size_t lastClusterStart = start, searchStart = start; for (size_t i = start; i < start + count; i++) { - if (GraphemeBreak::isGraphemeBreak(buf, start, count, i)) { + if (GraphemeBreak::isGraphemeBreak(advances, buf, start, count, i)) { searchStart = lastClusterStart; xSearchStart = xLastClusterStart; } @@ -103,7 +104,7 @@ size_t getOffsetForAdvance(const float* advances, const uint16_t* buf, size_t st size_t best = searchStart; float bestDist = FLT_MAX; for (size_t i = searchStart; i <= start + count; i++) { - if (GraphemeBreak::isGraphemeBreak(buf, start, count, i)) { + if (GraphemeBreak::isGraphemeBreak(advances, buf, start, count, i)) { // "getRunAdvance(layout, buf, start, count, i) - advance" but more efficient float delta = getRunAdvance(advances, buf, start, searchStart, count - searchStart, i) diff --git a/engine/src/flutter/tests/perftests/GraphemeBreak.cpp b/engine/src/flutter/tests/perftests/GraphemeBreak.cpp index cfee7c642c..6d6cf5b178 100644 --- a/engine/src/flutter/tests/perftests/GraphemeBreak.cpp +++ b/engine/src/flutter/tests/perftests/GraphemeBreak.cpp @@ -38,7 +38,7 @@ static void BM_GraphemeBreak_Ascii(benchmark::State& state) { LOG_ALWAYS_FATAL_IF(result_size != 12); const size_t testIndex = state.range(0); while (state.KeepRunning()) { - GraphemeBreak::isGraphemeBreak(buffer, 0, result_size, testIndex); + GraphemeBreak::isGraphemeBreak(nullptr, buffer, 0, result_size, testIndex); } } BENCHMARK(BM_GraphemeBreak_Ascii) @@ -53,7 +53,7 @@ static void BM_GraphemeBreak_Emoji(benchmark::State& state) { LOG_ALWAYS_FATAL_IF(result_size != 12); const size_t testIndex = state.range(0); while (state.KeepRunning()) { - GraphemeBreak::isGraphemeBreak(buffer, 0, result_size, testIndex); + GraphemeBreak::isGraphemeBreak(nullptr, buffer, 0, result_size, testIndex); } } BENCHMARK(BM_GraphemeBreak_Emoji) @@ -68,7 +68,7 @@ static void BM_GraphemeBreak_Emoji_Flags(benchmark::State& state) { LOG_ALWAYS_FATAL_IF(result_size != 12); const size_t testIndex = state.range(0); while (state.KeepRunning()) { - GraphemeBreak::isGraphemeBreak(buffer, 0, result_size, testIndex); + GraphemeBreak::isGraphemeBreak(nullptr, buffer, 0, result_size, testIndex); } } BENCHMARK(BM_GraphemeBreak_Emoji_Flags) diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index fdcc0c4e47..716fcc378d 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -76,6 +76,7 @@ LOCAL_SRC_FILES += \ GraphemeBreakTests.cpp \ LayoutTest.cpp \ LayoutUtilsTest.cpp \ + MeasurementTests.cpp \ SparseBitSetTest.cpp \ UnicodeUtilsTest.cpp \ WordBreakerTests.cpp diff --git a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp index 29b1669bd4..96bd8a8e79 100644 --- a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp @@ -26,7 +26,16 @@ bool IsBreak(const char* src) { size_t offset; size_t size; ParseUnicode(buf, BUF_SIZE, src, &size, &offset); - return GraphemeBreak::isGraphemeBreak(buf, 0, size, offset); + return GraphemeBreak::isGraphemeBreak(nullptr, buf, 0, size, offset); +} + +bool IsBreakWithAdvances(const float* advances, const char* src) { + const size_t BUF_SIZE = 256; + uint16_t buf[BUF_SIZE]; + size_t offset; + size_t size; + ParseUnicode(buf, BUF_SIZE, src, &size, &offset); + return GraphemeBreak::isGraphemeBreak(advances, buf, 0, size, offset); } TEST(GraphemeBreak, utf16) { @@ -164,6 +173,31 @@ TEST(GraphemeBreak, tailoring) { EXPECT_FALSE(IsBreak("U+0E01 | U+0E3A U+0E01")); // thai phinthu = pure killer EXPECT_TRUE(IsBreak("U+0E01 U+0E3A | U+0E01")); // thai phinthu = pure killer + // Repetition of above tests, but with a given advances array that implies everything + // became just one cluster. + const float conjoined[] = {1.0, 0.0, 0.0}; + EXPECT_FALSE(IsBreakWithAdvances(conjoined, + "U+0915 | U+094D U+0915")); // Devanagari ka+virama+ka + EXPECT_FALSE(IsBreakWithAdvances(conjoined, + "U+0915 U+094D | U+0915")); // Devanagari ka+virama+ka + EXPECT_FALSE(IsBreakWithAdvances(conjoined, + "U+0E01 | U+0E3A U+0E01")); // thai phinthu = pure killer + EXPECT_TRUE(IsBreakWithAdvances(conjoined, + "U+0E01 U+0E3A | U+0E01")); // thai phinthu = pure killer + + // Repetition of above tests, but with a given advances array that the virama did not + // form a cluster with the following consonant. The difference is that there is now + // a grapheme break after the virama in ka+virama+ka. + const float separate[] = {1.0, 0.0, 1.0}; + EXPECT_FALSE(IsBreakWithAdvances(separate, + "U+0915 | U+094D U+0915")); // Devanagari ka+virama+ka + EXPECT_TRUE(IsBreakWithAdvances(separate, + "U+0915 U+094D | U+0915")); // Devanagari ka+virama+ka + EXPECT_FALSE(IsBreakWithAdvances(separate, + "U+0E01 | U+0E3A U+0E01")); // thai phinthu = pure killer + EXPECT_TRUE(IsBreakWithAdvances(separate, + "U+0E01 U+0E3A | U+0E01")); // thai phinthu = pure killer + // suppress grapheme breaks in zwj emoji sequences, see // http://www.unicode.org/emoji/charts/emoji-zwj-sequences.html EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+2764 U+FE0F U+200D U+1F48B U+200D U+1F468")); @@ -222,10 +256,10 @@ TEST(GraphemeBreak, genderBalancedEmoji) { TEST(GraphemeBreak, offsets) { uint16_t string[] = { 0x0041, 0x06DD, 0x0045, 0x0301, 0x0049, 0x0301 }; - EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(string, 2, 3, 2)); - EXPECT_FALSE(GraphemeBreak::isGraphemeBreak(string, 2, 3, 3)); - EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(string, 2, 3, 4)); - EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(string, 2, 3, 5)); + EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(nullptr, string, 2, 3, 2)); + EXPECT_FALSE(GraphemeBreak::isGraphemeBreak(nullptr, string, 2, 3, 3)); + EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(nullptr, string, 2, 3, 4)); + EXPECT_TRUE(GraphemeBreak::isGraphemeBreak(nullptr, string, 2, 3, 5)); } } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/MeasurementTests.cpp b/engine/src/flutter/tests/unittest/MeasurementTests.cpp new file mode 100644 index 0000000000..7fedecb5ea --- /dev/null +++ b/engine/src/flutter/tests/unittest/MeasurementTests.cpp @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2017 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 +#include +#include + +namespace minikin { + +float getAdvance(const float* advances, const char* src) { + const size_t BUF_SIZE = 256; + uint16_t buf[BUF_SIZE]; + size_t offset; + size_t size; + ParseUnicode(buf, BUF_SIZE, src, &size, &offset); + return getRunAdvance(advances, buf, 0, size, offset); +} + +// Latin fi +TEST(Measurement, getRunAdvance_fi) { + const float unligated[] = {30.0, 20.0}; + EXPECT_EQ(0.0, getAdvance(unligated, "| 'f' 'i'")); + EXPECT_EQ(30.0, getAdvance(unligated, "'f' | 'i'")); + EXPECT_EQ(50.0, getAdvance(unligated, "'f' 'i' |")); + + const float ligated[] = {40.0, 0.0}; + EXPECT_EQ(0.0, getAdvance(ligated, "| 'f' 'i'")); + EXPECT_EQ(20.0, getAdvance(ligated, "'f' | 'i'")); + EXPECT_EQ(40.0, getAdvance(ligated, "'f' 'i' |")); +} + +// Devanagari ka+virama+ka +TEST(Measurement, getRunAdvance_kka) { + const float unligated[] = {30.0, 0.0, 30.0}; + EXPECT_EQ(0.0, getAdvance(unligated, "| U+0915 U+094D U+0915")); + EXPECT_EQ(30.0, getAdvance(unligated, "U+0915 | U+094D U+0915")); + EXPECT_EQ(30.0, getAdvance(unligated, "U+0915 U+094D | U+0915")); + EXPECT_EQ(60.0, getAdvance(unligated, "U+0915 U+094D U+0915 |")); + + const float ligated[] = {30.0, 0.0, 0.0}; + EXPECT_EQ(0.0, getAdvance(ligated, "| U+0915 U+094D U+0915")); + EXPECT_EQ(30.0, getAdvance(ligated, "U+0915 | U+094D U+0915")); + EXPECT_EQ(30.0, getAdvance(ligated, "U+0915 U+094D | U+0915")); + EXPECT_EQ(30.0, getAdvance(ligated, "U+0915 U+094D U+0915 |")); +} + +} // namespace minikin From 8d9c9d7f20e621e6e49f9252128ab8a5d890c67d Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 9 Mar 2017 15:16:16 -0800 Subject: [PATCH 245/364] Expose supportedAxes to frameworks/base The list of supportedAxes are necessary for returning value of setFontVariationSettings. Bug: 35764323 Test: ran TextViewTest and PaintTest in cts Change-Id: I52f244146ea0ce335df02c841f89285be2ed746e --- engine/src/flutter/include/minikin/FontCollection.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/engine/src/flutter/include/minikin/FontCollection.h b/engine/src/flutter/include/minikin/FontCollection.h index 2364538799..545d43db80 100644 --- a/engine/src/flutter/include/minikin/FontCollection.h +++ b/engine/src/flutter/include/minikin/FontCollection.h @@ -53,6 +53,10 @@ public: std::shared_ptr createCollectionWithVariation(const std::vector& variations); + const std::unordered_set& getSupportedTags() const { + return mSupportedAxes; + } + uint32_t getId() const; private: From 3165aebe3bb0afb5f4197ad7955c67ef55c749b1 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 14 Mar 2017 15:34:06 -0700 Subject: [PATCH 246/364] Do not keep FontCollection reference in Layout. LayoutCache only keeps result of layout and can live after FontCollection is destructed by GC. This kind of failure will be captured by minikin_stress_tests in the subsequent CL (I1bf4ba43e6e97cd04e7d6dd42d388dd17ce64c7b) Test: ran minikin_tests Bug: 36223724 Change-Id: I639b73c0f1041549158c43212a901c82df4b02db --- engine/src/flutter/include/minikin/Layout.h | 9 ++- engine/src/flutter/libs/minikin/Layout.cpp | 22 +++--- .../src/flutter/tests/unittest/LayoutTest.cpp | 69 ++++++++++++------- 3 files changed, 60 insertions(+), 40 deletions(-) diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index e9849c382c..8a6e7725d0 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -75,8 +75,7 @@ enum { class Layout { public: - Layout(const std::shared_ptr& collection) - : mGlyphs(), mAdvances(), mCollection(collection), mFaces(), mAdvance(0), mBounds() { + Layout() : mGlyphs(), mAdvances(), mFaces(), mAdvance(0), mBounds() { mBounds.setEmpty(); } @@ -89,7 +88,8 @@ public: void dump() const; void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - int bidiFlags, const FontStyle &style, const MinikinPaint &paint); + int bidiFlags, const FontStyle &style, const MinikinPaint &paint, + const std::shared_ptr& collection); static float measureText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint, @@ -143,7 +143,7 @@ private: // Lay out a single bidi run void doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, LayoutContext* ctx); + bool isRtl, LayoutContext* ctx, const std::shared_ptr& collection); // Append another layout (for example, cached value) into this one void appendLayout(Layout* src, size_t start, float extraAdvance); @@ -151,7 +151,6 @@ private: std::vector mGlyphs; std::vector mAdvances; - std::shared_ptr mCollection; std::vector mFaces; float mAdvance; MinikinRect mBounds; diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 743cb763ae..4032d4c943 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -131,10 +131,11 @@ public: mChars = NULL; } - void doLayout(Layout* layout, LayoutContext* ctx) const { + void doLayout(Layout* layout, LayoutContext* ctx, + const std::shared_ptr& collection) const { layout->mAdvances.resize(mCount, 0); ctx->clearHbFonts(); - layout->doLayoutRun(mChars, mStart, mCount, mNchars, mIsRtl, ctx); + layout->doLayoutRun(mChars, mStart, mCount, mNchars, mIsRtl, ctx, collection); } private: @@ -173,8 +174,8 @@ public: Layout* layout = mCache.get(key); if (layout == NULL) { key.copyText(); - layout = new Layout(collection); - key.doLayout(layout, ctx); + layout = new Layout(); + key.doLayout(layout, ctx, collection); mCache.put(key, layout); } return layout; @@ -584,7 +585,8 @@ BidiText::BidiText(const uint16_t* buf, size_t start, size_t count, size_t bufSi } void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - int bidiFlags, const FontStyle &style, const MinikinPaint &paint) { + int bidiFlags, const FontStyle &style, const MinikinPaint &paint, + const std::shared_ptr& collection) { android::AutoMutex _l(gMinikinLock); LayoutContext ctx; @@ -596,7 +598,7 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu for (const BidiText::Iter::RunInfo& runInfo : BidiText(buf, start, count, bufSize, bidiFlags)) { doLayoutRunCached(buf, runInfo.mRunStart, runInfo.mRunLength, bufSize, runInfo.mIsRtl, &ctx, - start, mCollection, this, NULL); + start, collection, this, NULL); } ctx.clearHbFonts(); } @@ -684,8 +686,8 @@ float Layout::doLayoutWord(const uint16_t* buf, size_t start, size_t count, size float advance; if (ctx->paint.skipCache()) { - Layout layoutForWord(collection); - key.doLayout(&layoutForWord, ctx); + Layout layoutForWord; + key.doLayout(&layoutForWord, ctx, collection); if (layout) { layout->appendLayout(&layoutForWord, bufStart, wordSpacing); } @@ -863,10 +865,10 @@ static inline uint32_t addToHbBuffer(hb_buffer_t* buffer, void Layout::doLayoutRun(const uint16_t* buf, size_t start, size_t count, size_t bufSize, - bool isRtl, LayoutContext* ctx) { + bool isRtl, LayoutContext* ctx, const std::shared_ptr& collection) { hb_buffer_t* buffer = LayoutEngine::getInstance().hbBuffer; vector items; - mCollection->itemize(buf + start, count, ctx->style, &items); + collection->itemize(buf + start, count, ctx->style, &items); vector features; // Disable default-on non-required ligature features if letter-spacing diff --git a/engine/src/flutter/tests/unittest/LayoutTest.cpp b/engine/src/flutter/tests/unittest/LayoutTest.cpp index ed41ca4574..1770d3ac5e 100644 --- a/engine/src/flutter/tests/unittest/LayoutTest.cpp +++ b/engine/src/flutter/tests/unittest/LayoutTest.cpp @@ -70,14 +70,15 @@ TEST_F(LayoutTest, doLayoutTest) { float advances[kMaxAdvanceLength]; std::vector expectedValues; - Layout layout(mCollection); + Layout layout; std::vector text; // The mock implementation returns 10.0f advance and 0,0-10x10 bounds for all glyph. { SCOPED_TRACE("one word"); text = utf8ToUtf16("oneword"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(70.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -95,7 +96,8 @@ TEST_F(LayoutTest, doLayoutTest) { { SCOPED_TRACE("two words"); text = utf8ToUtf16("two words"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(90.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -113,7 +115,8 @@ TEST_F(LayoutTest, doLayoutTest) { { SCOPED_TRACE("three words"); text = utf8ToUtf16("three words test"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(160.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -131,7 +134,8 @@ TEST_F(LayoutTest, doLayoutTest) { { SCOPED_TRACE("two spaces"); text = utf8ToUtf16("two spaces"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(110.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -156,7 +160,7 @@ TEST_F(LayoutTest, doLayoutTest_wordSpacing) { std::vector expectedValues; std::vector text; - Layout layout(mCollection); + Layout layout; paint.wordSpacing = 5.0f; @@ -164,7 +168,8 @@ TEST_F(LayoutTest, doLayoutTest_wordSpacing) { { SCOPED_TRACE("one word"); text = utf8ToUtf16("oneword"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(70.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -182,7 +187,8 @@ TEST_F(LayoutTest, doLayoutTest_wordSpacing) { { SCOPED_TRACE("two words"); text = utf8ToUtf16("two words"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(95.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -204,7 +210,8 @@ TEST_F(LayoutTest, doLayoutTest_wordSpacing) { { SCOPED_TRACE("three words test"); text = utf8ToUtf16("three words test"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(170.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -224,7 +231,8 @@ TEST_F(LayoutTest, doLayoutTest_wordSpacing) { { SCOPED_TRACE("two spaces"); text = utf8ToUtf16("two spaces"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(120.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -250,7 +258,7 @@ TEST_F(LayoutTest, doLayoutTest_negativeWordSpacing) { float advances[kMaxAdvanceLength]; std::vector expectedValues; - Layout layout(mCollection); + Layout layout; std::vector text; // Negative word spacing also should work. @@ -259,7 +267,8 @@ TEST_F(LayoutTest, doLayoutTest_negativeWordSpacing) { { SCOPED_TRACE("one word"); text = utf8ToUtf16("oneword"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(70.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -277,7 +286,8 @@ TEST_F(LayoutTest, doLayoutTest_negativeWordSpacing) { { SCOPED_TRACE("two words"); text = utf8ToUtf16("two words"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(85.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -296,7 +306,8 @@ TEST_F(LayoutTest, doLayoutTest_negativeWordSpacing) { { SCOPED_TRACE("three words"); text = utf8ToUtf16("three word test"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(140.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -316,7 +327,8 @@ TEST_F(LayoutTest, doLayoutTest_negativeWordSpacing) { { SCOPED_TRACE("two spaces"); text = utf8ToUtf16("two spaces"); - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(100.0f, layout.getAdvance()); layout.getBounds(&rect); EXPECT_EQ(0.0f, rect.mLeft); @@ -340,11 +352,13 @@ TEST_F(LayoutTest, doLayoutTest_rtlTest) { std::vector text = parseUnicodeString("'a' 'b' U+3042 U+3043 'c' 'd'"); - Layout ltrLayout(mCollection); - ltrLayout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + Layout ltrLayout; + ltrLayout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); - Layout rtlLayout(mCollection); - rtlLayout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_RTL, FontStyle(), paint); + Layout rtlLayout; + rtlLayout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_RTL, FontStyle(), paint, + mCollection); ASSERT_EQ(ltrLayout.nGlyphs(), rtlLayout.nGlyphs()); ASSERT_EQ(6u, ltrLayout.nGlyphs()); @@ -357,7 +371,7 @@ TEST_F(LayoutTest, doLayoutTest_rtlTest) { } TEST_F(LayoutTest, hyphenationTest) { - Layout layout(mCollection); + Layout layout; std::vector text; // The mock implementation returns 10.0f advance for all glyphs. @@ -366,7 +380,8 @@ TEST_F(LayoutTest, hyphenationTest) { text = utf8ToUtf16("oneword"); MinikinPaint paint; paint.hyphenEdit = HyphenEdit::NO_EDIT; - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(70.0f, layout.getAdvance()); } { @@ -374,7 +389,8 @@ TEST_F(LayoutTest, hyphenationTest) { text = utf8ToUtf16("oneword"); MinikinPaint paint; paint.hyphenEdit = HyphenEdit::INSERT_HYPHEN_AT_END; - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(80.0f, layout.getAdvance()); } { @@ -382,7 +398,8 @@ TEST_F(LayoutTest, hyphenationTest) { text = utf8ToUtf16("oneword"); MinikinPaint paint; paint.hyphenEdit = HyphenEdit::REPLACE_WITH_HYPHEN_AT_END; - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(70.0f, layout.getAdvance()); } { @@ -390,7 +407,8 @@ TEST_F(LayoutTest, hyphenationTest) { text = utf8ToUtf16("oneword"); MinikinPaint paint; paint.hyphenEdit = HyphenEdit::INSERT_HYPHEN_AT_START; - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(80.0f, layout.getAdvance()); } { @@ -398,7 +416,8 @@ TEST_F(LayoutTest, hyphenationTest) { text = utf8ToUtf16("oneword"); MinikinPaint paint; paint.hyphenEdit = HyphenEdit::INSERT_HYPHEN_AT_START | HyphenEdit::INSERT_HYPHEN_AT_END; - layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), paint, + mCollection); EXPECT_EQ(90.0f, layout.getAdvance()); } } From d2aaf3394aaf2f6c77f3b083c1621495673a4287 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Tue, 14 Mar 2017 14:59:58 -0700 Subject: [PATCH 247/364] In greedy line breaking, repeat breaks until the line fits Previously, in greedy line breaking, when a line overflowed, we found the best line breaking candidate before it and broke the line there. But we didn't check to see if the remaining part now fits in a line. With this change, we now repeat checking for overflows, and break again until we have no breaking opportunity or the remaining text now fits in a line. Also found an issue with greedy line breaking and keeping the hyphenation edit for the next line which is now fixed. Test: Manual. The issue reported in the bug is now fixed. Bug: 34185255 Bug: https://code.google.com/p/android/issues/detail?id=231437 Bug: 33560754 Change-Id: I93bdd341e4f8e1257710e453e4938f224cb2a1ff --- .../src/flutter/include/minikin/LineBreaker.h | 6 +- .../src/flutter/libs/minikin/LineBreaker.cpp | 56 +++++++++++++++---- 2 files changed, 50 insertions(+), 12 deletions(-) diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index ce8eb7d571..c91c0b3da7 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -191,8 +191,8 @@ class LineBreaker { struct Candidate { size_t offset; // offset to text buffer, in code units size_t prev; // index to previous break - ParaWidth preBreak; - ParaWidth postBreak; + ParaWidth preBreak; // width of text until this point, if we decide to not break here + ParaWidth postBreak; // width of text until this point, if we decide to break here float penalty; // penalty of this break (for example, hyphen penalty) float score; // best score found for this break size_t lineNumber; // only updated for non-constant line widths @@ -207,6 +207,7 @@ class LineBreaker { size_t preSpaceCount, size_t postSpaceCount, float penalty, HyphenationType hyph); void addCandidate(Candidate cand); + void pushGreedyBreak(); // push an actual break to the output. Takes care of setting flags for tab void pushBreak(int offset, float width, uint8_t hyphenEdit); @@ -248,6 +249,7 @@ class LineBreaker { size_t mBestBreak; float mBestScore; ParaWidth mPreBreak; // prebreak of last break + uint32_t mLastHyphenation; // hyphen edit of last break kept for next line int mFirstTabIndex; size_t mSpaceCount; }; diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index b8814b63d4..e75c7bf523 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -84,6 +84,7 @@ void LineBreaker::setText() { mBestBreak = 0; mBestScore = SCORE_INFTY; mPreBreak = 0; + mLastHyphenation = HyphenEdit::NO_EDIT; mFirstTabIndex = INT_MAX; mSpaceCount = 0; } @@ -269,24 +270,59 @@ void LineBreaker::addWordBreak(size_t offset, ParaWidth preBreak, ParaWidth post addCandidate(cand); } +// Helper method for addCandidate() +void LineBreaker::pushGreedyBreak() { + const Candidate& bestCandidate = mCandidates[mBestBreak]; + pushBreak(bestCandidate.offset, bestCandidate.postBreak - mPreBreak, + mLastHyphenation | HyphenEdit::editForThisLine(bestCandidate.hyphenType)); + mBestScore = SCORE_INFTY; +#if VERBOSE_DEBUG + ALOGD("break: %d %g", mBreaks.back(), mWidths.back()); +#endif + mLastBreak = mBestBreak; + mPreBreak = bestCandidate.preBreak; + mLastHyphenation = HyphenEdit::editForNextLine(bestCandidate.hyphenType); +} + // TODO performance: could avoid populating mCandidates if greedy only void LineBreaker::addCandidate(Candidate cand) { - size_t candIndex = mCandidates.size(); + const size_t candIndex = mCandidates.size(); mCandidates.push_back(cand); + + // mLastBreak is the index of the last line break we decided to do in mCandidates, + // and mPreBreak is its preBreak value. mBestBreak is the index of the best line breaking candidate + // we have found since then, and mBestScore is its penalty. if (cand.postBreak - mPreBreak > currentLineWidth()) { // This break would create an overfull line, pick the best break and break there (greedy) if (mBestBreak == mLastBreak) { + // No good break has been found since last break. Break here. mBestBreak = candIndex; } - pushBreak(mCandidates[mBestBreak].offset, mCandidates[mBestBreak].postBreak - mPreBreak, - HyphenEdit::editForThisLine(mCandidates[mBestBreak].hyphenType)); - mBestScore = SCORE_INFTY; -#if VERBOSE_DEBUG - ALOGD("break: %d %g", mBreaks.back(), mWidths.back()); -#endif - mLastBreak = mBestBreak; - mPreBreak = mCandidates[mBestBreak].preBreak; + pushGreedyBreak(); } + + while (mLastBreak != candIndex && cand.postBreak - mPreBreak > currentLineWidth()) { + // We should rarely come here. But if we are here, we have broken the line, but the + // remaining part still doesn't fit. We now need to break at the second best place after the + // last break, but we have not kept that information, so we need to go back and find it. + // + // In some really rare cases, postBreak - preBreak of a candidate itself may be over the + // current line width. We protect ourselves against an infinite loop in that case by + // checking that we have not broken the line at this candidate already. + for (size_t i = mLastBreak + 1; i < candIndex; i++) { + const float penalty = mCandidates[i].penalty; + if (penalty <= mBestScore) { + mBestBreak = i; + mBestScore = penalty; + } + } + if (mBestBreak == mLastBreak) { + // We didn't find anything good. Break here. + mBestBreak = candIndex; + } + pushGreedyBreak(); + } + if (cand.penalty <= mBestScore) { mBestBreak = candIndex; mBestScore = cand.penalty; @@ -329,7 +365,7 @@ void LineBreaker::computeBreaksGreedy() { size_t nCand = mCandidates.size(); if (nCand == 1 || mLastBreak != nCand - 1) { pushBreak(mCandidates[nCand - 1].offset, mCandidates[nCand - 1].postBreak - mPreBreak, - HyphenEdit::NO_EDIT); + mLastHyphenation); // don't need to update mBestScore, because we're done #if VERBOSE_DEBUG ALOGD("final break: %d %g", mBreaks.back(), mWidths.back()); From aae6468815e9c1ee279d07853b8e11ac715d38c0 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Wed, 15 Mar 2017 14:13:58 -0700 Subject: [PATCH 248/364] Fallback from script-specific hyphens to normal hyphen first The previous code fell back directly from a script-specific hyphen to the ASCII hyphen-minus if the font didn't support the script-specific hyphen. Now we try the Unicode hyphen (U+2010) first before trying the ASCII hyphen-minus. Bug: 36201363 Test: Not needed Change-Id: I374234fd73fab7edd990ea86f8937c38761c90bf --- engine/src/flutter/libs/minikin/Layout.cpp | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 4032d4c943..0a318bdccd 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -736,12 +736,22 @@ static void addFeatures(const string &str, vector* features) { } } +static const hb_codepoint_t CHAR_HYPHEN = 0x2010; /* HYPHEN */ + static inline hb_codepoint_t determineHyphenChar(hb_codepoint_t preferredHyphen, hb_font_t* font) { - if (preferredHyphen == 0x2010 /* HYPHEN */ - || preferredHyphen == 0x058A /* ARMENIAN_HYPHEN */ + hb_codepoint_t glyph; + if (preferredHyphen == 0x058A /* ARMENIAN_HYPHEN */ || preferredHyphen == 0x05BE /* HEBREW PUNCTUATION MAQAF */ || preferredHyphen == 0x1400 /* CANADIAN SYLLABIC HYPHEN */) { - hb_codepoint_t glyph; + if (hb_font_get_nominal_glyph(font, preferredHyphen, &glyph)) { + return preferredHyphen; + } else { + // The original hyphen requested was not supported. Let's try and see if the + // Unicode hyphen is supported. + preferredHyphen = CHAR_HYPHEN; + } + } + if (preferredHyphen == CHAR_HYPHEN) { /* HYPHEN */ // Fallback to ASCII HYPHEN-MINUS if the font didn't have a glyph for the preferred hyphen. // Note that we intentionally don't do anything special if the font doesn't have a // HYPHEN-MINUS either, so a tofu could be shown, hinting towards something missing. From ca8ac8a9249979e0c5b46463195e1c61b2186ac8 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 14 Mar 2017 17:57:28 -0700 Subject: [PATCH 249/364] Serialize and deserialize supported axes. To avoid reading font files during FontFamily construction, serialize and deserialize supported axes and cmap coverage at the same time. Bug: 36232655 Test: ran minikin_tests Change-Id: I4086fb887e13f872390b533584bce6f1d5598ea0 --- .../src/flutter/include/minikin/FontFamily.h | 10 +++- .../src/flutter/libs/minikin/FontFamily.cpp | 57 +++++++++++++++---- .../flutter/tests/unittest/FontFamilyTest.cpp | 46 +++++++++++++++ 3 files changed, 99 insertions(+), 14 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 4186c2baab..18a75ee8ec 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -110,10 +110,8 @@ struct Font { std::shared_ptr typeface; FontStyle style; - std::unordered_set supportedAxes; -private: - void loadAxes(); + std::unordered_set getSupportedAxesLocked() const; }; struct FontVariation { @@ -181,6 +179,12 @@ private: void computeCoverage(); void readAcceleratorTable(const uint8_t* data, size_t size); + size_t writeSupportedAxes(uint8_t* out) const; + + // Reads supported axes values from 'in' buffer. This method reads up to + // 'inSize' bytes and returns the number of bytes read. + size_t readSupportedAxes(const uint8_t* in, size_t inSize); + uint32_t mLangId; int mVariant; std::vector mFonts; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 4097e8fb23..076dff2bcc 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -67,36 +67,33 @@ uint32_t FontStyle::pack(int variant, int weight, bool italic) { Font::Font(const std::shared_ptr& typeface, FontStyle style) : typeface(typeface), style(style) { - loadAxes(); } Font::Font(std::shared_ptr&& typeface, FontStyle style) : typeface(typeface), style(style) { - loadAxes(); } -void Font::loadAxes() { - android::AutoMutex _l(gMinikinLock); +std::unordered_set Font::getSupportedAxesLocked() const { const uint32_t fvarTag = MinikinFont::MakeTag('f', 'v', 'a', 'r'); HbBlob fvarTable(getFontTable(typeface.get(), fvarTag)); if (fvarTable.size() == 0) { - return; + return std::unordered_set(); } + std::unordered_set supportedAxes; analyzeAxes(fvarTable.get(), fvarTable.size(), &supportedAxes); + return supportedAxes; } Font::Font(Font&& o) { typeface = std::move(o.typeface); style = o.style; o.typeface = nullptr; - supportedAxes = std::move(o.supportedAxes); } Font::Font(const Font& o) { typeface = o.typeface; style = o.style; - supportedAxes = o.supportedAxes; } // static @@ -201,7 +198,8 @@ void FontFamily::computeCoverage() { CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); for (size_t i = 0; i < mFonts.size(); ++i) { - mSupportedAxes.insert(mFonts[i].supportedAxes.begin(), mFonts[i].supportedAxes.end()); + std::unordered_set supportedAxes = mFonts[i].getSupportedAxesLocked(); + mSupportedAxes.insert(supportedAxes.begin(), supportedAxes.end()); } } @@ -242,9 +240,11 @@ std::shared_ptr FontFamily::createFamilyWithVariation( std::vector fonts; for (const Font& font : mFonts) { bool supportedVariations = false; - if (!font.supportedAxes.empty()) { + android::AutoMutex _l(gMinikinLock); + std::unordered_set supportedAxes = font.getSupportedAxesLocked(); + if (!supportedAxes.empty()) { for (const FontVariation& variation : variations) { - if (font.supportedAxes.find(variation.axisTag) != font.supportedAxes.end()) { + if (supportedAxes.find(variation.axisTag) != supportedAxes.end()) { supportedVariations = true; break; } @@ -264,11 +264,46 @@ std::shared_ptr FontFamily::createFamilyWithVariation( } size_t FontFamily::writeAcceleratorTable(uint8_t* out) const { - return mCoverage.writeToBuffer(out); + const size_t axesTableSize = writeSupportedAxes(out); + if (out != nullptr) { + out += axesTableSize; + } + const size_t coverageTableSize = mCoverage.writeToBuffer(out); + return axesTableSize + coverageTableSize; } void FontFamily::readAcceleratorTable(const uint8_t* data, size_t size) { + const size_t readSize = readSupportedAxes(data, size); + data += readSize; + size -= readSize; bool result = mCoverage.initFromBuffer(data, size); LOG_ALWAYS_FATAL_IF(!result, "Failed to reconstruct accelerator table from buffer"); } + +size_t FontFamily::writeSupportedAxes(uint8_t* out) const { + LOG_ALWAYS_FATAL_IF(mSupportedAxes.size() > 255, "System fonts may only use up to 255 axes."); + const uint8_t axesCount = static_cast(mSupportedAxes.size()); + if (out != nullptr) { + out[0] = axesCount; + AxisTag* axisTags = reinterpret_cast(out + 1); + for (const auto& tag : mSupportedAxes) { + *axisTags++ = tag; + } + } + const size_t axesSizeInbytes = sizeof(AxisTag) * axesCount; + return axesSizeInbytes + 1 /* 1 for axes count */; +} + +size_t FontFamily::readSupportedAxes(const uint8_t* in, size_t inSize) { + LOG_ALWAYS_FATAL_IF(inSize == 0); + const uint8_t axesCount = in[0]; + const size_t totalSize = sizeof(AxisTag) * axesCount + 1 /* 1 for axes Count */; + LOG_ALWAYS_FATAL_IF(inSize < totalSize); + const AxisTag* axisTags = reinterpret_cast(in + 1); + mSupportedAxes.clear(); + for (uint8_t i = 0; i < axesCount; ++i) { + mSupportedAxes.insert(axisTags[i]); + } + return totalSize; +} } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 5285f2642b..58a7bab5f6 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -656,4 +656,50 @@ TEST_F(FontFamilyTest, createFamilyWithVariationTest) { } } +TEST_F(FontFamilyTest, supportedAxesRestoreFromSerializedBuffer) { + const char kFontPath[] = kTestFontDir "/MultiAxis.ttf"; + + std::shared_ptr font(new MinikinFontForTest(kFontPath)); + std::shared_ptr family = + std::make_shared(std::vector({Font(font, FontStyle())})); + + size_t necessaryBytes = family->writeAcceleratorTable(nullptr); + ASSERT_NE(0U, necessaryBytes); + std::vector buffer; + buffer.resize(necessaryBytes); + family->writeAcceleratorTable(buffer.data()); + + std::shared_ptr restoredMultiAxisFamily = + std::make_shared(std::vector({Font(font, FontStyle())}), + buffer.data(), buffer.size()); + + // This font has 'wdth' and 'wght' axes. + const std::unordered_set& supportedAxes = family->supportedAxes(); + ASSERT_EQ(2U, supportedAxes.size()); + EXPECT_NE(supportedAxes.end(), supportedAxes.find(MinikinFont::MakeTag('w', 'd', 't', 'h'))); + EXPECT_NE(supportedAxes.end(), supportedAxes.find(MinikinFont::MakeTag('w', 'g', 'h', 't'))); +} + +TEST_F(FontFamilyTest, supportedAxesRestoreFromSerializedBuffer_NoAxisFont) { + const char kFontPath[] = kTestFontDir "/Regular.ttf"; + + std::shared_ptr font(new MinikinFontForTest(kFontPath)); + std::shared_ptr family = + std::make_shared(std::vector({Font(font, FontStyle())})); + + size_t necessaryBytes = family->writeAcceleratorTable(nullptr); + ASSERT_NE(0U, necessaryBytes); + std::vector buffer; + buffer.resize(necessaryBytes); + family->writeAcceleratorTable(buffer.data()); + + std::shared_ptr restoredMultiAxisFamily = + std::make_shared(std::vector({Font(font, FontStyle())}), + buffer.data(), buffer.size()); + + // This font supports no axes. + const std::unordered_set& supportedAxes = family->supportedAxes(); + EXPECT_TRUE(supportedAxes.empty()); +} + } // namespace minikin From e64e9b217609148f704009ae878e36f5a3cb01f0 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Tue, 14 Mar 2017 18:10:48 -0700 Subject: [PATCH 250/364] Introduce minikin_stress_tests to find race condition. This is designed for catching race condition. The stress_tests is splited from unit test binary since this takes 30 seconds on angler. Bug: 36223724 Bug: 36208043 Test: ran minikin_stress_tests Change-Id: I1bf4ba43e6e97cd04e7d6dd42d388dd17ce64c7b --- .../src/flutter/tests/stresstest/Android.mk | 56 +++++++++ .../tests/stresstest/MultithreadTest.cpp | 109 ++++++++++++++++++ .../flutter/tests/stresstest/how_to_run.txt | 3 + 3 files changed, 168 insertions(+) create mode 100644 engine/src/flutter/tests/stresstest/Android.mk create mode 100644 engine/src/flutter/tests/stresstest/MultithreadTest.cpp create mode 100644 engine/src/flutter/tests/stresstest/how_to_run.txt diff --git a/engine/src/flutter/tests/stresstest/Android.mk b/engine/src/flutter/tests/stresstest/Android.mk new file mode 100644 index 0000000000..961978b5cc --- /dev/null +++ b/engine/src/flutter/tests/stresstest/Android.mk @@ -0,0 +1,56 @@ +# Copyright (C) 2017 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. + +# see how_to_run.txt for instructions on running these tests + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_TEST_DATA := $(foreach f,$(LOCAL_TEST_DATA),frameworks/minikin/tests:$(f)) + +LOCAL_MODULE := minikin_stress_tests +LOCAL_MODULE_TAGS := tests +LOCAL_MODULE_CLASS := NATIVE_TESTS + +LOCAL_STATIC_LIBRARIES := libminikin + +# Shared libraries which are dependencies of minikin; these are not automatically +# pulled in by the build system (and thus sadly must be repeated). + +LOCAL_SHARED_LIBRARIES := \ + libskia \ + libft2 \ + libharfbuzz_ng \ + libicuuc \ + liblog \ + libutils \ + libz + +LOCAL_STATIC_LIBRARIES += \ + libxml2 + +LOCAL_SRC_FILES += \ + ../util/FontTestUtils.cpp \ + ../util/MinikinFontForTest.cpp \ + MultithreadTest.cpp \ + +LOCAL_C_INCLUDES := \ + $(LOCAL_PATH)/../../libs/minikin/ \ + $(LOCAL_PATH)/../util \ + external/libxml2/include \ + +LOCAL_CPPFLAGS += -Werror -Wall -Wextra + +include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/stresstest/MultithreadTest.cpp b/engine/src/flutter/tests/stresstest/MultithreadTest.cpp new file mode 100644 index 0000000000..08c94b99fe --- /dev/null +++ b/engine/src/flutter/tests/stresstest/MultithreadTest.cpp @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2017 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 + +#include +#include +#include +#include + +#include + +#include "MinikinInternal.h" +#include "minikin/FontCollection.h" +#include "minikin/Layout.h" +#include "../util/FontTestUtils.h" + +namespace minikin { + +const char* SYSTEM_FONT_PATH = "/system/fonts/"; +const char* SYSTEM_FONT_XML = "/system/etc/fonts.xml"; + +constexpr int LAYOUT_COUNT_PER_COLLECTION = 500; +constexpr int COLLECTION_COUNT_PER_THREAD = 15; +constexpr int NUM_THREADS = 10; + +std::mutex gMutex; +std::condition_variable gCv; +bool gReady = false; + +static std::vector generateTestText( + std::mt19937* mt, int lettersInWord, int wordsInText) { + std::uniform_int_distribution dist('A', 'Z'); + + std::vector text; + text.reserve((lettersInWord + 1) * wordsInText - 1); + for (int i = 0; i < wordsInText; ++i) { + if (i != 0) { + text.emplace_back(' '); + } + for (int j = 0; j < lettersInWord; ++j) { + text.emplace_back(dist(*mt)); + } + } + return text; +} + +static void thread_main(int tid) { + { + // Wait until all threads are created. + std::unique_lock lock(gMutex); + gCv.wait(lock, [] { return gReady; }); + } + + std::mt19937 mt(tid); + MinikinPaint paint; + + for (int i = 0; i < COLLECTION_COUNT_PER_THREAD; ++i) { + std::shared_ptr collection( + getFontCollection(SYSTEM_FONT_PATH, SYSTEM_FONT_XML)); + + for (int j = 0; j < LAYOUT_COUNT_PER_COLLECTION; ++j) { + // Generates 10 of 3-letter words so that the word sometimes hit the cache. + Layout layout; + std::vector text = generateTestText(&mt, 3, 10); + layout.doLayout(text.data(), 0, text.size(), text.size(), kBidi_LTR, FontStyle(), + paint, collection); + std::vector advances(text.size()); + layout.getAdvances(advances.data()); + for (size_t k = 0; k < advances.size(); ++k) { + // MinikinFontForTest always returns 10.0f for horizontal advance. + LOG_ALWAYS_FATAL_IF(advances[k] != 10.0f, "Memory corruption detected."); + } + } + } +} + +TEST(MultithreadTest, ThreadSafeStressTest) { + std::vector threads; + + { + std::unique_lock lock(gMutex); + threads.reserve(NUM_THREADS); + for (int i = 0; i < NUM_THREADS; ++i) { + threads.emplace_back(&thread_main, i); + } + gReady = true; + } + gCv.notify_all(); + + for (auto& thread : threads) { + thread.join(); + } +} + +} // namespace minikin diff --git a/engine/src/flutter/tests/stresstest/how_to_run.txt b/engine/src/flutter/tests/stresstest/how_to_run.txt new file mode 100644 index 0000000000..ba4dbdf1f7 --- /dev/null +++ b/engine/src/flutter/tests/stresstest/how_to_run.txt @@ -0,0 +1,3 @@ +mmm -j8 frameworks/minikin/tests/stresstest && +adb sync data && +adb shell /data/nativetest/minikin_tests/minikin_stress_tests From f3399b503e4f4beafe1f689a2ba56332097203fb Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Thu, 16 Mar 2017 12:23:08 -0700 Subject: [PATCH 251/364] Refactor WordBreaker Refactor WordBreaker to make it ready for more complex behavior. Test: existing unit tests continue to pass Change-Id: Ife758f3e2cf48922ab56109e6c5d3cffa3673feb --- .../src/flutter/include/minikin/WordBreaker.h | 4 + .../src/flutter/libs/minikin/WordBreaker.cpp | 115 ++++++++++-------- 2 files changed, 69 insertions(+), 50 deletions(-) diff --git a/engine/src/flutter/include/minikin/WordBreaker.h b/engine/src/flutter/include/minikin/WordBreaker.h index 0f95bb208a..6971ce2013 100644 --- a/engine/src/flutter/include/minikin/WordBreaker.h +++ b/engine/src/flutter/include/minikin/WordBreaker.h @@ -55,6 +55,10 @@ public: void finish(); private: + int32_t iteratorNext(); + void detectEmailOrUrl(); + ssize_t findNextBreakInEmailOrUrl(); + std::unique_ptr mBreakIterator; UText mUText = UTEXT_INITIALIZER; const uint16_t* mText = nullptr; diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index 7ad7242dff..36a3e88b23 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -58,14 +58,6 @@ ssize_t WordBreaker::current() const { return mCurrent; } -enum ScanState { - START, - SAW_AT, - SAW_COLON, - SAW_COLON_SLASH, - SAW_COLON_SLASH_SLASH, -}; - /** * Determine whether a line break at position i within the buffer buf is valid. This * represents customization beyond the ICU behavior, because plain ICU provides some @@ -120,6 +112,22 @@ static bool isBreakValid(const uint16_t* buf, size_t bufEnd, size_t i) { return true; } +// Customized iteratorNext that takes care of both resets and our modifications +// to ICU's behavior. +int32_t WordBreaker::iteratorNext() { + int32_t result; + do { + if (mIteratorWasReset) { + result = mBreakIterator->following(mCurrent); + mIteratorWasReset = false; + } else { + result = mBreakIterator->next(); + } + } while (!(result == icu::BreakIterator::DONE || (size_t)result == mTextSize + || isBreakValid(mText, mTextSize, result))); + return result; +} + // Chicago Manual of Style recommends breaking after these characters in URLs and email addresses static bool breakAfter(uint16_t c) { return c == ':' || c == '=' || c == '&'; @@ -131,9 +139,15 @@ static bool breakBefore(uint16_t c) { || c == '%' || c == '=' || c == '&'; } -ssize_t WordBreaker::next() { - mLast = mCurrent; +enum ScanState { + START, + SAW_AT, + SAW_COLON, + SAW_COLON_SLASH, + SAW_COLON_SLASH_SLASH, +}; +void WordBreaker::detectEmailOrUrl() { // scan forward from current ICU position for email address or URL if (mLast >= mScanOffset) { ScanState state = START; @@ -158,6 +172,9 @@ ssize_t WordBreaker::next() { } if (state == SAW_AT || state == SAW_COLON_SLASH_SLASH) { if (!mBreakIterator->isBoundary(i)) { + // If there are combining marks or such at the end of the URL or the email address, + // consider them a part of the URL or the email, and skip to the next actual + // boundary. i = mBreakIterator->following(i); } mInEmailOrUrl = true; @@ -167,48 +184,46 @@ ssize_t WordBreaker::next() { } mScanOffset = i; } +} - if (mInEmailOrUrl) { - // special rules for email addresses and URL's as per Chicago Manual of Style (16th ed.) - uint16_t lastChar = mText[mLast]; - ssize_t i; - for (i = mLast + 1; i < mScanOffset; i++) { - if (breakAfter(lastChar)) { - break; - } - // break after double slash - if (lastChar == '/' && i >= mLast + 2 && mText[i - 2] == '/') { - break; - } - uint16_t thisChar = mText[i]; - // never break after hyphen - if (lastChar != '-') { - if (breakBefore(thisChar)) { - break; - } - // break before single slash - if (thisChar == '/' && lastChar != '/' && - !(i + 1 < mScanOffset && mText[i + 1] == '/')) { - break; - } - } - lastChar = thisChar; +ssize_t WordBreaker::findNextBreakInEmailOrUrl() { + // special rules for email addresses and URL's as per Chicago Manual of Style (16th ed.) + uint16_t lastChar = mText[mLast]; + ssize_t i; + for (i = mLast + 1; i < mScanOffset; i++) { + if (breakAfter(lastChar)) { + break; } - mCurrent = i; - return mCurrent; + // break after double slash + if (lastChar == '/' && i >= mLast + 2 && mText[i - 2] == '/') { + break; + } + const uint16_t thisChar = mText[i]; + // never break after hyphen + if (lastChar != '-') { + if (breakBefore(thisChar)) { + break; + } + // break before single slash + if (thisChar == '/' && lastChar != '/' && + !(i + 1 < mScanOffset && mText[i + 1] == '/')) { + break; + } + } + lastChar = thisChar; } + return i; +} - int32_t result; - do { - if (mIteratorWasReset) { - result = mBreakIterator->following(mCurrent); - mIteratorWasReset = false; - } else { - result = mBreakIterator->next(); - } - } while (result != icu::BreakIterator::DONE && (size_t)result != mTextSize - && !isBreakValid(mText, mTextSize, result)); - mCurrent = (ssize_t)result; +ssize_t WordBreaker::next() { + mLast = mCurrent; + + detectEmailOrUrl(); + if (mInEmailOrUrl) { + mCurrent = findNextBreakInEmailOrUrl(); + } else { // Business as usual + mCurrent = (ssize_t) iteratorNext(); + } return mCurrent; } @@ -221,7 +236,7 @@ ssize_t WordBreaker::wordStart() const { UChar32 c; ssize_t ix = result; U16_NEXT(mText, ix, mCurrent, c); - int32_t lb = u_getIntPropertyValue(c, UCHAR_LINE_BREAK); + const int32_t lb = u_getIntPropertyValue(c, UCHAR_LINE_BREAK); // strip leading punctuation, defined as OP and QU line breaking classes, // see UAX #14 if (!(lb == U_LB_OPEN_PUNCTUATION || lb == U_LB_QUOTATION)) { @@ -241,7 +256,7 @@ ssize_t WordBreaker::wordEnd() const { UChar32 c; ssize_t ix = result; U16_PREV(mText, mLast, ix, c); - int32_t gc_mask = U_GET_GC_MASK(c); + const int32_t gc_mask = U_GET_GC_MASK(c); // strip trailing space and punctuation if ((gc_mask & (U_GC_ZS_MASK | U_GC_P_MASK)) == 0) { break; From f2fd20ec540cd6db8eb96daa55727e87dec5a47c Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Wed, 15 Mar 2017 16:35:36 -0700 Subject: [PATCH 252/364] Update emoji grapheme breaking rules The rules are updated to the latest UAX #29, with tailorings based on the font in use: we can now use the clustering information calculated by Layout, so we will only disallow a grapheme break if an emoji ligature is actually formed. Test: Unit tests have been updated and pass. Bug: 30917298 Bug: 34211654 Change-Id: Idc0ef9f1f4f45dc45a50ed69e45c43ebfaea0306 --- .../flutter/libs/minikin/GraphemeBreak.cpp | 126 +++++++++++------- .../tests/unittest/GraphemeBreakTests.cpp | 68 ++++++++-- 2 files changed, 139 insertions(+), 55 deletions(-) diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index 56f3a52a5d..b1188e8d88 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -102,70 +102,102 @@ bool GraphemeBreak::isGraphemeBreak(const float* advances, const uint16_t* buf, if ((p1 == U_GCB_LVT || p1 == U_GCB_T) && p2 == U_GCB_T) { return false; } - // Rule GB8a that looks at even-off cases. - // - // sot (RI RI)* RI x RI - // [^RI] (RI RI)* RI x RI - // RI ÷ RI - if (p1 == U_GCB_REGIONAL_INDICATOR && p2 == U_GCB_REGIONAL_INDICATOR) { - // Look at up to 1000 code units. - start = std::max((ssize_t)start, (ssize_t)offset_back - 1000); - while (offset_back > start) { - U16_PREV(buf, start, offset_back, c1); - if (tailoredGraphemeClusterBreak(c1) != U_GCB_REGIONAL_INDICATOR) { - offset_back += U16_LENGTH(c1); - break; - } - } - - // The number 4 comes from the number of code units in a whole flag. - return (offset - offset_back) % 4 == 0; - } // Rule GB9, x (Extend | ZWJ); Rule GB9a, x SpacingMark; Rule GB9b, Prepend x if (p2 == U_GCB_EXTEND || p2 == U_GCB_ZWJ || p2 == U_GCB_SPACING_MARK || p1 == U_GCB_PREPEND) { return false; } - // Cluster Indic syllables together (tailoring of UAX #29). - // Immediately after each virama (that is not just a pure killer) followed by a letter, we - // check to see if the next character has a non-zero width assigned to it in the advances - // array. A zero width means a cluster is formed with the virama (so there is no grapheme - // break), while a non-zero width means a new cluster is started (so there may be a grapheme - // break). - if (u_getIntPropertyValue(c1, UCHAR_CANONICAL_COMBINING_CLASS) == 9 // virama - && !isPureKiller(c1) - && u_getIntPropertyValue(c2, UCHAR_GENERAL_CATEGORY) == U_OTHER_LETTER - && (advances == nullptr || advances[offset - start] == 0)) { - return false; + + // This is used to decide font-dependent grapheme clusters. If we don't have the advance + // information, we become conservative in grapheme breaking and assume that it has no advance. + const bool c2_has_advance = (advances != nullptr && advances[offset - start] != 0.0); + + // All the following rules are font-dependent, in the way that if we know c2 has an advance, + // we definitely know that it cannot form a grapheme with the character(s) before it. So we + // make the decision in favor a grapheme break early. + if (c2_has_advance) { + return true; } - // Tailoring: make emoji sequences with ZWJ a single grapheme cluster + + // Note: For Rule GB10 and GB11 below, we do not use the Unicode line breaking properties for + // determining emoji-ness and carry our own data, because our data could be more fresh than what + // ICU provides. + // + // Tailored version of Rule GB10, (E_Base | EBG) Extend* × E_Modifier. + // The rule itself says do not break between emoji base and emoji modifiers, skipping all Extend + // characters. Variation selectors are considered Extend, so they are handled fine. + // + // We tailor this by requiring that an actual ligature is formed. If the font doesn't form a + // ligature, we allow a break before the modifier. + if (isEmojiModifier(c2)) { + uint32_t c0 = c1; + size_t offset_backback = offset_back; + int32_t p0 = p1; + if (p0 == U_GCB_EXTEND && offset_backback > start) { + // skip over emoji variation selector + U16_PREV(buf, start, offset_backback, c0); + p0 = tailoredGraphemeClusterBreak(c0); + } + if (isEmojiBase(c0)) { + return false; + } + } + // Tailored version of Rule GB11, ZWJ × (Glue_After_Zwj | EBG) + // We try to make emoji sequences with ZWJ a single grapheme cluster, but only if they actually + // merge to one cluster. So we are more relaxed than the UAX #29 rules in accepting any emoji + // character after the ZWJ, but are tighter in that we only treat it as one cluster if a + // ligature is actually formed and we also require the character before the ZWJ to also be an + // emoji. if (p1 == U_GCB_ZWJ && isEmoji(c2) && offset_back > start) { // look at character before ZWJ to see that both can participate in an emoji zwj sequence uint32_t c0 = 0; - U16_PREV(buf, start, offset_back, c0); - if (c0 == 0xFE0F && offset_back > start) { + size_t offset_backback = offset_back; + U16_PREV(buf, start, offset_backback, c0); + if (c0 == 0xFE0F && offset_backback > start) { // skip over emoji variation selector - U16_PREV(buf, start, offset_back, c0); + U16_PREV(buf, start, offset_backback, c0); } if (isEmoji(c0)) { return false; } } - // Proposed Rule GB9c from http://www.unicode.org/L2/L2016/16011r3-break-prop-emoji.pdf - // E_Base x E_Modifier - // TODO: Migrate to Rule GB10 and Rule GB11 with fixing following test cases in - // GraphemeBreak.tailoring and GraphemeBreak.emojiModifiers (Bug: 34211654) - // U+0628 U+200D U+2764 is expected to have grapheme boundary after U+200D. - // U+270C U+FE0E U+1F3FB is expected to have grapheme boundary after U+200D. - if (isEmojiModifier(c2)) { - if (c1 == 0xFE0F && offset_back > start) { - // skip over emoji variation selector - U16_PREV(buf, start, offset_back, c1); - } - if (isEmojiBase(c1)) { + // Tailored version of Rule GB12 and Rule GB13 that look at even-odd cases. + // sot (RI RI)* RI x RI + // [^RI] (RI RI)* RI x RI + // + // If we have font information, we have already broken the cluster if and only if the second + // character had no advance, which means a ligature was formed. If we don't, we look back like + // UAX #29 recommends, but only up to 1000 code units. + if (p1 == U_GCB_REGIONAL_INDICATOR && p2 == U_GCB_REGIONAL_INDICATOR) { + if (advances != nullptr) { + // We have advances information. But if we are here, we already know c2 has no advance. + // So we should definitely disallow a break. return false; + } else { + // Look at up to 1000 code units. + const size_t lookback_barrier = std::max((ssize_t)start, (ssize_t)offset_back - 1000); + size_t offset_backback = offset_back; + while (offset_backback > lookback_barrier) { + uint32_t c0 = 0; + U16_PREV(buf, lookback_barrier, offset_backback, c0); + if (tailoredGraphemeClusterBreak(c0) != U_GCB_REGIONAL_INDICATOR) { + offset_backback += U16_LENGTH(c0); + break; + } + } + // The number 4 comes from the number of code units in a whole flag. + return (offset - offset_backback) % 4 == 0; } } - // Rule GB10, Any ÷ Any + // Cluster Indic syllables together (tailoring of UAX #29). + // Immediately after each virama (that is not just a pure killer) followed by a letter, we + // disallow grapheme breaks (if we are here, we don't know about advances, or we already know + // that c2 has no advance). + if (u_getIntPropertyValue(c1, UCHAR_CANONICAL_COMBINING_CLASS) == 9 // virama + && !isPureKiller(c1) + && u_getIntPropertyValue(c2, UCHAR_GENERAL_CATEGORY) == U_OTHER_LETTER) { + return false; + } + // Rule GB999, Any ÷ Any return true; } diff --git a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp index 96bd8a8e79..6720df6bef 100644 --- a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp @@ -91,7 +91,7 @@ TEST(GraphemeBreak, rules) { EXPECT_TRUE(IsBreak("U+11A8 | U+AC00")); // T x LV EXPECT_TRUE(IsBreak("U+11A8 | U+AC01")); // T x LVT - // Rule GB8a, Regional_Indicator x Regional_Indicator + // Rule GB12 and Rule GB13, Regional_Indicator x Regional_Indicator EXPECT_FALSE(IsBreak("U+1F1FA | U+1F1F8")); EXPECT_TRUE(IsBreak("U+1F1FA U+1F1F8 | U+1F1FA U+1F1F8")); // Regional indicator pair (flag) EXPECT_FALSE(IsBreak("U+1F1FA | U+1F1F8 U+1F1FA U+1F1F8")); // Regional indicator pair (flag) @@ -99,6 +99,17 @@ TEST(GraphemeBreak, rules) { EXPECT_TRUE(IsBreak("U+1F1FA U+1F1F8 | U+1F1FA")); // Regional indicator pair (flag) EXPECT_FALSE(IsBreak("U+1F1FA | U+1F1F8 U+1F1FA")); // Regional indicator pair (flag) + // Same case as the two above, knowing that the first two characters ligate, which is what + // would typically happen. + const float firstPairLigated[] = {1.0, 0.0, 0.0, 0.0, 1.0, 0.0}; // Two entries per codepoint + EXPECT_TRUE(IsBreakWithAdvances(firstPairLigated, "U+1F1FA U+1F1F8 | U+1F1FA")); + EXPECT_FALSE(IsBreakWithAdvances(firstPairLigated, "U+1F1FA | U+1F1F8 U+1F1FA")); + // Repeat the tests, But now the font doesn't have a ligature for the first two characters, + // while it does have a ligature for the last two. This could happen for fonts that do not + // support some (potentially encoded later than they were developed) flags. + const float secondPairLigated[] = {1.0, 0.0, 1.0, 0.0, 0.0, 0.0}; + EXPECT_FALSE(IsBreakWithAdvances(secondPairLigated, "U+1F1FA U+1F1F8 | U+1F1FA")); + EXPECT_TRUE(IsBreakWithAdvances(secondPairLigated, "U+1F1FA | U+1F1F8 U+1F1FA")); EXPECT_TRUE(IsBreak("'a' U+1F1FA U+1F1F8 | U+1F1FA")); // Regional indicator pair (flag) EXPECT_FALSE(IsBreak("'a' U+1F1FA | U+1F1F8 U+1F1FA")); // Regional indicator pair (flag) @@ -110,14 +121,15 @@ TEST(GraphemeBreak, rules) { EXPECT_FALSE( IsBreak("'a' U+1F1FA U+1F1F8 U+1F1FA | U+1F1F8")); // Regional indicator pair (flag) - // Rule GB9, x Extend + // Rule GB9, x (Extend | ZWJ) EXPECT_FALSE(IsBreak("'a' | U+0301")); // combining accent + EXPECT_FALSE(IsBreak("'a' | U+200D")); // ZWJ // Rule GB9a, x SpacingMark EXPECT_FALSE(IsBreak("U+0915 | U+093E")); // KA, AA (spacing mark) // Rule GB9b, Prepend x // see tailoring test for prepend, as current ICU doesn't have any characters in the class - // Rule GB10, Any ÷ Any + // Rule GB999, Any ÷ Any EXPECT_TRUE(IsBreak("'a' | 'b'")); EXPECT_TRUE(IsBreak("'f' | 'i'")); // probable ligature EXPECT_TRUE(IsBreak("U+0644 | U+0627")); // probable ligature, lam + alef @@ -198,8 +210,7 @@ TEST(GraphemeBreak, tailoring) { EXPECT_TRUE(IsBreakWithAdvances(separate, "U+0E01 U+0E3A | U+0E01")); // thai phinthu = pure killer - // suppress grapheme breaks in zwj emoji sequences, see - // http://www.unicode.org/emoji/charts/emoji-zwj-sequences.html + // suppress grapheme breaks in zwj emoji sequences EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+2764 U+FE0F U+200D U+1F48B U+200D U+1F468")); EXPECT_FALSE(IsBreak("U+1F469 U+200D U+2764 U+FE0F U+200D | U+1F48B U+200D U+1F468")); EXPECT_FALSE(IsBreak("U+1F469 U+200D U+2764 U+FE0F U+200D U+1F48B U+200D | U+1F468")); @@ -228,10 +239,42 @@ TEST(GraphemeBreak, emojiModifiers) { EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FF")); // boy + modifier EXPECT_FALSE(IsBreak("U+1F918 | U+1F3FF")); // sign of the horns + modifier EXPECT_FALSE(IsBreak("U+1F933 | U+1F3FF")); // selfie (Unicode 9) + modifier + // Reptition of the tests above, with the knowledge that they are ligated. + const float ligated1_2[] = {1.0, 0.0, 0.0}; + const float ligated2_2[] = {1.0, 0.0, 0.0, 0.0}; + EXPECT_FALSE(IsBreakWithAdvances(ligated1_2, "U+261D | U+1F3FB")); + EXPECT_FALSE(IsBreakWithAdvances(ligated1_2, "U+270C | U+1F3FB")); + EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F466 | U+1F3FB")); + EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F466 | U+1F3FC")); + EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F466 | U+1F3FD")); + EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F466 | U+1F3FE")); + EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F466 | U+1F3FF")); + EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F918 | U+1F3FF")); + EXPECT_FALSE(IsBreakWithAdvances(ligated2_2, "U+1F933 | U+1F3FF")); + // Reptition of the tests above, with the knowledge that they are not ligated. + const float unligated1_2[] = {1.0, 1.0, 0.0}; + const float unligated2_2[] = {1.0, 0.0, 1.0, 0.0}; + EXPECT_TRUE(IsBreakWithAdvances(unligated1_2, "U+261D | U+1F3FB")); + EXPECT_TRUE(IsBreakWithAdvances(unligated1_2, "U+270C | U+1F3FB")); + EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F466 | U+1F3FB")); + EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F466 | U+1F3FC")); + EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F466 | U+1F3FD")); + EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F466 | U+1F3FE")); + EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F466 | U+1F3FF")); + EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F918 | U+1F3FF")); + EXPECT_TRUE(IsBreakWithAdvances(unligated2_2, "U+1F933 | U+1F3FF")); - // adding emoji style variation selector doesn't affect grapheme cluster - EXPECT_TRUE(IsBreak("U+270C U+FE0E | U+1F3FB")); // victory hand + text style + modifier + // adding extend characters between emoji base and modifier doesn't affect grapheme cluster + EXPECT_FALSE(IsBreak("U+270C U+FE0E | U+1F3FB")); // victory hand + text style + modifier EXPECT_FALSE(IsBreak("U+270C U+FE0F | U+1F3FB")); // heart + emoji style + modifier + // Reptition of the two tests above, with the knowledge that they are ligated. + const float ligated1_1_2[] = {1.0, 0.0, 0.0, 0.0}; + EXPECT_FALSE(IsBreakWithAdvances(ligated1_1_2, "U+270C U+FE0E | U+1F3FB")); + EXPECT_FALSE(IsBreakWithAdvances(ligated1_1_2, "U+270C U+FE0F | U+1F3FB")); + // Reptition of the first two tests, with the knowledge that they are not ligated. + const float unligated1_1_2[] = {1.0, 0.0, 1.0, 0.0}; + EXPECT_TRUE(IsBreakWithAdvances(unligated1_1_2, "U+270C U+FE0E | U+1F3FB")); + EXPECT_TRUE(IsBreakWithAdvances(unligated1_1_2, "U+270C U+FE0F | U+1F3FB")); // heart is not an emoji base EXPECT_TRUE(IsBreak("U+2764 | U+1F3FB")); // heart + modifier @@ -241,17 +284,26 @@ TEST(GraphemeBreak, emojiModifiers) { // rat is not an emoji modifer EXPECT_TRUE(IsBreak("U+1F466 | U+1F400")); // boy + rat - } TEST(GraphemeBreak, genderBalancedEmoji) { // U+1F469 is WOMAN, U+200D is ZWJ, U+1F4BC is BRIEFCASE. EXPECT_FALSE(IsBreak("U+1F469 | U+200D U+1F4BC")); EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+1F4BC")); + // The above two cases, when the ligature is not supported in the font. We now expect a break + // between them. + const float unligated2_1_2[] = {1.0, 0.0, 0.0, 1.0, 0.0}; + EXPECT_FALSE(IsBreakWithAdvances(unligated2_1_2, "U+1F469 | U+200D U+1F4BC")); + EXPECT_TRUE(IsBreakWithAdvances(unligated2_1_2, "U+1F469 U+200D | U+1F4BC")); // U+2695 has now emoji property, so should be part of ZWJ sequence. EXPECT_FALSE(IsBreak("U+1F469 | U+200D U+2695")); EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+2695")); + // The above two cases, when the ligature is not supported in the font. We now expect a break + // between them. + const float unligated2_1_1[] = {1.0, 0.0, 0.0, 1.0}; + EXPECT_FALSE(IsBreakWithAdvances(unligated2_1_1, "U+1F469 | U+200D U+2695")); + EXPECT_TRUE(IsBreakWithAdvances(unligated2_1_1, "U+1F469 U+200D | U+2695")); } TEST(GraphemeBreak, offsets) { From 3d10a1ed4f69df9dbadefa0d28a2de6f99eb0e1c Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Thu, 16 Mar 2017 14:18:59 -0700 Subject: [PATCH 253/364] Update emoji character data in Minikin Update emoji character data to Unicode 10.0 / Emoji 5.0 (which also removes U+1F93B MODERN PENATHLON from the emoji base letters). Also add unit tests for line breaking for new characters (based on earlier work by Seigo Nonaka). Test: All new and existing unit tests pass; Test: Manually tested line breaking of new emojis in TextView. Bug: 28364892 Bug: 28678294 Bug: 30874706 Change-Id: I367cdab09187dc08a66a3112a5181a2b7fb338a5 --- .../flutter/libs/minikin/MinikinInternal.cpp | 36 ++++++++----- .../tests/unittest/WordBreakerTests.cpp | 51 ++++++++++++++++++- 2 files changed, 74 insertions(+), 13 deletions(-) diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index e766dce992..60fa9636f8 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -34,29 +34,39 @@ void assertMinikinLocked() { } bool isEmoji(uint32_t c) { - // U+2695 U+2640 U+2642 are not in emoji category in Unicode 9 but they are now emoji category. - // TODO: remove once emoji database is updated. - if (c == 0x2695 || c == 0x2640 || c == 0x2642) { + // Emoji characters new in Unicode emoji 5.0. + // From http://www.unicode.org/Public/emoji/5.0/emoji-data.txt + // TODO: Remove once emoji-data.text 5.0 is in the tree. + if ((0x1F6F7 <= c && c <= 0x1F6F8) + || c == 0x1F91F + || (0x1F928 <= c && c <= 0x1F92F) + || (0x1F931 <= c && c <= 0x1F932) + || c == 0x1F94C + || (0x1F95F <= c && c <= 0x1F96B) + || (0x1F992 <= c && c <= 0x1F997) + || (0x1F9D0 <= c && c <= 0x1F9E6)) { return true; } + const size_t length = sizeof(generated::EMOJI_LIST) / sizeof(generated::EMOJI_LIST[0]); return std::binary_search(generated::EMOJI_LIST, generated::EMOJI_LIST + length, c); } -// Based on Modifiers from http://www.unicode.org/L2/L2016/16011-data-file.txt +// Based on Emoji_Modifier from http://www.unicode.org/Public/emoji/5.0/emoji-data.txt bool isEmojiModifier(uint32_t c) { return (0x1F3FB <= c && c <= 0x1F3FF); } // Based on Emoji_Modifier_Base from -// http://www.unicode.org/Public/emoji/3.0/emoji-data.txt +// http://www.unicode.org/Public/emoji/5.0/emoji-data.txt bool isEmojiBase(uint32_t c) { if (0x261D <= c && c <= 0x270D) { return (c == 0x261D || c == 0x26F9 || (0x270A <= c && c <= 0x270D)); } else if (0x1F385 <= c && c <= 0x1F93E) { return (c == 0x1F385 - || (0x1F3C3 <= c && c <= 0x1F3C4) - || (0x1F3CA <= c && c <= 0x1F3CB) + || (0x1F3C2 <= c && c <= 0x1F3C4) + || c == 0x1F3C7 + || (0x1F3CA <= c && c <= 0x1F3CC) || (0x1F442 <= c && c <= 0x1F443) || (0x1F446 <= c && c <= 0x1F450) || (0x1F466 <= c && c <= 0x1F469) @@ -66,7 +76,7 @@ bool isEmojiBase(uint32_t c) { || (0x1F481 <= c && c <= 0x1F483) || (0x1F485 <= c && c <= 0x1F487) || c == 0x1F4AA - || c == 0x1F575 + || (0x1F574 <= c && c <= 0x1F575) || c == 0x1F57A || c == 0x1F590 || (0x1F595 <= c && c <= 0x1F596) @@ -75,11 +85,13 @@ bool isEmojiBase(uint32_t c) { || c == 0x1F6A3 || (0x1F6B4 <= c && c <= 0x1F6B6) || c == 0x1F6C0 - || (0x1F918 <= c && c <= 0x1F91E) + || c == 0x1F6CC + || (0x1F918 <= c && c <= 0x1F91C) + || (0x1F91E <= c && c <= 0x1F91F) || c == 0x1F926 - || c == 0x1F930 - || (0x1F933 <= c && c <= 0x1F939) - || (0x1F93B <= c && c <= 0x1F93E)); + || (0x1F930 <= c && c <= 0x1F939) + || (0x1F93D <= c && c <= 0x1F93E) + || (0x1F9D1 <= c && c <= 0x1F9DD)); } else { return false; } diff --git a/engine/src/flutter/tests/unittest/WordBreakerTests.cpp b/engine/src/flutter/tests/unittest/WordBreakerTests.cpp index 7971b49070..13e0420c8a 100644 --- a/engine/src/flutter/tests/unittest/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/unittest/WordBreakerTests.cpp @@ -99,7 +99,7 @@ TEST_F(WordBreakerTest, postfixAndPrefix) { EXPECT_EQ((ssize_t)NELEM(buf), breaker.wordEnd()); } -TEST_F(WordBreakerTest, MyanmarKinzi) { +TEST_F(WordBreakerTest, myanmarKinzi) { uint16_t buf[] = {0x1004, 0x103A, 0x1039, 0x1000, 0x102C}; // NGA, ASAT, VIRAMA, KA, UU WordBreaker breaker; icu::Locale burmese("my"); @@ -158,6 +158,55 @@ TEST_F(WordBreakerTest, emojiWithModifier) { EXPECT_EQ(8, breaker.wordEnd()); } +TEST_F(WordBreakerTest, unicode10Emoji) { + // Should break between emojis. + uint16_t buf[] = { + // SLED + SLED + UTF16(0x1F6F7), UTF16(0x1F6F7), + // SLED + VS15 + SLED + UTF16(0x1F6F7), 0xFE0E, UTF16(0x1F6F7), + // WHITE SMILING FACE + SLED + 0x263A, UTF16(0x1F6F7), + // WHITE SMILING FACE + VS16 + SLED + 0x263A, 0xFE0F, UTF16(0x1F6F7), + }; + WordBreaker breaker; + breaker.setLocale(icu::Locale::getEnglish()); + breaker.setText(buf, NELEM(buf)); + EXPECT_EQ(0, breaker.current()); + EXPECT_EQ(2, breaker.next()); + EXPECT_EQ(0, breaker.wordStart()); + EXPECT_EQ(2, breaker.wordEnd()); + + EXPECT_EQ(4, breaker.next()); + EXPECT_EQ(2, breaker.wordStart()); + EXPECT_EQ(4, breaker.wordEnd()); + + EXPECT_EQ(7, breaker.next()); + EXPECT_EQ(4, breaker.wordStart()); + EXPECT_EQ(7, breaker.wordEnd()); + + EXPECT_EQ(9, breaker.next()); + EXPECT_EQ(7, breaker.wordStart()); + EXPECT_EQ(9, breaker.wordEnd()); + + EXPECT_EQ(10, breaker.next()); + EXPECT_EQ(9, breaker.wordStart()); + EXPECT_EQ(10, breaker.wordEnd()); + + EXPECT_EQ(12, breaker.next()); + EXPECT_EQ(10, breaker.wordStart()); + EXPECT_EQ(12, breaker.wordEnd()); + + EXPECT_EQ(14, breaker.next()); + EXPECT_EQ(12, breaker.wordStart()); + EXPECT_EQ(14, breaker.wordEnd()); + + EXPECT_EQ(16, breaker.next()); + EXPECT_EQ(14, breaker.wordStart()); + EXPECT_EQ(16, breaker.wordEnd()); +} + TEST_F(WordBreakerTest, flagsSequenceSingleFlag) { const std::string kFlag = "U+1F3F4"; const std::string flags = kFlag + " " + kFlag; From 2d0bfff20317fcd083de6b3c1c9a2dbfcd317499 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Thu, 16 Mar 2017 15:55:25 -0700 Subject: [PATCH 254/364] Introduce FontCollection construct perf test Test: ran minikin_perftest Bug: 36232655 Change-Id: Ic4d88663d522be17540e2ac17c9b7ae64210275f --- .../tests/perftests/FontCollection.cpp | 10 ++++++++++ .../src/flutter/tests/util/FontTestUtils.cpp | 19 +++++++++++-------- engine/src/flutter/tests/util/FontTestUtils.h | 17 ++++++++++++++--- 3 files changed, 35 insertions(+), 11 deletions(-) diff --git a/engine/src/flutter/tests/perftests/FontCollection.cpp b/engine/src/flutter/tests/perftests/FontCollection.cpp index 6f9d636ca3..fd95cf1a60 100644 --- a/engine/src/flutter/tests/perftests/FontCollection.cpp +++ b/engine/src/flutter/tests/perftests/FontCollection.cpp @@ -27,6 +27,16 @@ namespace minikin { const char* SYSTEM_FONT_PATH = "/system/fonts/"; const char* SYSTEM_FONT_XML = "/system/etc/fonts.xml"; +static void BM_FontCollection_construct(benchmark::State& state) { + std::vector> families = + getFontFamilies(SYSTEM_FONT_PATH, SYSTEM_FONT_XML); + while (state.KeepRunning()) { + std::make_shared(families); + } +} + +BENCHMARK(BM_FontCollection_construct); + static void BM_FontCollection_hasVariationSelector(benchmark::State& state) { std::shared_ptr collection( getFontCollection(SYSTEM_FONT_PATH, SYSTEM_FONT_XML)); diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index 27a693e16d..13360d4aa2 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -28,7 +28,7 @@ namespace minikin { -FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { +std::vector> getFontFamilies(const char* fontDir, const char* fontXml) { xmlDoc* doc = xmlReadFile(fontXml, NULL, 0); xmlNode* familySet = xmlDocGetRootElement(doc); @@ -69,11 +69,12 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { } if (index == nullptr) { - std::shared_ptr minikinFont(new MinikinFontForTest(fontPath)); + std::shared_ptr minikinFont = + std::make_shared(fontPath); fonts.push_back(Font(minikinFont, FontStyle(weight, italic))); } else { - std::shared_ptr minikinFont( - new MinikinFontForTest(fontPath, atoi((const char*)index))); + std::shared_ptr minikinFont = + std::make_shared(fontPath, atoi((const char*)index)); fonts.push_back(Font(minikinFont, FontStyle(weight, italic))); } } @@ -81,17 +82,19 @@ FontCollection* getFontCollection(const char* fontDir, const char* fontXml) { xmlChar* lang = xmlGetProp(familyNode, (const xmlChar*)"lang"); std::shared_ptr family; if (lang == nullptr) { - family.reset(new FontFamily(variant, std::move(fonts))); + family = std::make_shared(variant, std::move(fonts)); } else { uint32_t langId = FontStyle::registerLanguageList( std::string((const char*)lang, xmlStrlen(lang))); - family.reset(new FontFamily(langId, variant, std::move(fonts))); + family = std::make_shared(langId, variant, std::move(fonts)); } families.push_back(family); } xmlFreeDoc(doc); - - return new FontCollection(families); + return families; +} +std::shared_ptr getFontCollection(const char* fontDir, const char* fontXml) { + return std::make_shared(getFontFamilies(fontDir, fontXml)); } } // namespace minikin diff --git a/engine/src/flutter/tests/util/FontTestUtils.h b/engine/src/flutter/tests/util/FontTestUtils.h index 69ba841b43..dd5e5860e4 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.h +++ b/engine/src/flutter/tests/util/FontTestUtils.h @@ -19,17 +19,28 @@ #include +#include + namespace minikin { +/** + * Returns list of FontFamily from installed fonts. + * + * This function reads an XML file and makes font families. + * + * Caller must unref the returned pointer. + */ +std::vector> getFontFamilies(const char* fontDir, const char* fontXml); + /** * Returns FontCollection from installed fonts. * - * This function reads /system/etc/fonts.xml and make font families and - * collections of them. MinikinFontForTest is used for FontFamily creation. + * This function reads an XML file and makes font families and collections of them. + * MinikinFontForTest is used for FontFamily creation. * * Caller must unref the returned pointer. */ -FontCollection* getFontCollection(const char* fontDir, const char* fontXml); +std::shared_ptr getFontCollection(const char* fontDir, const char* fontXml); } // namespace minikin #endif // MINIKIN_FONT_TEST_UTILS_H From 215f7ff8d061952135689e8fdaed31d2dd904dff Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Fri, 17 Mar 2017 14:29:09 -0700 Subject: [PATCH 255/364] Update Minikin to use ICU's emoji data Certain differences are still needed, since ICU appears to support Emoji 4.0 only, while we need Emoji 5.0. But the bulk of the data is now carried by ICU. We no longer need the script that generates the tables, so that's also removed. Test: Comprehensive unit tests added. Bug: 27365282 Bug: 30874706 Change-Id: I011443fbca9bb202deff7fffb40043f89e1f1fb1 --- engine/src/flutter/libs/minikin/Android.mk | 12 -- .../flutter/libs/minikin/MinikinInternal.cpp | 63 ++++------- .../libs/minikin/unicode_emoji_h_gen.py | 105 ------------------ .../tests/unittest/MinikinInternalTest.cpp | 46 ++++++++ 4 files changed, 66 insertions(+), 160 deletions(-) delete mode 100644 engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 603638e754..be5301218a 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -15,18 +15,6 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) -# Generate unicode emoji data from UCD. -UNICODE_EMOJI_H_GEN_PY := $(LOCAL_PATH)/unicode_emoji_h_gen.py -UNICODE_EMOJI_DATA := $(TOP)/external/unicode/emoji-data.txt - -UNICODE_EMOJI_H := $(intermediates)/generated/UnicodeData.h -$(UNICODE_EMOJI_H): $(UNICODE_EMOJI_H_GEN_PY) $(UNICODE_EMOJI_DATA) -$(LOCAL_PATH)/MinikinInternal.cpp: $(UNICODE_EMOJI_H) -$(UNICODE_EMOJI_H): PRIVATE_CUSTOM_TOOL := python $(UNICODE_EMOJI_H_GEN_PY) \ - -i $(UNICODE_EMOJI_DATA) \ - -o $(UNICODE_EMOJI_H) -$(UNICODE_EMOJI_H): - $(transform-generated-source) include $(CLEAR_VARS) minikin_src_files := \ diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 60fa9636f8..212ee26c0f 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -19,8 +19,8 @@ #include "MinikinInternal.h" #include "HbFontCache.h" -#include "generated/UnicodeData.h" +#include #include namespace minikin { @@ -36,7 +36,7 @@ void assertMinikinLocked() { bool isEmoji(uint32_t c) { // Emoji characters new in Unicode emoji 5.0. // From http://www.unicode.org/Public/emoji/5.0/emoji-data.txt - // TODO: Remove once emoji-data.text 5.0 is in the tree. + // TODO: Remove once emoji-data.text 5.0 is in ICU or update to 6.0. if ((0x1F6F7 <= c && c <= 0x1F6F8) || c == 0x1F91F || (0x1F928 <= c && c <= 0x1F92F) @@ -47,54 +47,31 @@ bool isEmoji(uint32_t c) { || (0x1F9D0 <= c && c <= 0x1F9E6)) { return true; } - - const size_t length = sizeof(generated::EMOJI_LIST) / sizeof(generated::EMOJI_LIST[0]); - return std::binary_search(generated::EMOJI_LIST, generated::EMOJI_LIST + length, c); + return u_hasBinaryProperty(c, UCHAR_EMOJI); } -// Based on Emoji_Modifier from http://www.unicode.org/Public/emoji/5.0/emoji-data.txt bool isEmojiModifier(uint32_t c) { - return (0x1F3FB <= c && c <= 0x1F3FF); + // Emoji modifier are not expected to change, so there's a small change we need to customize + // this. + return u_hasBinaryProperty(c, UCHAR_EMOJI_MODIFIER); } -// Based on Emoji_Modifier_Base from -// http://www.unicode.org/Public/emoji/5.0/emoji-data.txt bool isEmojiBase(uint32_t c) { - if (0x261D <= c && c <= 0x270D) { - return (c == 0x261D || c == 0x26F9 || (0x270A <= c && c <= 0x270D)); - } else if (0x1F385 <= c && c <= 0x1F93E) { - return (c == 0x1F385 - || (0x1F3C2 <= c && c <= 0x1F3C4) - || c == 0x1F3C7 - || (0x1F3CA <= c && c <= 0x1F3CC) - || (0x1F442 <= c && c <= 0x1F443) - || (0x1F446 <= c && c <= 0x1F450) - || (0x1F466 <= c && c <= 0x1F469) - || c == 0x1F46E - || (0x1F470 <= c && c <= 0x1F478) - || c == 0x1F47C - || (0x1F481 <= c && c <= 0x1F483) - || (0x1F485 <= c && c <= 0x1F487) - || c == 0x1F4AA - || (0x1F574 <= c && c <= 0x1F575) - || c == 0x1F57A - || c == 0x1F590 - || (0x1F595 <= c && c <= 0x1F596) - || (0x1F645 <= c && c <= 0x1F647) - || (0x1F64B <= c && c <= 0x1F64F) - || c == 0x1F6A3 - || (0x1F6B4 <= c && c <= 0x1F6B6) - || c == 0x1F6C0 - || c == 0x1F6CC - || (0x1F918 <= c && c <= 0x1F91C) - || (0x1F91E <= c && c <= 0x1F91F) - || c == 0x1F926 - || (0x1F930 <= c && c <= 0x1F939) - || (0x1F93D <= c && c <= 0x1F93E) - || (0x1F9D1 <= c && c <= 0x1F9DD)); - } else { - return false; + // These two characters were removed from Emoji_Modifier_Base in Emoji 4.0, but we need to keep + // them as emoji modifier bases since there are fonts and user-generated text out there that + // treats these as potential emoji bases. + if (c == 0x1F91D || c == 0x1F93C) { + return true; } + // Emoji Modifier Base characters new in Unicode emoji 5.0. + // From http://www.unicode.org/Public/emoji/5.0/emoji-data.txt + // TODO: Remove once emoji-data.text 5.0 is in ICU or update to 6.0. + if (c == 0x1F91F + || (0x1F931 <= c && c <= 0x1F932) + || (0x1F9D1 <= c && c <= 0x1F9DD)) { + return true; + } + return u_hasBinaryProperty(c, UCHAR_EMOJI_MODIFIER_BASE); } hb_blob_t* getFontTable(const MinikinFont* minikinFont, uint32_t tag) { diff --git a/engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py b/engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py deleted file mode 100644 index 5186455188..0000000000 --- a/engine/src/flutter/libs/minikin/unicode_emoji_h_gen.py +++ /dev/null @@ -1,105 +0,0 @@ -#!/usr/bin/env python -# -# Copyright (C) 2016 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. -# -"""Generate header file for unicode data.""" - -import optparse -import sys - - -UNICODE_EMOJI_TEMPLATE=""" -/* file generated by frameworks/minikin/lib/minikin/Android.mk */ -#ifndef MINIKIN_UNICODE_EMOJI_H -#define MINIKIN_UNICODE_EMOJI_H - -#include - -namespace minikin { -namespace generated { - -int32_t EMOJI_LIST[] = { -@@@EMOJI_DATA@@@ -}; - -} // namespace generated -} // namespace minikin - -#endif // MINIKIN_UNICODE_EMOJI_H -""" - - -def _create_opt_parser(): - parser = optparse.OptionParser() - parser.add_option('-i', '--input', type='str', action='store', - help='path to input emoji-data.txt') - parser.add_option('-o', '--output', type='str', action='store', - help='path to output UnicodeEmoji.h') - return parser - - -def _read_emoji_data(emoji_data_file_path): - result = [] - with open(emoji_data_file_path) as emoji_data_file: - for line in emoji_data_file: - if '#' in line: - line = line[:line.index('#')] # Drop comments. - if not line.strip(): - continue # Skip empty line. - - code_points, prop = line.split(';') - code_points = code_points.strip() - prop = prop.strip() - if prop != 'Emoji': - break # Only collect Emoji property code points - - if '..' in code_points: # code point range - cp_start, cp_end = code_points.split('..') - result.extend(xrange(int(cp_start, 16), int(cp_end, 16) + 1)) - else: - code_point = int(code_points, 16) - result.append(code_point) - return result - - -def _generate_header_contents(emoji_list): - INDENT = ' ' * 4 - JOINER = ', ' - - hex_list = ['0x%04X' % x for x in emoji_list] - lines = [] - tmp_line = '%s%s' % (INDENT, hex_list[0]) - for hex_str in hex_list[1:]: - if len(tmp_line) + len(JOINER) + len(hex_str) >= 100: - lines.append(tmp_line + ',') - tmp_line = '%s%s' % (INDENT, hex_str) - else: - tmp_line = '%s%s%s' % (tmp_line, JOINER, hex_str) - lines.append(tmp_line) - - template = UNICODE_EMOJI_TEMPLATE - template = template.replace('@@@EMOJI_DATA@@@', '\n'.join(lines)) - return template - - -if __name__ == '__main__': - opt_parser = _create_opt_parser() - opts, _ = opt_parser.parse_args() - - emoji_list = _read_emoji_data(opts.input) - header = _generate_header_contents(emoji_list) - with open(opts.output, 'w') as header_file: - header_file.write(header) - diff --git a/engine/src/flutter/tests/unittest/MinikinInternalTest.cpp b/engine/src/flutter/tests/unittest/MinikinInternalTest.cpp index e314dd1be5..1d3ecd76b8 100644 --- a/engine/src/flutter/tests/unittest/MinikinInternalTest.cpp +++ b/engine/src/flutter/tests/unittest/MinikinInternalTest.cpp @@ -16,6 +16,8 @@ #include +#include + #include "MinikinInternal.h" namespace minikin { @@ -23,12 +25,56 @@ namespace minikin { TEST(MinikinInternalTest, isEmojiTest) { EXPECT_TRUE(isEmoji(0x0023)); // NUMBER SIGN EXPECT_TRUE(isEmoji(0x0035)); // DIGIT FIVE + EXPECT_TRUE(isEmoji(0x2640)); // FEMALE SIGN + EXPECT_TRUE(isEmoji(0x2642)); // MALE SIGN + EXPECT_TRUE(isEmoji(0x2695)); // STAFF OF AESCULAPIUS EXPECT_TRUE(isEmoji(0x1F0CF)); // PLAYING CARD BLACK JOKER EXPECT_TRUE(isEmoji(0x1F1E9)); // REGIONAL INDICATOR SYMBOL LETTER D + EXPECT_TRUE(isEmoji(0x1F6F7)); // SLED + EXPECT_TRUE(isEmoji(0x1F9E6)); // SOCKS EXPECT_FALSE(isEmoji(0x0000)); // EXPECT_FALSE(isEmoji(0x0061)); // LATIN SMALL LETTER A + EXPECT_FALSE(isEmoji(0x1F93B)); // MODERN PENTATHLON + EXPECT_FALSE(isEmoji(0x1F946)); // RIFLE EXPECT_FALSE(isEmoji(0x29E3D)); // A han character. } +TEST(MinikinInternalTest, isEmojiModifierTest) { + EXPECT_TRUE(isEmojiModifier(0x1F3FB)); // EMOJI MODIFIER FITZPATRICK TYPE-1-2 + EXPECT_TRUE(isEmojiModifier(0x1F3FC)); // EMOJI MODIFIER FITZPATRICK TYPE-3 + EXPECT_TRUE(isEmojiModifier(0x1F3FD)); // EMOJI MODIFIER FITZPATRICK TYPE-4 + EXPECT_TRUE(isEmojiModifier(0x1F3FE)); // EMOJI MODIFIER FITZPATRICK TYPE-5 + EXPECT_TRUE(isEmojiModifier(0x1F3FF)); // EMOJI MODIFIER FITZPATRICK TYPE-6 + + EXPECT_FALSE(isEmojiModifier(0x0000)); // + EXPECT_FALSE(isEmojiModifier(0x1F3FA)); // AMPHORA + EXPECT_FALSE(isEmojiModifier(0x1F400)); // RAT + EXPECT_FALSE(isEmojiModifier(0x29E3D)); // A han character. +} + +TEST(MinikinInternalTest, isEmojiBaseTest) { + EXPECT_TRUE(isEmojiBase(0x261D)); // WHITE UP POINTING INDEX + EXPECT_TRUE(isEmojiBase(0x270D)); // WRITING HAND + EXPECT_TRUE(isEmojiBase(0x1F385)); // FATHER CHRISTMAS + EXPECT_TRUE(isEmojiBase(0x1F3C2)); // SNOWBOARDER + EXPECT_TRUE(isEmojiBase(0x1F3C7)); // HORSE RACING + EXPECT_TRUE(isEmojiBase(0x1F3CC)); // GOLFER + EXPECT_TRUE(isEmojiBase(0x1F574)); // MAN IN BUSINESS SUIT LEVITATING + EXPECT_TRUE(isEmojiBase(0x1F6CC)); // SLEEPING ACCOMMODATION + EXPECT_TRUE(isEmojiBase(0x1F91D)); // HANDSHAKE (removed from Emoji 4.0, but we need it) + EXPECT_TRUE(isEmojiBase(0x1F91F)); // I LOVE YOU HAND SIGN + EXPECT_TRUE(isEmojiBase(0x1F931)); // BREAST-FEEDING + EXPECT_TRUE(isEmojiBase(0x1F932)); // PALMS UP TOGETHER + EXPECT_TRUE(isEmojiBase(0x1F93C)); // WRESTLERS (removed from Emoji 4.0, but we need it) + EXPECT_TRUE(isEmojiBase(0x1F9D1)); // ADULT + EXPECT_TRUE(isEmojiBase(0x1F9DD)); // ELF + + EXPECT_FALSE(isEmojiBase(0x0000)); // + EXPECT_FALSE(isEmojiBase(0x261C)); // WHITE LEFT POINTING INDEX + EXPECT_FALSE(isEmojiBase(0x1F384)); // CHRISTMAS TREE + EXPECT_FALSE(isEmojiBase(0x1F9DE)); // GENIE + EXPECT_FALSE(isEmojiBase(0x29E3D)); // A han character. +} + } // namespace minikin From 8eb2df1a8e9d59b6914eca9691f1bab8f4efadce Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Fri, 17 Mar 2017 15:42:49 -0700 Subject: [PATCH 256/364] Remove workaround for line breaks around currency symbols This is now done properly in ICU so we no longer need to do it ourselves. Also updated some comments about emoji line-breaking. Test: Existings tests for this in Minikin continue to pass. Bug: 24959657 Bug: 27365282 Change-Id: I865ea9ba1e79a64409d84d2d30c121f740e35ad6 --- engine/src/flutter/libs/minikin/WordBreaker.cpp | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index 36a3e88b23..3b9e956fe1 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -83,23 +83,13 @@ static bool isBreakValid(const uint16_t* buf, size_t bufEnd, size_t i) { size_t next_offset = i; U16_NEXT(buf, next_offset, bufEnd, next_codepoint); - // Proposed change to LB24 from http://www.unicode.org/L2/L2016/16043r-line-break-pr-po.txt - // (AL | HL) × (PR | PO) - int32_t lineBreak = u_getIntPropertyValue(codePoint, UCHAR_LINE_BREAK); - if (lineBreak == U_LB_ALPHABETIC || lineBreak == U_LB_HEBREW_LETTER) { - lineBreak = u_getIntPropertyValue(next_codepoint, UCHAR_LINE_BREAK); - if (lineBreak == U_LB_PREFIX_NUMERIC || lineBreak == U_LB_POSTFIX_NUMERIC) { - return false; - } - } - - // Emoji ZWJ sequences. + // Rule LB8 for Emoji ZWJ sequences. We need to do this ourselves since we may have fresher + // emoji data than ICU does. if (codePoint == CHAR_ZWJ && isEmoji(next_codepoint)) { return false; } - // Proposed Rule LB30b from http://www.unicode.org/L2/L2016/16011r3-break-prop-emoji.pdf - // EB x EM + // Rule LB30b. We need to this ourselves since we may have fresher emoji data than ICU does. if (isEmojiModifier(next_codepoint)) { if (codePoint == 0xFE0F && prev_offset > 0) { // skip over emoji variation selector From aa928e61b75b0017f260f4a2994f6132318fd35e Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Fri, 17 Mar 2017 16:54:42 -0700 Subject: [PATCH 257/364] Relax requirement for text variation sequences Previously, we insisted that in order for us to claim that a text variation sequence is supported or to display it, it needs to be standardized already. Now we accept any character as the base of a text variation sequence and support it as far the font used to display it is not an emoji font. Also fix a typo in a font name. Test: Unit tests are updated and pass. Bug: 30874706 Change-Id: I9660ec43aeee84303cfb825352a7f5029d036dd6 --- .../flutter/libs/minikin/FontCollection.cpp | 46 +++---------------- engine/src/flutter/tests/unittest/Android.mk | 2 +- .../unittest/FontCollectionItemizeTest.cpp | 4 +- .../tests/unittest/FontCollectionTest.cpp | 13 ++++-- .../flutter/tests/unittest/FontFamilyTest.cpp | 2 +- 5 files changed, 18 insertions(+), 49 deletions(-) diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index a3d2d974e0..962b95b4af 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -41,42 +41,6 @@ static inline T max(T a, T b) { const uint32_t EMOJI_STYLE_VS = 0xFE0F; const uint32_t TEXT_STYLE_VS = 0xFE0E; -// See http://www.unicode.org/Public/9.0.0/ucd/StandardizedVariants.txt -// U+2640, U+2642, U+2695 are now in emoji category but not listed in above file, so added them by -// manual. -// Must be sorted. -const uint32_t EMOJI_STYLE_VS_BASES[] = { - 0x0023, 0x002A, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, - 0x00A9, 0x00AE, 0x203C, 0x2049, 0x2122, 0x2139, 0x2194, 0x2195, 0x2196, 0x2197, 0x2198, 0x2199, - 0x21A9, 0x21AA, 0x231A, 0x231B, 0x2328, 0x23CF, 0x23ED, 0x23EE, 0x23EF, 0x23F1, 0x23F2, 0x23F8, - 0x23F9, 0x23FA, 0x24C2, 0x25AA, 0x25AB, 0x25B6, 0x25C0, 0x25FB, 0x25FC, 0x25FD, 0x25FE, 0x2600, - 0x2601, 0x2602, 0x2603, 0x2604, 0x260E, 0x2611, 0x2614, 0x2615, 0x2618, 0x261D, 0x2620, 0x2622, - 0x2623, 0x2626, 0x262A, 0x262E, 0x262F, 0x2638, 0x2639, 0x263A, 0x2640, 0x2642, 0x2648, 0x2649, - 0x264A, 0x264B, 0x264C, 0x264D, 0x264E, 0x264F, 0x2650, 0x2651, 0x2652, 0x2653, 0x2660, 0x2663, - 0x2665, 0x2666, 0x2668, 0x267B, 0x267F, 0x2692, 0x2693, 0x2694, 0x2695, 0x2696, 0x2697, 0x2699, - 0x269B, 0x269C, 0x26A0, 0x26A1, 0x26AA, 0x26AB, 0x26B0, 0x26B1, 0x26BD, 0x26BE, 0x26C4, 0x26C5, - 0x26C8, 0x26CF, 0x26D1, 0x26D3, 0x26D4, 0x26E9, 0x26EA, 0x26F0, 0x26F1, 0x26F2, 0x26F3, 0x26F4, - 0x26F5, 0x26F7, 0x26F8, 0x26F9, 0x26FA, 0x26FD, 0x2702, 0x2708, 0x2709, 0x270C, 0x270D, 0x270F, - 0x2712, 0x2714, 0x2716, 0x271D, 0x2721, 0x2733, 0x2734, 0x2744, 0x2747, 0x2757, 0x2763, 0x2764, - 0x27A1, 0x2934, 0x2935, 0x2B05, 0x2B06, 0x2B07, 0x2B1B, 0x2B1C, 0x2B50, 0x2B55, 0x3030, 0x303D, - 0x3297, 0x3299, 0x1F004, 0x1F170, 0x1F171, 0x1F17E, 0x1F17F, 0x1F202, 0x1F21A, 0x1F22F, 0x1F237, - 0x1F321, 0x1F324, 0x1F325, 0x1F326, 0x1F327, 0x1F328, 0x1F329, 0x1F32A, 0x1F32B, 0x1F32C, - 0x1F336, 0x1F37D, 0x1F396, 0x1F397, 0x1F399, 0x1F39A, 0x1F39B, 0x1F39E, 0x1F39F, 0x1F3CB, - 0x1F3CC, 0x1F3CD, 0x1F3CE, 0x1F3D4, 0x1F3D5, 0x1F3D6, 0x1F3D7, 0x1F3D8, 0x1F3D9, 0x1F3DA, - 0x1F3DB, 0x1F3DC, 0x1F3DD, 0x1F3DE, 0x1F3DF, 0x1F3F3, 0x1F3F5, 0x1F3F7, 0x1F43F, 0x1F441, - 0x1F4FD, 0x1F549, 0x1F54A, 0x1F56F, 0x1F570, 0x1F573, 0x1F574, 0x1F575, 0x1F576, 0x1F577, - 0x1F578, 0x1F579, 0x1F587, 0x1F58A, 0x1F58B, 0x1F58C, 0x1F58D, 0x1F590, 0x1F5A5, 0x1F5A8, - 0x1F5B1, 0x1F5B2, 0x1F5BC, 0x1F5C2, 0x1F5C3, 0x1F5C4, 0x1F5D1, 0x1F5D2, 0x1F5D3, 0x1F5DC, - 0x1F5DD, 0x1F5DE, 0x1F5E1, 0x1F5E3, 0x1F5E8, 0x1F5EF, 0x1F5F3, 0x1F5FA, 0x1F6CB, 0x1F6CD, - 0x1F6CE, 0x1F6CF, 0x1F6E0, 0x1F6E1, 0x1F6E2, 0x1F6E3, 0x1F6E4, 0x1F6E5, 0x1F6E9, 0x1F6F0, - 0x1F6F3, -}; - -static bool isEmojiStyleVSBase(uint32_t cp) { - const size_t length = sizeof(EMOJI_STYLE_VS_BASES) / sizeof(EMOJI_STYLE_VS_BASES[0]); - return std::binary_search(EMOJI_STYLE_VS_BASES, EMOJI_STYLE_VS_BASES + length, cp); -} - uint32_t FontCollection::sNextId = 0; FontCollection::FontCollection(std::shared_ptr&& typeface) : mMaxChar(0) { @@ -378,11 +342,13 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, } // Even if there is no cmap format 14 subtable entry for the given sequence, should return true - // for emoji + U+FE0E case since we have special fallback rule for the sequence. - if (isEmojiStyleVSBase(baseCodepoint) && variationSelector == TEXT_STYLE_VS) { + // for case since we have special fallback rule for the + // sequence. Note that we don't need to restrict this to already standardized variation + // sequences, since Unicode is adding variation sequences more frequently now and may even move + // towards allowing text and emoji variation selectors on any character. + if (variationSelector == TEXT_STYLE_VS) { for (size_t i = 0; i < mFamilies.size(); ++i) { - if (!mFamilies[i]->isColorEmojiFamily() && variationSelector == TEXT_STYLE_VS && - mFamilies[i]->hasGlyph(baseCodepoint, 0)) { + if (!mFamilies[i]->isColorEmojiFamily() && mFamilies[i]->hasGlyph(baseCodepoint, 0)) { return true; } } diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index 716fcc378d..25406d0822 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -32,7 +32,7 @@ LOCAL_TEST_DATA := \ data/NoGlyphFont.ttf \ data/Regular.ttf \ data/TextEmojiFont.ttf \ - data/VarioationSelectorTest-Regular.ttf \ + data/VariationSelectorTest-Regular.ttf \ data/ZhHans.ttf \ data/ZhHant.ttf \ data/itemize.xml \ diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index aa142cccdc..78bfa3b94d 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -47,7 +47,7 @@ const char kTextEmojiFont[] = kTestFontDir "TextEmojiFont.ttf"; const char kMixedEmojiFont[] = kTestFontDir "ColorTextMixedEmojiFont.ttf"; const char kHasCmapFormat14Font[] = kTestFontDir "NoCmapFormat14.ttf"; -const char kNoCmapFormat14Font[] = kTestFontDir "VarioationSelectorTest-Regular.ttf"; +const char kNoCmapFormat14Font[] = kTestFontDir "VariationSelectorTest-Regular.ttf"; typedef ICUTestBase FontCollectionItemizeTest; @@ -667,7 +667,7 @@ TEST_F(FontCollectionItemizeTest, itemize_vs_sequence_but_no_base_char) { // kVSTestFont supports U+717D U+FE02 but doesn't support U+717D. // kVSTestFont should be selected for U+717D U+FE02 even if it does not support the base code // point. - const std::string kVSTestFont = kTestFontDir "VarioationSelectorTest-Regular.ttf"; + const std::string kVSTestFont = kTestFontDir "VariationSelectorTest-Regular.ttf"; std::vector> families; std::shared_ptr font(new MinikinFontForTest(kLatinFont)); diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index 100e206975..bef1c63088 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -38,7 +38,7 @@ namespace minikin { // U+717D U+FE02 (VS3) // U+717D U+E0102 (VS19) // U+717D U+E0103 (VS20) -const char kVsTestFont[] = kTestFontDir "/VarioationSelectorTest-Regular.ttf"; +const char kVsTestFont[] = kTestFontDir "/VariationSelectorTest-Regular.ttf"; void expectVSGlyphs(const FontCollection* fc, uint32_t codepoint, const std::set& vsSet) { for (uint32_t vs = 0xFE00; vs <= 0xE01EF; ++vs) { @@ -64,13 +64,13 @@ TEST(FontCollectionTest, hasVariationSelectorTest) { std::shared_ptr fc(new FontCollection(families)); EXPECT_FALSE(fc->hasVariationSelector(0x82A6, 0)); - expectVSGlyphs(fc.get(), 0x82A6, std::set({0xFE00, 0xE0100, 0xE0101, 0xE0102})); + expectVSGlyphs(fc.get(), 0x82A6, std::set({0xFE00, 0xFE0E, 0xE0100, 0xE0101, 0xE0102})); EXPECT_FALSE(fc->hasVariationSelector(0x845B, 0)); - expectVSGlyphs(fc.get(), 0x845B, std::set({0xFE01, 0xE0101, 0xE0102, 0xE0103})); + expectVSGlyphs(fc.get(), 0x845B, std::set({0xFE01, 0xFE0E, 0xE0101, 0xE0102, 0xE0103})); EXPECT_FALSE(fc->hasVariationSelector(0x537F, 0)); - expectVSGlyphs(fc.get(), 0x537F, std::set({})); + expectVSGlyphs(fc.get(), 0x537F, std::set({0xFE0E})); EXPECT_FALSE(fc->hasVariationSelector(0x717D, 0)); expectVSGlyphs(fc.get(), 0x717D, std::set({0xFE02, 0xE0102, 0xE0103})); @@ -99,10 +99,13 @@ TEST(FontCollectionTest, hasVariationSelectorTest_emoji) { EXPECT_TRUE(collection->hasVariationSelector(0x262E, 0xFE0E)); EXPECT_FALSE(collection->hasVariationSelector(0x262E, 0xFE0F)); + // Text font doesn't support U+1F3FD. Only the color emoji fonts has. So VS15 is not supported. + EXPECT_FALSE(collection->hasVariationSelector(0x1F3FD, 0xFE0E)); + // Text font doesn't have U+262F U+FE0E or even its base code point U+262F. EXPECT_FALSE(collection->hasVariationSelector(0x262F, 0xFE0E)); - // VS15/VS16 is only for emoji, should return false for not an emoji code point. + // None of the fonts support U+2229. EXPECT_FALSE(collection->hasVariationSelector(0x2229, 0xFE0E)); EXPECT_FALSE(collection->hasVariationSelector(0x2229, 0xFE0F)); diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 58a7bab5f6..0769aa4312 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -495,7 +495,7 @@ TEST_F(FontLanguagesTest, registerLanguageListTest) { // U+717D U+FE02 (VS3) // U+717D U+E0102 (VS19) // U+717D U+E0103 (VS20) -const char kVsTestFont[] = kTestFontDir "VarioationSelectorTest-Regular.ttf"; +const char kVsTestFont[] = kTestFontDir "VariationSelectorTest-Regular.ttf"; class FontFamilyTest : public ICUTestBase { public: From 6a5534a4373d441cae6f61663115fd784ba57b6d Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Wed, 22 Mar 2017 15:58:46 -0700 Subject: [PATCH 258/364] Remove unused functions. This CL is essentially reverting following changes: - "Serialize and deserialize supported axes." I4086fb887e13f872390b533584bce6f1d5598ea0 - "Make SparseBitSet serializable." I0463138adcf234739bb3ce1cdadf382021921f3e Bug: 36232655 Test: N/A Change-Id: I25c701e1805e92b01034142147a9925f86533819 --- .../src/flutter/include/minikin/FontFamily.h | 24 ------ .../flutter/include/minikin/SparseBitSet.h | 11 --- .../src/flutter/libs/minikin/FontFamily.cpp | 62 -------------- .../src/flutter/libs/minikin/SparseBitSet.cpp | 67 --------------- .../flutter/tests/perftests/FontFamily.cpp | 19 ----- .../flutter/tests/unittest/FontFamilyTest.cpp | 46 ---------- .../tests/unittest/SparseBitSetTest.cpp | 85 ------------------- 7 files changed, 314 deletions(-) diff --git a/engine/src/flutter/include/minikin/FontFamily.h b/engine/src/flutter/include/minikin/FontFamily.h index 18a75ee8ec..babed732f5 100644 --- a/engine/src/flutter/include/minikin/FontFamily.h +++ b/engine/src/flutter/include/minikin/FontFamily.h @@ -126,23 +126,6 @@ public: FontFamily(int variant, std::vector&& fonts); FontFamily(uint32_t langId, int variant, std::vector&& fonts); - // The accelerator table won't be copied. Do not release the memory until the created FontFamily - // is destructed. - FontFamily(std::vector&& fonts, const uint8_t* acceleratorTable, size_t tableSize); - FontFamily(int variant, std::vector&& fonts, const uint8_t* acceleratorTable, - size_t tableSize); - FontFamily(uint32_t langId, int variant, std::vector&& fonts, - const uint8_t* acceleratorTable, size_t tableSize); - - ~FontFamily(); - - // Writes internal accelerator tables into the 'out' buffer. - // - // This method returns the number of bytes written to the buffer. By calling the method with - // 'out' set to nullptr, the method just returns the size needed, which the caller can then use - // for allocating a buffer for a second call. - size_t writeAcceleratorTable(uint8_t* out) const; - // TODO: Good to expose FontUtil.h. static bool analyzeStyle(const std::shared_ptr& typeface, int* weight, bool* italic); @@ -177,13 +160,6 @@ public: private: void computeCoverage(); - void readAcceleratorTable(const uint8_t* data, size_t size); - - size_t writeSupportedAxes(uint8_t* out) const; - - // Reads supported axes values from 'in' buffer. This method reads up to - // 'inSize' bytes and returns the number of bytes read. - size_t readSupportedAxes(const uint8_t* in, size_t inSize); uint32_t mLangId; int mVariant; diff --git a/engine/src/flutter/include/minikin/SparseBitSet.h b/engine/src/flutter/include/minikin/SparseBitSet.h index 491e68ae7f..ba9d7797fb 100644 --- a/engine/src/flutter/include/minikin/SparseBitSet.h +++ b/engine/src/flutter/include/minikin/SparseBitSet.h @@ -45,17 +45,6 @@ public: // inclusive of start, exclusive of end, laid out in a uint32 array. void initFromRanges(const uint32_t* ranges, size_t nRanges); - // Initializes the set with pre-calculted data. Returns false if the serialized data is invalid. - // Even if this function returns false, the internal data is cleared. - bool initFromBuffer(const uint8_t* data, size_t size); - - // Serialize the set and write into out. - // - // This method returns the number of bytes written to the buffer. By calling the method with - // 'out' set to nullptr, the method just returns the size needed, which the caller can then use - // for allocating a buffer for a second call. - size_t writeToBuffer(uint8_t* out) const; - // Determine whether the value is included in the set bool get(uint32_t ch) const { if (ch >= mMaxVal) return false; diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 076dff2bcc..492db1e4f4 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -109,25 +109,6 @@ FontFamily::FontFamily(uint32_t langId, int variant, std::vector&& fonts) computeCoverage(); } -FontFamily::FontFamily(std::vector&& fonts, const uint8_t* acceleratorTable, size_t tableSize) - : FontFamily(0 /* variant */, std::move(fonts), acceleratorTable, tableSize) { -} - -FontFamily::FontFamily(int variant, std::vector&& fonts, const uint8_t* acceleratorTable, - size_t tableSize) - : FontFamily(FontLanguageListCache::kEmptyListId, variant, std::move(fonts), acceleratorTable, - tableSize) { -} - -FontFamily::FontFamily(uint32_t langId, int variant, std::vector&& fonts, - const uint8_t* acceleratorTable, size_t tableSize) - : mLangId(langId), mVariant(variant), mFonts(std::move(fonts)), mHasVSTable(false) { - readAcceleratorTable(acceleratorTable, tableSize); -} - -FontFamily::~FontFamily() { -} - bool FontFamily::analyzeStyle(const std::shared_ptr& typeface, int* weight, bool* italic) { android::AutoMutex _l(gMinikinLock); @@ -263,47 +244,4 @@ std::shared_ptr FontFamily::createFamilyWithVariation( return std::shared_ptr(new FontFamily(mLangId, mVariant, std::move(fonts))); } -size_t FontFamily::writeAcceleratorTable(uint8_t* out) const { - const size_t axesTableSize = writeSupportedAxes(out); - if (out != nullptr) { - out += axesTableSize; - } - const size_t coverageTableSize = mCoverage.writeToBuffer(out); - return axesTableSize + coverageTableSize; -} - -void FontFamily::readAcceleratorTable(const uint8_t* data, size_t size) { - const size_t readSize = readSupportedAxes(data, size); - data += readSize; - size -= readSize; - bool result = mCoverage.initFromBuffer(data, size); - LOG_ALWAYS_FATAL_IF(!result, "Failed to reconstruct accelerator table from buffer"); -} - -size_t FontFamily::writeSupportedAxes(uint8_t* out) const { - LOG_ALWAYS_FATAL_IF(mSupportedAxes.size() > 255, "System fonts may only use up to 255 axes."); - const uint8_t axesCount = static_cast(mSupportedAxes.size()); - if (out != nullptr) { - out[0] = axesCount; - AxisTag* axisTags = reinterpret_cast(out + 1); - for (const auto& tag : mSupportedAxes) { - *axisTags++ = tag; - } - } - const size_t axesSizeInbytes = sizeof(AxisTag) * axesCount; - return axesSizeInbytes + 1 /* 1 for axes count */; -} - -size_t FontFamily::readSupportedAxes(const uint8_t* in, size_t inSize) { - LOG_ALWAYS_FATAL_IF(inSize == 0); - const uint8_t axesCount = in[0]; - const size_t totalSize = sizeof(AxisTag) * axesCount + 1 /* 1 for axes Count */; - LOG_ALWAYS_FATAL_IF(inSize < totalSize); - const AxisTag* axisTags = reinterpret_cast(in + 1); - mSupportedAxes.clear(); - for (uint8_t i = 0; i < axesCount; ++i) { - mSupportedAxes.insert(axisTags[i]); - } - return totalSize; -} } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp index a95af4d716..51557df9af 100644 --- a/engine/src/flutter/libs/minikin/SparseBitSet.cpp +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -118,73 +118,6 @@ void SparseBitSet::initFromRanges(const uint32_t* ranges, size_t nRanges) { mIndices = indices; } -struct SparseBitSetHeader { - uint32_t maxValue; - uint32_t zeroPageIndex; - uint32_t indexSize; - uint32_t bitmapSize; -}; - -bool SparseBitSet::initFromBuffer(const uint8_t* data, size_t size) { - // No need to be concerned about endianness here since Intel x86 CPUs are little-endian. ARM - // CPUs are bi-endian but the endianness is only changeable at reset time and is impossible to - // change at runtime. Thus incoming data is guaranteed to have the same endianness as when it - // was created. - - if (data == nullptr || size < sizeof(SparseBitSetHeader)) { - clear(); - return false; - } - - // The serialized data starts with SparseBitSetHeader. - const SparseBitSetHeader* header = reinterpret_cast(data); - mMaxVal = header->maxValue; - mZeroPageIndex = header->zeroPageIndex; - mIndexSize = header->indexSize; - mBitmapSize = header->bitmapSize; - - mOwnIndicesAndBitmaps = false; - if (mIndexSize == 0 || mBitmapSize == 0 || mMaxVal == 0) { - const bool isValidEmptyBitSet = (mIndexSize == 0 && mBitmapSize == 0 && mMaxVal == 0); - if (!isValidEmptyBitSet) { - clear(); - } - return isValidEmptyBitSet; - } - - const size_t indicesSizeInBytes = sizeof(mIndices[0]) * mIndexSize; - const size_t bitmapsSizeInBytes = sizeof(mBitmaps[0]) * mBitmapSize; - if (size != sizeof(SparseBitSetHeader) + indicesSizeInBytes + bitmapsSizeInBytes) { - clear(); - return false; - } - data += sizeof(SparseBitSetHeader); - mIndices = reinterpret_cast(data); - data += indicesSizeInBytes; - mBitmaps = reinterpret_cast(data); - return true; -} - -size_t SparseBitSet::writeToBuffer(uint8_t* out) const{ - // See comments in SparseBitSet::initFromBuffer for the data structure. - const size_t indicesSizeInBytes = sizeof(mIndices[0]) * mIndexSize; - const size_t bitmapsSizeInBytes = sizeof(mBitmaps[0]) * mBitmapSize; - size_t necessarySize = sizeof(SparseBitSetHeader) + indicesSizeInBytes + bitmapsSizeInBytes; - if (out != nullptr) { - SparseBitSetHeader* header = reinterpret_cast(out); - header->maxValue = mMaxVal; - header->zeroPageIndex = mZeroPageIndex; - header->indexSize = mIndexSize; - header->bitmapSize = mBitmapSize; - - out += sizeof(SparseBitSetHeader); - memcpy(out, mIndices, indicesSizeInBytes); - out += indicesSizeInBytes; - memcpy(out, mBitmaps, bitmapsSizeInBytes); - } - return necessarySize; -} - int SparseBitSet::CountLeadingZeros(element x) { // Note: GCC / clang builtin return sizeof(element) <= sizeof(int) ? __builtin_clz(x) : __builtin_clzl(x); diff --git a/engine/src/flutter/tests/perftests/FontFamily.cpp b/engine/src/flutter/tests/perftests/FontFamily.cpp index a731ef640f..9ab61e1fa7 100644 --- a/engine/src/flutter/tests/perftests/FontFamily.cpp +++ b/engine/src/flutter/tests/perftests/FontFamily.cpp @@ -32,23 +32,4 @@ static void BM_FontFamily_create(benchmark::State& state) { BENCHMARK(BM_FontFamily_create); -static void BM_FontFamily_create_fromBuffer(benchmark::State& state) { - std::shared_ptr minikinFont = - std::make_shared("/system/fonts/NotoSansCJK-Regular.ttc", 0); - - std::shared_ptr family = std::make_shared( - std::vector({Font(minikinFont, FontStyle())})); - - size_t bufSize = family->writeAcceleratorTable(nullptr); - std::unique_ptr buffer(new uint8_t[bufSize]); - family->writeAcceleratorTable(buffer.get()); - - while (state.KeepRunning()) { - std::shared_ptr family = std::make_shared( - std::vector({Font(minikinFont, FontStyle())}), buffer.get(), bufSize); - } -} - -BENCHMARK(BM_FontFamily_create_fromBuffer); - } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 0769aa4312..90cc794083 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -656,50 +656,4 @@ TEST_F(FontFamilyTest, createFamilyWithVariationTest) { } } -TEST_F(FontFamilyTest, supportedAxesRestoreFromSerializedBuffer) { - const char kFontPath[] = kTestFontDir "/MultiAxis.ttf"; - - std::shared_ptr font(new MinikinFontForTest(kFontPath)); - std::shared_ptr family = - std::make_shared(std::vector({Font(font, FontStyle())})); - - size_t necessaryBytes = family->writeAcceleratorTable(nullptr); - ASSERT_NE(0U, necessaryBytes); - std::vector buffer; - buffer.resize(necessaryBytes); - family->writeAcceleratorTable(buffer.data()); - - std::shared_ptr restoredMultiAxisFamily = - std::make_shared(std::vector({Font(font, FontStyle())}), - buffer.data(), buffer.size()); - - // This font has 'wdth' and 'wght' axes. - const std::unordered_set& supportedAxes = family->supportedAxes(); - ASSERT_EQ(2U, supportedAxes.size()); - EXPECT_NE(supportedAxes.end(), supportedAxes.find(MinikinFont::MakeTag('w', 'd', 't', 'h'))); - EXPECT_NE(supportedAxes.end(), supportedAxes.find(MinikinFont::MakeTag('w', 'g', 'h', 't'))); -} - -TEST_F(FontFamilyTest, supportedAxesRestoreFromSerializedBuffer_NoAxisFont) { - const char kFontPath[] = kTestFontDir "/Regular.ttf"; - - std::shared_ptr font(new MinikinFontForTest(kFontPath)); - std::shared_ptr family = - std::make_shared(std::vector({Font(font, FontStyle())})); - - size_t necessaryBytes = family->writeAcceleratorTable(nullptr); - ASSERT_NE(0U, necessaryBytes); - std::vector buffer; - buffer.resize(necessaryBytes); - family->writeAcceleratorTable(buffer.data()); - - std::shared_ptr restoredMultiAxisFamily = - std::make_shared(std::vector({Font(font, FontStyle())}), - buffer.data(), buffer.size()); - - // This font supports no axes. - const std::unordered_set& supportedAxes = family->supportedAxes(); - EXPECT_TRUE(supportedAxes.empty()); -} - } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/SparseBitSetTest.cpp b/engine/src/flutter/tests/unittest/SparseBitSetTest.cpp index ab38f6ca75..cfb437f3f5 100644 --- a/engine/src/flutter/tests/unittest/SparseBitSetTest.cpp +++ b/engine/src/flutter/tests/unittest/SparseBitSetTest.cpp @@ -52,89 +52,4 @@ TEST(SparseBitSetTest, randomTest) { } } -TEST(SparseBitSetTest, randomTest_restoredFromBuffer) { - const uint32_t kTestRangeNum = 4096; - - std::mt19937 mt; // Fix seeds to be able to reproduce the result. - std::uniform_int_distribution distribution(1, 512); - - std::vector range { distribution(mt) }; - for (size_t i = 1; i < kTestRangeNum * 2; ++i) { - range.push_back((range.back() - 1) + distribution(mt)); - } - - SparseBitSet tmpBitset; - tmpBitset.initFromRanges(range.data(), range.size() / 2); - - size_t bufSize = tmpBitset.writeToBuffer(nullptr); - ASSERT_NE(0U, bufSize); - std::vector buffer(bufSize); - tmpBitset.writeToBuffer(buffer.data()); - - SparseBitSet bitset; - bitset.initFromBuffer(buffer.data(), buffer.size()); - - uint32_t ch = 0; - for (size_t i = 0; i < range.size() / 2; ++i) { - uint32_t start = range[i * 2]; - uint32_t end = range[i * 2 + 1]; - - for (; ch < start; ch++) { - ASSERT_FALSE(bitset.get(ch)) << std::hex << ch; - } - for (; ch < end; ch++) { - ASSERT_TRUE(bitset.get(ch)) << std::hex << ch; - } - } - for (; ch < 0x1FFFFFF; ++ch) { - ASSERT_FALSE(bitset.get(ch)) << std::hex << ch; - } -} - -TEST(SparseBitSetTest, emptyBitSet) { - SparseBitSet bitset; - uint32_t empty_bitset[4] = { - 0 /* max value */, 0 /* zero page index */, 0 /* index size */, 0 /* bitmap size */ - }; - EXPECT_TRUE(bitset.initFromBuffer( - reinterpret_cast(empty_bitset), sizeof(empty_bitset))); -} - -TEST(SparseBitSetTest, invalidData) { - SparseBitSet bitset; - EXPECT_FALSE(bitset.initFromBuffer(nullptr, 0)); - - // Buffer is too small. - uint32_t small_buffer[3] = { 0, 0, 0 }; - EXPECT_FALSE(bitset.initFromBuffer( - reinterpret_cast(small_buffer), sizeof(small_buffer))); - - // Buffer size does not match with necessary size. - uint32_t invalid_size_buffer[4] = { - 0x12345678 /* max value */, 0 /* zero page index */, 0x50 /* index size*/, - 0x80 /* bitmap size */ - }; - EXPECT_FALSE(bitset.initFromBuffer( - reinterpret_cast(invalid_size_buffer), sizeof(invalid_size_buffer))); - - // max value, index size, bitmap size must be zero if the bitset is empty. - uint32_t invalid_empty_bitset1[4] = { - 1 /* max value */, 0 /* zero page index */, 0 /* index size */, 0 /* bitmap size */ - }; - EXPECT_FALSE(bitset.initFromBuffer( - reinterpret_cast(invalid_empty_bitset1), sizeof(invalid_empty_bitset1))); - - uint32_t invalid_empty_bitset2[4] = { - 0 /* max value */, 0 /* zero page index */, 1 /* index size */, 0 /* bitmap size */ - }; - EXPECT_FALSE(bitset.initFromBuffer( - reinterpret_cast(invalid_empty_bitset2), sizeof(invalid_empty_bitset2))); - - uint32_t invalid_empty_bitset3[4] = { - 0 /* max value */, 0 /* zero page index */, 0 /* index size */, 1 /* bitmap size */ - }; - EXPECT_FALSE(bitset.initFromBuffer( - reinterpret_cast(invalid_empty_bitset3), sizeof(invalid_empty_bitset3))); -} - } // namespace minikin From bbffea58c5f6149e64868767b61f4d7fe3b8ea8e Mon Sep 17 00:00:00 2001 From: Dan Shi Date: Tue, 28 Mar 2017 16:10:05 -0700 Subject: [PATCH 259/364] Add test config to minikin_tests Design doc: Generalized Suites & the Unification of APCT & CTS Workflows Design/Roadmap https://docs.google.com/document/d/1eabK3srlBLouMiBMrNP3xJPiRRdcoCquNxC8gBWPvx8/edit#heading=h.78vup5eivwzo Details about test configs changes are tracked in doc https://docs.google.com/document/d/1EWUjJ7fjy8ge_Nk0YQbFdRp8DSHo3z6GU0R8jLgrAcw/edit# Bug: 35882476 Test: local test Change-Id: I0b1e0dc39975bc373685eb8adf1e297dc8f4c07a --- engine/src/flutter/tests/unittest/Android.mk | 1 + .../flutter/tests/unittest/AndroidTest.xml | 26 +++++++++++++++++++ 2 files changed, 27 insertions(+) create mode 100644 engine/src/flutter/tests/unittest/AndroidTest.xml diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index 25406d0822..06ce61b8ee 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -41,6 +41,7 @@ LOCAL_TEST_DATA := \ LOCAL_TEST_DATA := $(foreach f,$(LOCAL_TEST_DATA),frameworks/minikin/tests:$(f)) LOCAL_MODULE := minikin_tests +LOCAL_COMPATIBILITY_SUITE := device-tests LOCAL_MODULE_TAGS := tests LOCAL_MODULE_CLASS := NATIVE_TESTS diff --git a/engine/src/flutter/tests/unittest/AndroidTest.xml b/engine/src/flutter/tests/unittest/AndroidTest.xml new file mode 100644 index 0000000000..a0731014f1 --- /dev/null +++ b/engine/src/flutter/tests/unittest/AndroidTest.xml @@ -0,0 +1,26 @@ + + + + + + \ No newline at end of file From f0d9c2f52d2e01b9c77867ca05d5c501ccbf5d1e Mon Sep 17 00:00:00 2001 From: Dan Shi Date: Wed, 29 Mar 2017 12:11:51 -0700 Subject: [PATCH 260/364] Add test config to minikin_perftests Design doc: Generalized Suites & the Unification of APCT & CTS Workflows Design/Roadmap https://docs.google.com/document/d/1eabK3srlBLouMiBMrNP3xJPiRRdcoCquNxC8gBWPvx8/edit#heading=h.78vup5eivwzo Details about test configs changes are tracked in doc https://docs.google.com/document/d/1EWUjJ7fjy8ge_Nk0YQbFdRp8DSHo3z6GU0R8jLgrAcw/edit# Bug: 35882476 Test: local test Change-Id: I23366d56aaa7fbd22ed8233df0969a17e371c5a5 --- engine/src/flutter/tests/perftests/Android.mk | 1 + .../flutter/tests/perftests/AndroidTest.xml | 26 +++++++++++++++++++ 2 files changed, 27 insertions(+) create mode 100644 engine/src/flutter/tests/perftests/AndroidTest.xml diff --git a/engine/src/flutter/tests/perftests/Android.mk b/engine/src/flutter/tests/perftests/Android.mk index c60123a83d..aa18f8b27a 100644 --- a/engine/src/flutter/tests/perftests/Android.mk +++ b/engine/src/flutter/tests/perftests/Android.mk @@ -31,6 +31,7 @@ perftest_src_files := \ include $(CLEAR_VARS) LOCAL_MODULE := minikin_perftests +LOCAL_COMPATIBILITY_SUITE := device-tests LOCAL_CPPFLAGS := -Werror -Wall -Wextra LOCAL_SRC_FILES := $(perftest_src_files) LOCAL_STATIC_LIBRARIES := \ diff --git a/engine/src/flutter/tests/perftests/AndroidTest.xml b/engine/src/flutter/tests/perftests/AndroidTest.xml new file mode 100644 index 0000000000..dcbdcf11ce --- /dev/null +++ b/engine/src/flutter/tests/perftests/AndroidTest.xml @@ -0,0 +1,26 @@ + + + + + + From 7708c89648451a69f6287c7dbc419865769fff59 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Thu, 30 Mar 2017 16:24:42 -0700 Subject: [PATCH 261/364] Remove unused classes and methods Removed Bitmap and MinikinFontFreeType classes, as well as the Layout::draw() method. The code was there for debugging purposes and for potential third-party users. We no longer support third-party uses of Minikin, since we don't know of any. Test: mmma -j frameworks/minikin builds with no errors Change-Id: Iddc9e8d35334053bd5255bccf3dbe5ba1eecf814 --- engine/src/flutter/include/minikin/Layout.h | 18 ---- .../src/flutter/include/minikin/MinikinFont.h | 2 - .../include/minikin/MinikinFontFreeType.h | 75 ------------- engine/src/flutter/libs/minikin/Android.mk | 2 - engine/src/flutter/libs/minikin/Layout.cpp | 67 ------------ .../libs/minikin/MinikinFontFreeType.cpp | 100 ------------------ engine/src/flutter/tests/unittest/Android.mk | 1 - 7 files changed, 265 deletions(-) delete mode 100644 engine/src/flutter/include/minikin/MinikinFontFreeType.h delete mode 100644 engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp diff --git a/engine/src/flutter/include/minikin/Layout.h b/engine/src/flutter/include/minikin/Layout.h index 8a6e7725d0..6d1de2fbd2 100644 --- a/engine/src/flutter/include/minikin/Layout.h +++ b/engine/src/flutter/include/minikin/Layout.h @@ -23,25 +23,9 @@ #include #include -#include namespace minikin { -// The Bitmap class is for debugging. We'll probably move it out -// of here into a separate lightweight software rendering module -// (optional, as we'd hope most clients would do their own) -class Bitmap { -public: - Bitmap(int width, int height); - ~Bitmap(); - void writePnm(std::ofstream& o) const; - void drawGlyph(const GlyphBitmap& bitmap, int x, int y); -private: - int width; - int height; - uint8_t* buf; -}; - struct LayoutGlyph { // index into mFaces and mHbFonts vectors. We could imagine // moving this into a run length representation, because it's @@ -95,8 +79,6 @@ public: int bidiFlags, const FontStyle &style, const MinikinPaint &paint, const std::shared_ptr& collection, float* advances); - void draw(minikin::Bitmap*, int x0, int y0, float size) const; - // public accessors size_t nGlyphs() const; const MinikinFont* getFont(int i) const; diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 52263f529a..01af786aa6 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -81,8 +81,6 @@ struct MinikinRect { void join(const MinikinRect& r); }; -class MinikinFontFreeType; - // Callback for freeing data typedef void (*MinikinDestroyFunc) (void* data); diff --git a/engine/src/flutter/include/minikin/MinikinFontFreeType.h b/engine/src/flutter/include/minikin/MinikinFontFreeType.h deleted file mode 100644 index 37333e5f37..0000000000 --- a/engine/src/flutter/include/minikin/MinikinFontFreeType.h +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright (C) 2013 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef MINIKIN_FONT_FREETYPE_H -#define MINIKIN_FONT_FREETYPE_H - -#include -#include FT_FREETYPE_H -#include FT_TRUETYPE_TABLES_H - -#include - -// An abstraction for platform fonts, allowing Minikin to be used with -// multiple actual implementations of fonts. - -namespace minikin { - -struct GlyphBitmap { - uint8_t *buffer; - int width; - int height; - int left; - int top; -}; - -class MinikinFontFreeType : public MinikinFont { -public: - explicit MinikinFontFreeType(FT_Face typeface); - - ~MinikinFontFreeType(); - - float GetHorizontalAdvance(uint32_t glyph_id, - const MinikinPaint &paint) const; - - void GetBounds(MinikinRect* bounds, uint32_t glyph_id, - const MinikinPaint& paint) const; - - const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy); - - const std::vector& GetAxes() const { - return mAxes; - } - - // TODO: provide access to raw data, as an optimization. - - // Not a virtual method, as the protocol to access rendered - // glyph bitmaps is probably different depending on the - // backend. - bool Render(uint32_t glyph_id, - const MinikinPaint &paint, GlyphBitmap *result); - - MinikinFontFreeType* GetFreeType(); - -private: - FT_Face mTypeface; - static int32_t sIdCounter; - std::vector mAxes; -}; - -} // namespace minikin - -#endif // MINIKIN_FONT_FREETYPE_H diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index be5301218a..67a478a7c7 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -33,13 +33,11 @@ minikin_src_files := \ Measurement.cpp \ MinikinInternal.cpp \ MinikinFont.cpp \ - MinikinFontFreeType.cpp \ SparseBitSet.cpp \ WordBreaker.cpp minikin_c_includes := \ external/harfbuzz_ng/src \ - external/freetype/include \ frameworks/minikin/include \ $(intermediates) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 0a318bdccd..1f2fbc4457 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -39,7 +39,6 @@ #include "HbFontCache.h" #include "LayoutUtils.h" #include "MinikinInternal.h" -#include #include using std::string; @@ -47,44 +46,6 @@ using std::vector; namespace minikin { -Bitmap::Bitmap(int width, int height) : width(width), height(height) { - buf = new uint8_t[width * height](); -} - -Bitmap::~Bitmap() { - delete[] buf; -} - -void Bitmap::writePnm(std::ofstream &o) const { - o << "P5" << std::endl; - o << width << " " << height << std::endl; - o << "255" << std::endl; - o.write((const char *)buf, width * height); - o.close(); -} - -void Bitmap::drawGlyph(const GlyphBitmap& bitmap, int x, int y) { - int bmw = bitmap.width; - int bmh = bitmap.height; - x += bitmap.left; - y -= bitmap.top; - int x0 = std::max(0, x); - int x1 = std::min(width, x + bmw); - int y0 = std::max(0, y); - int y1 = std::min(height, y + bmh); - const unsigned char* src = bitmap.buffer + (y0 - y) * bmw + (x0 - x); - uint8_t* dst = buf + y0 * width; - for (int yy = y0; yy < y1; yy++) { - for (int xx = x0; xx < x1; xx++) { - int pixel = (int)dst[xx] + (int)src[xx - x]; - pixel = pixel > 0xff ? 0xff : pixel; - dst[xx] = pixel; - } - src += bmw; - dst += width; - } -} - const int kDirection_Mask = 0x1; struct LayoutContext { @@ -1091,34 +1052,6 @@ void Layout::appendLayout(Layout* src, size_t start, float extraAdvance) { } } -void Layout::draw(minikin::Bitmap* surface, int x0, int y0, float size) const { - /* - TODO: redo as MinikinPaint settings - if (mProps.hasTag(minikinHinting)) { - int hintflags = mProps.value(minikinHinting).getIntValue(); - if (hintflags & 1) load_flags |= FT_LOAD_NO_HINTING; - if (hintflags & 2) load_flags |= FT_LOAD_NO_AUTOHINT; - } - */ - for (size_t i = 0; i < mGlyphs.size(); i++) { - const LayoutGlyph& glyph = mGlyphs[i]; - MinikinFont* mf = mFaces[glyph.font_ix].font; - MinikinFontFreeType* face = static_cast(mf); - GlyphBitmap glyphBitmap; - MinikinPaint paint; - paint.size = size; - bool ok = face->Render(glyph.glyph_id, paint, &glyphBitmap); -#ifdef VERBOSE_DEBUG - ALOGD("glyphBitmap.width=%d, glyphBitmap.height=%d (%d, %d) x=%f, y=%f, ok=%d", - glyphBitmap.width, glyphBitmap.height, glyphBitmap.left, glyphBitmap.top, glyph.x, glyph.y, ok); -#endif - if (ok) { - surface->drawGlyph(glyphBitmap, - x0 + int(floor(glyph.x + 0.5)), y0 + int(floor(glyph.y + 0.5))); - } - } -} - size_t Layout::nGlyphs() const { return mGlyphs.size(); } diff --git a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp b/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp deleted file mode 100644 index 6f56a8dd55..0000000000 --- a/engine/src/flutter/libs/minikin/MinikinFontFreeType.cpp +++ /dev/null @@ -1,100 +0,0 @@ -/* - * Copyright (C) 2013 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// Implementation of MinikinFont abstraction specialized for FreeType - -#include - -#include -#include FT_FREETYPE_H -#include FT_TRUETYPE_TABLES_H -#include FT_ADVANCES_H - -#include - -namespace minikin { - -int32_t MinikinFontFreeType::sIdCounter = 0; - -MinikinFontFreeType::MinikinFontFreeType(FT_Face typeface) : - MinikinFont(sIdCounter++), - mTypeface(typeface) { -} - -MinikinFontFreeType::~MinikinFontFreeType() { - FT_Done_Face(mTypeface); -} - -float MinikinFontFreeType::GetHorizontalAdvance(uint32_t glyph_id, - const MinikinPaint &paint) const { - FT_Set_Pixel_Sizes(mTypeface, 0, paint.size); - FT_UInt32 flags = FT_LOAD_DEFAULT; // TODO: respect hinting settings - FT_Fixed advance; - FT_Get_Advance(mTypeface, glyph_id, flags, &advance); - return advance * (1.0 / 65536); -} - -void MinikinFontFreeType::GetBounds(MinikinRect* /* bounds */, uint32_t /* glyph_id*/, - const MinikinPaint& /* paint */) const { - // TODO: NYI -} - -const void* MinikinFontFreeType::GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) { - FT_ULong ftsize = 0; - FT_Error error = FT_Load_Sfnt_Table(mTypeface, tag, 0, nullptr, &ftsize); - if (error != 0) { - return nullptr; - } - FT_Byte* buf = reinterpret_cast(malloc(ftsize)); - if (buf == nullptr) { - return nullptr; - } - error = FT_Load_Sfnt_Table(mTypeface, tag, 0, buf, &ftsize); - if (error != 0) { - free(buf); - return nullptr; - } - *destroy = free; - *size = ftsize; - return buf; -} - -bool MinikinFontFreeType::Render(uint32_t glyph_id, const MinikinPaint& /* paint */, - GlyphBitmap *result) { - FT_Error error; - FT_Int32 load_flags = FT_LOAD_DEFAULT; // TODO: respect hinting settings - error = FT_Load_Glyph(mTypeface, glyph_id, load_flags); - if (error != 0) { - return false; - } - error = FT_Render_Glyph(mTypeface->glyph, FT_RENDER_MODE_NORMAL); - if (error != 0) { - return false; - } - FT_Bitmap &bitmap = mTypeface->glyph->bitmap; - result->buffer = bitmap.buffer; - result->width = bitmap.width; - result->height = bitmap.rows; - result->left = mTypeface->glyph->bitmap_left; - result->top = mTypeface->glyph->bitmap_top; - return true; -} - -MinikinFontFreeType* MinikinFontFreeType::GetFreeType() { - return this; -} - -} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index 25406d0822..eca0107397 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -84,7 +84,6 @@ LOCAL_SRC_FILES += \ LOCAL_C_INCLUDES := \ $(LOCAL_PATH)/../../libs/minikin/ \ $(LOCAL_PATH)/../util \ - external/freetype/include \ external/harfbuzz_ng/src \ external/libxml2/include \ external/skia/src/core From d01462f7a1affe4d863e97d9d1f0986cf50af626 Mon Sep 17 00:00:00 2001 From: Roozbeh Pournader Date: Thu, 30 Mar 2017 19:54:00 -0700 Subject: [PATCH 262/364] Override the bidi properties of new emojis Test: new Minikin tests are added, and pass Bug: 32952475 Change-Id: Ibcae60d18d0cd5efd7556aaf58a716b6b59c8ee0 --- engine/src/flutter/include/minikin/Emoji.h | 34 ++++++++ engine/src/flutter/libs/minikin/Android.mk | 1 + engine/src/flutter/libs/minikin/Emoji.cpp | 77 +++++++++++++++++++ .../flutter/libs/minikin/FontCollection.cpp | 1 + .../flutter/libs/minikin/GraphemeBreak.cpp | 1 + engine/src/flutter/libs/minikin/Layout.cpp | 8 ++ .../flutter/libs/minikin/MinikinInternal.cpp | 42 ---------- .../flutter/libs/minikin/MinikinInternal.h | 9 --- .../src/flutter/libs/minikin/WordBreaker.cpp | 3 +- engine/src/flutter/tests/unittest/Android.mk | 2 +- ...{MinikinInternalTest.cpp => EmojiTest.cpp} | 16 +++- 11 files changed, 137 insertions(+), 57 deletions(-) create mode 100644 engine/src/flutter/include/minikin/Emoji.h create mode 100644 engine/src/flutter/libs/minikin/Emoji.cpp rename engine/src/flutter/tests/unittest/{MinikinInternalTest.cpp => EmojiTest.cpp} (85%) diff --git a/engine/src/flutter/include/minikin/Emoji.h b/engine/src/flutter/include/minikin/Emoji.h new file mode 100644 index 0000000000..28261735aa --- /dev/null +++ b/engine/src/flutter/include/minikin/Emoji.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2014 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 + +namespace minikin { + +// Returns true if c is emoji. +bool isEmoji(uint32_t c); + +// Returns true if c is emoji modifier base. +bool isEmojiBase(uint32_t c); + +// Returns true if c is emoji modifier. +bool isEmojiModifier(uint32_t c); + +// Bidi override for ICU that knows about new emoji. +UCharDirection emojiBidiOverride(const void* context, UChar32 c); + +} // namespace minikin + diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk index 67a478a7c7..bb6234a123 100644 --- a/engine/src/flutter/libs/minikin/Android.mk +++ b/engine/src/flutter/libs/minikin/Android.mk @@ -19,6 +19,7 @@ include $(CLEAR_VARS) include $(CLEAR_VARS) minikin_src_files := \ CmapCoverage.cpp \ + Emoji.cpp \ FontCollection.cpp \ FontFamily.cpp \ FontLanguage.cpp \ diff --git a/engine/src/flutter/libs/minikin/Emoji.cpp b/engine/src/flutter/libs/minikin/Emoji.cpp new file mode 100644 index 0000000000..fbe68ca843 --- /dev/null +++ b/engine/src/flutter/libs/minikin/Emoji.cpp @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2014 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 + +namespace minikin { + +bool isNewEmoji(uint32_t c) { + // Emoji characters new in Unicode emoji 5.0. + // From http://www.unicode.org/Public/emoji/5.0/emoji-data.txt + // TODO: Remove once emoji-data.text 5.0 is in ICU or update to 6.0. + if (c < 0x1F6F7 || c > 0x1F9E6) { + // Optimization for characters outside the new emoji range. + return false; + } + return (0x1F6F7 <= c && c <= 0x1F6F8) + || c == 0x1F91F + || (0x1F928 <= c && c <= 0x1F92F) + || (0x1F931 <= c && c <= 0x1F932) + || c == 0x1F94C + || (0x1F95F <= c && c <= 0x1F96B) + || (0x1F992 <= c && c <= 0x1F997) + || (0x1F9D0 <= c && c <= 0x1F9E6); +} + +bool isEmoji(uint32_t c) { + return isNewEmoji(c) || u_hasBinaryProperty(c, UCHAR_EMOJI); +} + +bool isEmojiModifier(uint32_t c) { + // Emoji modifier are not expected to change, so there's a small change we need to customize + // this. + return u_hasBinaryProperty(c, UCHAR_EMOJI_MODIFIER); +} + +bool isEmojiBase(uint32_t c) { + // These two characters were removed from Emoji_Modifier_Base in Emoji 4.0, but we need to keep + // them as emoji modifier bases since there are fonts and user-generated text out there that + // treats these as potential emoji bases. + if (c == 0x1F91D || c == 0x1F93C) { + return true; + } + // Emoji Modifier Base characters new in Unicode emoji 5.0. + // From http://www.unicode.org/Public/emoji/5.0/emoji-data.txt + // TODO: Remove once emoji-data.text 5.0 is in ICU or update to 6.0. + if (c == 0x1F91F + || (0x1F931 <= c && c <= 0x1F932) + || (0x1F9D1 <= c && c <= 0x1F9DD)) { + return true; + } + return u_hasBinaryProperty(c, UCHAR_EMOJI_MODIFIER_BASE); +} + +UCharDirection emojiBidiOverride(const void* /* context */, UChar32 c) { + if (isNewEmoji(c)) { + // All new emoji characters in Unicode 10.0 are of the bidi class ON. + return U_OTHER_NEUTRAL; + } else { + return u_charDirection(c); + } +} + +} // namespace minikin + diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 962b95b4af..02ed9dc623 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -27,6 +27,7 @@ #include "FontLanguage.h" #include "FontLanguageListCache.h" #include "MinikinInternal.h" +#include #include using std::vector; diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index b1188e8d88..87de4213f9 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -20,6 +20,7 @@ #include #include +#include #include "MinikinInternal.h" namespace minikin { diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 1f2fbc4457..568e03876b 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -39,6 +39,7 @@ #include "HbFontCache.h" #include "LayoutUtils.h" #include "MinikinInternal.h" +#include #include using std::string; @@ -522,6 +523,13 @@ BidiText::BidiText(const uint16_t* buf, size_t start, size_t count, size_t bufSi return; } UErrorCode status = U_ZERO_ERROR; + // Set callbacks to override bidi classes of new emoji + ubidi_setClassCallback(mBidi, emojiBidiOverride, nullptr, nullptr, nullptr, &status); + if (!U_SUCCESS(status)) { + ALOGE("error setting bidi callback function, status = %d", status); + return; + } + UBiDiLevel bidiReq = bidiFlags; if (bidiFlags == kBidi_Default_LTR) { bidiReq = UBIDI_DEFAULT_LTR; diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 212ee26c0f..88acc5061b 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -20,7 +20,6 @@ #include "MinikinInternal.h" #include "HbFontCache.h" -#include #include namespace minikin { @@ -33,47 +32,6 @@ void assertMinikinLocked() { #endif } -bool isEmoji(uint32_t c) { - // Emoji characters new in Unicode emoji 5.0. - // From http://www.unicode.org/Public/emoji/5.0/emoji-data.txt - // TODO: Remove once emoji-data.text 5.0 is in ICU or update to 6.0. - if ((0x1F6F7 <= c && c <= 0x1F6F8) - || c == 0x1F91F - || (0x1F928 <= c && c <= 0x1F92F) - || (0x1F931 <= c && c <= 0x1F932) - || c == 0x1F94C - || (0x1F95F <= c && c <= 0x1F96B) - || (0x1F992 <= c && c <= 0x1F997) - || (0x1F9D0 <= c && c <= 0x1F9E6)) { - return true; - } - return u_hasBinaryProperty(c, UCHAR_EMOJI); -} - -bool isEmojiModifier(uint32_t c) { - // Emoji modifier are not expected to change, so there's a small change we need to customize - // this. - return u_hasBinaryProperty(c, UCHAR_EMOJI_MODIFIER); -} - -bool isEmojiBase(uint32_t c) { - // These two characters were removed from Emoji_Modifier_Base in Emoji 4.0, but we need to keep - // them as emoji modifier bases since there are fonts and user-generated text out there that - // treats these as potential emoji bases. - if (c == 0x1F91D || c == 0x1F93C) { - return true; - } - // Emoji Modifier Base characters new in Unicode emoji 5.0. - // From http://www.unicode.org/Public/emoji/5.0/emoji-data.txt - // TODO: Remove once emoji-data.text 5.0 is in ICU or update to 6.0. - if (c == 0x1F91F - || (0x1F931 <= c && c <= 0x1F932) - || (0x1F9D1 <= c && c <= 0x1F9DD)) { - return true; - } - return u_hasBinaryProperty(c, UCHAR_EMOJI_MODIFIER_BASE); -} - hb_blob_t* getFontTable(const MinikinFont* minikinFont, uint32_t tag) { assertMinikinLocked(); hb_font_t* font = getHbFontLocked(minikinFont); diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index 365f20cc0d..250f63d74b 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -36,15 +36,6 @@ extern android::Mutex gMinikinLock; // Aborts if gMinikinLock is not acquired. Do nothing on the release build. void assertMinikinLocked(); -// Returns true if c is emoji. -bool isEmoji(uint32_t c); - -// Returns true if c is emoji modifier base. -bool isEmojiBase(uint32_t c); - -// Returns true if c is emoji modifier. -bool isEmojiModifier(uint32_t c); - hb_blob_t* getFontTable(const MinikinFont* minikinFont, uint32_t tag); // An RAII wrapper for hb_blob_t diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index 3b9e956fe1..16edca7d6e 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -18,8 +18,9 @@ #include -#include +#include #include +#include #include "MinikinInternal.h" #include diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index eca0107397..d30c1062ce 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -66,13 +66,13 @@ LOCAL_SRC_FILES += \ ../util/FontTestUtils.cpp \ ../util/MinikinFontForTest.cpp \ ../util/UnicodeUtils.cpp \ + EmojiTest.cpp \ FontCollectionTest.cpp \ FontCollectionItemizeTest.cpp \ FontFamilyTest.cpp \ FontLanguageListCacheTest.cpp \ HbFontCacheTest.cpp \ HyphenatorTest.cpp \ - MinikinInternalTest.cpp \ GraphemeBreakTests.cpp \ LayoutTest.cpp \ LayoutUtilsTest.cpp \ diff --git a/engine/src/flutter/tests/unittest/MinikinInternalTest.cpp b/engine/src/flutter/tests/unittest/EmojiTest.cpp similarity index 85% rename from engine/src/flutter/tests/unittest/MinikinInternalTest.cpp rename to engine/src/flutter/tests/unittest/EmojiTest.cpp index 1d3ecd76b8..e7d0f56f49 100644 --- a/engine/src/flutter/tests/unittest/MinikinInternalTest.cpp +++ b/engine/src/flutter/tests/unittest/EmojiTest.cpp @@ -18,11 +18,11 @@ #include -#include "MinikinInternal.h" +#include namespace minikin { -TEST(MinikinInternalTest, isEmojiTest) { +TEST(EmojiTest, isEmojiTest) { EXPECT_TRUE(isEmoji(0x0023)); // NUMBER SIGN EXPECT_TRUE(isEmoji(0x0035)); // DIGIT FIVE EXPECT_TRUE(isEmoji(0x2640)); // FEMALE SIGN @@ -40,7 +40,7 @@ TEST(MinikinInternalTest, isEmojiTest) { EXPECT_FALSE(isEmoji(0x29E3D)); // A han character. } -TEST(MinikinInternalTest, isEmojiModifierTest) { +TEST(EmojiTest, isEmojiModifierTest) { EXPECT_TRUE(isEmojiModifier(0x1F3FB)); // EMOJI MODIFIER FITZPATRICK TYPE-1-2 EXPECT_TRUE(isEmojiModifier(0x1F3FC)); // EMOJI MODIFIER FITZPATRICK TYPE-3 EXPECT_TRUE(isEmojiModifier(0x1F3FD)); // EMOJI MODIFIER FITZPATRICK TYPE-4 @@ -53,7 +53,7 @@ TEST(MinikinInternalTest, isEmojiModifierTest) { EXPECT_FALSE(isEmojiModifier(0x29E3D)); // A han character. } -TEST(MinikinInternalTest, isEmojiBaseTest) { +TEST(EmojiTest, isEmojiBaseTest) { EXPECT_TRUE(isEmojiBase(0x261D)); // WHITE UP POINTING INDEX EXPECT_TRUE(isEmojiBase(0x270D)); // WRITING HAND EXPECT_TRUE(isEmojiBase(0x1F385)); // FATHER CHRISTMAS @@ -77,4 +77,12 @@ TEST(MinikinInternalTest, isEmojiBaseTest) { EXPECT_FALSE(isEmojiBase(0x29E3D)); // A han character. } +TEST(EmojiTest, emojiBidiOverrideTest) { + EXPECT_EQ(U_RIGHT_TO_LEFT, emojiBidiOverride(nullptr, 0x05D0)); // HEBREW LETTER ALEF + EXPECT_EQ(U_LEFT_TO_RIGHT, + emojiBidiOverride(nullptr, 0x1F170)); // NEGATIVE SQUARED LATIN CAPITAL LETTER A + EXPECT_EQ(U_OTHER_NEUTRAL, emojiBidiOverride(nullptr, 0x1F6F7)); // SLED + EXPECT_EQ(U_OTHER_NEUTRAL, emojiBidiOverride(nullptr, 0x1F9E6)); // SOCKS +} + } // namespace minikin From cc8f7117d33f0b80cd11e4d189eba3861ef8b380 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Fri, 24 Mar 2017 16:57:20 -0700 Subject: [PATCH 263/364] Support cmap tables with platform ID == 0 Some fonts don't have cmap subtables of Microsoft Platform ID (3) and only have cmap subtables of Unicode Platform ID (0). Bug: 32505843 Test: minikin_unittest passed Test: android.graphics.cts.TypefaceTest passed Change-Id: I24aa49860790c0ae8d8e578efd728b95ec0f93ae --- .../flutter/include/minikin/CmapCoverage.h | 2 +- .../flutter/include/minikin/SparseBitSet.h | 33 +- .../src/flutter/libs/minikin/CmapCoverage.cpp | 180 ++++-- .../src/flutter/libs/minikin/FontFamily.cpp | 3 +- .../src/flutter/libs/minikin/SparseBitSet.cpp | 36 +- engine/src/flutter/tests/unittest/Android.mk | 8 +- .../tests/unittest/CmapCoverageTest.cpp | 586 ++++++++++++++++++ .../flutter/tests/unittest/FontFamilyTest.cpp | 44 +- .../tests/unittest/SparseBitSetTest.cpp | 3 +- 9 files changed, 780 insertions(+), 115 deletions(-) create mode 100644 engine/src/flutter/tests/unittest/CmapCoverageTest.cpp diff --git a/engine/src/flutter/include/minikin/CmapCoverage.h b/engine/src/flutter/include/minikin/CmapCoverage.h index 19b43f38de..5136d8692a 100644 --- a/engine/src/flutter/include/minikin/CmapCoverage.h +++ b/engine/src/flutter/include/minikin/CmapCoverage.h @@ -23,7 +23,7 @@ namespace minikin { class CmapCoverage { public: - static bool getCoverage(SparseBitSet &coverage, const uint8_t* cmap_data, size_t cmap_size, + static SparseBitSet getCoverage(const uint8_t* cmap_data, size_t cmap_size, bool* has_cmap_format14_subtable); }; diff --git a/engine/src/flutter/include/minikin/SparseBitSet.h b/engine/src/flutter/include/minikin/SparseBitSet.h index ba9d7797fb..91288988ac 100644 --- a/engine/src/flutter/include/minikin/SparseBitSet.h +++ b/engine/src/flutter/include/minikin/SparseBitSet.h @@ -31,19 +31,20 @@ namespace minikin { // of thousands to millions. It is particularly efficient when there are // large gaps. The motivating example is Unicode coverage of a font, but // the abstraction itself is fully general. - class SparseBitSet { public: - SparseBitSet(): mMaxVal(0), mOwnIndicesAndBitmaps(false) { - } - - // Clear the set - void clear(); + // Create an empty bit set. + SparseBitSet() : mMaxVal(0) {} // Initialize the set to a new value, represented by ranges. For // simplicity, these ranges are arranged as pairs of values, // inclusive of start, exclusive of end, laid out in a uint32 array. - void initFromRanges(const uint32_t* ranges, size_t nRanges); + SparseBitSet(const uint32_t* ranges, size_t nRanges) : SparseBitSet() { + initFromRanges(ranges, nRanges); + } + + SparseBitSet(SparseBitSet&&) = default; + SparseBitSet& operator=(SparseBitSet&&) = default; // Determine whether the value is included in the set bool get(uint32_t ch) const { @@ -65,6 +66,8 @@ public: static const uint32_t kNotFound = ~0u; private: + void initFromRanges(const uint32_t* ranges, size_t nRanges); + static const int kLogValuesPerPage = 8; static const int kPageMask = (1 << kLogValuesPerPage) - 1; static const int kLogBytesPerEl = 2; @@ -81,18 +84,14 @@ private: uint32_t mMaxVal; - // True if this SparseBitSet is responsible for freeing mIndices and mBitamps. - bool mOwnIndicesAndBitmaps; - - uint32_t mIndexSize; - const uint32_t* mIndices; - uint32_t mBitmapSize; - const element* mBitmaps; + std::unique_ptr mIndices; + std::unique_ptr mBitmaps; uint32_t mZeroPageIndex; -}; -// Note: this thing cannot be used in vectors yet. If that were important, we'd need to -// make the copy constructor work, and probably set up move traits as well. + // Forbid copy and assign. + SparseBitSet(const SparseBitSet&) = delete; + void operator=(const SparseBitSet&) = delete; +}; } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index 6fa67155b4..ed053da788 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -132,76 +132,146 @@ static bool getCoverageFormat12(vector& coverage, const uint8_t* data, return true; } -bool CmapCoverage::getCoverage(SparseBitSet& coverage, const uint8_t* cmap_data, size_t cmap_size, +// Lower value has higher priority. 0 for the highest priority table. +// kLowestPriority for unsupported tables. +// This order comes from HarfBuzz's hb-ot-font.cc and needs to be kept in sync with it. +constexpr uint8_t kLowestPriority = 255; +uint8_t getTablePriority(uint16_t platformId, uint16_t encodingId) { + if (platformId == 3 && encodingId == 10) { + return 0; + } + if (platformId == 0 && encodingId == 6) { + return 1; + } + if (platformId == 0 && encodingId == 4) { + return 2; + } + if (platformId == 3 && encodingId == 1) { + return 3; + } + if (platformId == 0 && encodingId == 3) { + return 4; + } + if (platformId == 0 && encodingId == 2) { + return 5; + } + if (platformId == 0 && encodingId == 1) { + return 6; + } + if (platformId == 0 && encodingId == 0) { + return 7; + } + // Tables other than above are not supported. + return kLowestPriority; +} + +SparseBitSet CmapCoverage::getCoverage(const uint8_t* cmap_data, size_t cmap_size, bool* has_cmap_format14_subtable) { - vector coverageVec; - const size_t kHeaderSize = 4; - const size_t kNumTablesOffset = 2; - const size_t kTableSize = 8; - const size_t kPlatformIdOffset = 0; - const size_t kEncodingIdOffset = 2; - const size_t kOffsetOffset = 4; - const uint16_t kUnicodePlatformId = 0; - const uint16_t kMicrosoftPlatformId = 3; - const uint16_t kUnicodeBmpEncodingId = 1; - const uint16_t kVariationSequencesEncodingId = 5; - const uint16_t kUnicodeUcs4EncodingId = 10; - const uint32_t kNoTable = UINT32_MAX; + constexpr size_t kHeaderSize = 4; + constexpr size_t kNumTablesOffset = 2; + constexpr size_t kTableSize = 8; + constexpr size_t kPlatformIdOffset = 0; + constexpr size_t kEncodingIdOffset = 2; + constexpr size_t kOffsetOffset = 4; + constexpr size_t kFormatOffset = 0; + constexpr uint32_t kInvalidOffset = UINT32_MAX; + if (kHeaderSize > cmap_size) { - return false; + return SparseBitSet(); } uint32_t numTables = readU16(cmap_data, kNumTablesOffset); if (kHeaderSize + numTables * kTableSize > cmap_size) { - return false; + return SparseBitSet(); } - uint32_t bestTable = kNoTable; - bool hasCmapFormat14Subtable = false; - for (uint32_t i = 0; i < numTables; i++) { - uint16_t platformId = readU16(cmap_data, kHeaderSize + i * kTableSize + kPlatformIdOffset); - uint16_t encodingId = readU16(cmap_data, kHeaderSize + i * kTableSize + kEncodingIdOffset); - if (platformId == kMicrosoftPlatformId && encodingId == kUnicodeUcs4EncodingId) { - bestTable = i; - break; - } else if (platformId == kMicrosoftPlatformId && encodingId == kUnicodeBmpEncodingId) { - bestTable = i; - } else if (platformId == kUnicodePlatformId && - encodingId == kVariationSequencesEncodingId) { - uint32_t offset = readU32(cmap_data, kHeaderSize + i * kTableSize + kOffsetOffset); - if (offset <= cmap_size - 2 && readU16(cmap_data, offset) == 14) { - hasCmapFormat14Subtable = true; + + uint32_t bestTableOffset = kInvalidOffset; + uint16_t bestTableFormat = 0; + uint8_t bestTablePriority = kLowestPriority; + *has_cmap_format14_subtable = false; + for (uint32_t i = 0; i < numTables; ++i) { + const uint32_t tableHeadOffset = kHeaderSize + i * kTableSize; + const uint16_t platformId = readU16(cmap_data, tableHeadOffset + kPlatformIdOffset); + const uint16_t encodingId = readU16(cmap_data, tableHeadOffset + kEncodingIdOffset); + const uint32_t offset = readU32(cmap_data, tableHeadOffset + kOffsetOffset); + + if (offset > cmap_size - 2) { + continue; // Invalid table: not enough space to read. + } + const uint16_t format = readU16(cmap_data, offset + kFormatOffset); + + if (platformId == 0 /* Unicode */ && encodingId == 5 /* Variation Sequences */) { + if (!(*has_cmap_format14_subtable) && format == 14) { + *has_cmap_format14_subtable = true; + } else { + // Ignore the (0, 5) table if we have already seen another valid one or it's in a + // format we don't understand. + } + } else { + uint32_t length; + uint32_t language; + + if (format == 4) { + constexpr size_t lengthOffset = 2; + constexpr size_t languageOffset = 4; + constexpr size_t minTableSize = languageOffset + 2; + if (offset > cmap_size - minTableSize) { + continue; // Invalid table: not enough space to read. + } + length = readU16(cmap_data, offset + lengthOffset); + language = readU16(cmap_data, offset + languageOffset); + } else if (format == 12) { + constexpr size_t lengthOffset = 4; + constexpr size_t languageOffset = 8; + constexpr size_t minTableSize = languageOffset + 4; + if (offset > cmap_size - minTableSize) { + continue; // Invalid table: not enough space to read. + } + length = readU32(cmap_data, offset + lengthOffset); + language = readU32(cmap_data, offset + languageOffset); + } else { + continue; + } + + if (length > cmap_size - offset) { + continue; // Invalid table: table length is larger than whole cmap data size. + } + if (language != 0) { + // Unsupported or invalid table: this is either a subtable for the Macintosh + // platform (which we don't support), or an invalid subtable since language field + // should be zero for non-Macintosh subtables. + continue; + } + const uint8_t priority = getTablePriority(platformId, encodingId); + if (priority < bestTablePriority) { + bestTableOffset = offset; + bestTablePriority = priority; + bestTableFormat = format; } } + if (*has_cmap_format14_subtable && bestTablePriority == 0 /* highest priority */) { + // Already found the highest priority table and variation sequences table. No need to + // look at remaining tables. + break; + } } - *has_cmap_format14_subtable = hasCmapFormat14Subtable; -#ifdef VERBOSE_DEBUG - ALOGD("best table = %d\n", bestTable); -#endif - if (bestTable == kNoTable) { - return false; + if (bestTableOffset == kInvalidOffset) { + return SparseBitSet(); } - uint32_t offset = readU32(cmap_data, kHeaderSize + bestTable * kTableSize + kOffsetOffset); - if (offset > cmap_size - 2) { - return false; - } - uint16_t format = readU16(cmap_data, offset); - bool success = false; - const uint8_t* tableData = cmap_data + offset; - const size_t tableSize = cmap_size - offset; - if (format == 4) { + const uint8_t* tableData = cmap_data + bestTableOffset; + const size_t tableSize = cmap_size - bestTableOffset; + vector coverageVec; + bool success; + if (bestTableFormat == 4) { success = getCoverageFormat4(coverageVec, tableData, tableSize); - } else if (format == 12) { + } else { success = getCoverageFormat12(coverageVec, tableData, tableSize); } if (success) { - coverage.initFromRanges(&coverageVec.front(), coverageVec.size() >> 1); + return SparseBitSet(&coverageVec.front(), coverageVec.size() >> 1); + } else { + return SparseBitSet(); } -#ifdef VERBOSE_DEBUG - for (size_t i = 0; i < coverageVec.size(); i += 2) { - ALOGD("%x:%x\n", coverageVec[i], coverageVec[i + 1]); - } - ALOGD("success = %d", success); -#endif - return success; + } } // namespace minikin diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 492db1e4f4..39d374b99d 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -175,8 +175,7 @@ void FontFamily::computeCoverage() { ALOGE("Could not get cmap table size!\n"); return; } - // TODO: Error check? - CmapCoverage::getCoverage(mCoverage, cmapTable.get(), cmapTable.size(), &mHasVSTable); + mCoverage = CmapCoverage::getCoverage(cmapTable.get(), cmapTable.size(), &mHasVSTable); for (size_t i = 0; i < mFonts.size(); ++i) { std::unordered_set supportedAxes = mFonts[i].getSupportedAxesLocked(); diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp index 51557df9af..28ae710c18 100644 --- a/engine/src/flutter/libs/minikin/SparseBitSet.cpp +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -27,17 +27,6 @@ namespace minikin { const uint32_t SparseBitSet::kNotFound; -void SparseBitSet::clear() { - mMaxVal = 0; - if (mOwnIndicesAndBitmaps) { - delete[] mIndices; - delete[] mBitmaps; - mIndexSize = 0; - mBitmapSize = 0; - mOwnIndicesAndBitmaps = false; - } -} - uint32_t SparseBitSet::calcNumPages(const uint32_t* ranges, size_t nRanges) { bool haveZeroPage = false; uint32_t nonzeroPageEnd = 0; @@ -64,17 +53,12 @@ uint32_t SparseBitSet::calcNumPages(const uint32_t* ranges, size_t nRanges) { void SparseBitSet::initFromRanges(const uint32_t* ranges, size_t nRanges) { if (nRanges == 0) { - clear(); return; } mMaxVal = ranges[nRanges * 2 - 1]; - mIndexSize = (mMaxVal + kPageMask) >> kLogValuesPerPage; - uint32_t* indices = new uint32_t[mIndexSize]; + mIndices.reset(new uint32_t[(mMaxVal + kPageMask) >> kLogValuesPerPage]); uint32_t nPages = calcNumPages(ranges, nRanges); - mBitmapSize = nPages << (kLogValuesPerPage - kLogBitsPerEl); - element* bitmaps = new element[mBitmapSize]; - mOwnIndicesAndBitmaps = true; - memset(bitmaps, 0, nPages << (kLogValuesPerPage - 3)); + mBitmaps.reset(new element[nPages << (kLogValuesPerPage - kLogBitsPerEl)]()); mZeroPageIndex = noZeroPage; uint32_t nonzeroPageEnd = 0; uint32_t currentPage = 0; @@ -90,32 +74,30 @@ void SparseBitSet::initFromRanges(const uint32_t* ranges, size_t nRanges) { mZeroPageIndex = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl); } for (uint32_t j = nonzeroPageEnd; j < startPage; j++) { - indices[j] = mZeroPageIndex; + mIndices[j] = mZeroPageIndex; } } - indices[startPage] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl); + mIndices[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) { - bitmaps[index] |= (kElAllOnes >> (start & kElMask)) & + mBitmaps[index] |= (kElAllOnes >> (start & kElMask)) & (kElAllOnes << ((~end + 1) & kElMask)); } else { - bitmaps[index] |= kElAllOnes >> (start & kElMask); + mBitmaps[index] |= kElAllOnes >> (start & kElMask); for (size_t j = 1; j < nElements - 1; j++) { - bitmaps[index + j] = kElAllOnes; + mBitmaps[index + j] = kElAllOnes; } - bitmaps[index + nElements - 1] |= kElAllOnes << ((~end + 1) & kElMask); + mBitmaps[index + nElements - 1] |= kElAllOnes << ((~end + 1) & kElMask); } for (size_t j = startPage + 1; j < endPage + 1; j++) { - indices[j] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl); + mIndices[j] = (currentPage++) << (kLogValuesPerPage - kLogBitsPerEl); } nonzeroPageEnd = endPage + 1; } - mBitmaps = bitmaps; - mIndices = indices; } int SparseBitSet::CountLeadingZeros(element x) { diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk index d30c1062ce..b817c46961 100644 --- a/engine/src/flutter/tests/unittest/Android.mk +++ b/engine/src/flutter/tests/unittest/Android.mk @@ -19,8 +19,8 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_TEST_DATA := \ - data/BoldItalic.ttf \ data/Bold.ttf \ + data/BoldItalic.ttf \ data/ColorEmojiFont.ttf \ data/ColorTextMixedEmojiFont.ttf \ data/Emoji.ttf \ @@ -32,11 +32,14 @@ LOCAL_TEST_DATA := \ data/NoGlyphFont.ttf \ data/Regular.ttf \ data/TextEmojiFont.ttf \ + data/UnicodeBMPOnly.ttf \ + data/UnicodeBMPOnly2.ttf \ + data/UnicodeUCS4.ttf \ data/VariationSelectorTest-Regular.ttf \ data/ZhHans.ttf \ data/ZhHant.ttf \ + data/emoji.xml \ data/itemize.xml \ - data/emoji.xml LOCAL_TEST_DATA := $(foreach f,$(LOCAL_TEST_DATA),frameworks/minikin/tests:$(f)) @@ -66,6 +69,7 @@ LOCAL_SRC_FILES += \ ../util/FontTestUtils.cpp \ ../util/MinikinFontForTest.cpp \ ../util/UnicodeUtils.cpp \ + CmapCoverageTest.cpp \ EmojiTest.cpp \ FontCollectionTest.cpp \ FontCollectionItemizeTest.cpp \ diff --git a/engine/src/flutter/tests/unittest/CmapCoverageTest.cpp b/engine/src/flutter/tests/unittest/CmapCoverageTest.cpp new file mode 100644 index 0000000000..cbcc557a34 --- /dev/null +++ b/engine/src/flutter/tests/unittest/CmapCoverageTest.cpp @@ -0,0 +1,586 @@ +/* + * Copyright (C) 2017 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 + +#include +#include +#include +#include + +namespace minikin { + +size_t writeU16(uint16_t x, uint8_t* out, size_t offset) { + out[offset] = x >> 8; + out[offset + 1] = x; + return offset + 2; +} + +size_t writeI16(int16_t sx, uint8_t* out, size_t offset) { + return writeU16(static_cast(sx), out, offset); +} + +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; +} + +// Returns valid cmap format 4 table contents. All glyph ID is same value as code point. (e.g. +// 'a' (U+0061) is mapped to Glyph ID = 0x0061). +// 'range' should be specified with inclusive-inclusive values. +static std::vector buildCmapFormat4Table(const std::vector& ranges) { + uint16_t segmentCount = ranges.size() / 2 + 1 /* +1 for end marker */; + + const size_t numOfUint16 = + 8 /* format, length, languages, segCountX2, searchRange, entrySelector, rangeShift, pad */ + + segmentCount * 4 /* endCount, startCount, idRange, idRangeOffset */; + const size_t finalLength = sizeof(uint16_t) * numOfUint16; + + std::vector out(finalLength); + size_t head = 0; + head = writeU16(4, out.data(), head); // format + head = writeU16(finalLength, out.data(), head); // length + head = writeU16(0, out.data(), head); // langauge + + const uint16_t searchRange = 2 * (1 << static_cast(floor(log2(segmentCount)))); + + head = writeU16(segmentCount * 2, out.data(), head); // segCountX2 + head = writeU16(searchRange, out.data(), head); // searchRange + head = writeU16(__builtin_ctz(searchRange) - 1, out.data(), head); // entrySelector + head = writeU16(segmentCount * 2 - searchRange, out.data(), head); // rangeShift + + size_t endCountHead = head; + size_t startCountHead = head + segmentCount * sizeof(uint16_t) + 2 /* padding */; + size_t idDeltaHead = startCountHead + segmentCount * sizeof(uint16_t); + size_t idRangeOffsetHead = idDeltaHead + segmentCount * sizeof(uint16_t); + + for (size_t i = 0; i < ranges.size() / 2; ++i) { + const uint16_t begin = ranges[i * 2]; + const uint16_t end = ranges[i * 2 + 1]; + startCountHead = writeU16(begin, out.data(), startCountHead); + endCountHead = writeU16(end, out.data(), endCountHead); + // map glyph ID as the same value of the code point. + idDeltaHead = writeU16(0, out.data(), idDeltaHead); + idRangeOffsetHead = writeU16(0 /* we don't use this */, out.data(), idRangeOffsetHead); + } + + // fill end marker + endCountHead = writeU16(0xFFFF, out.data(), endCountHead); + startCountHead = writeU16(0xFFFF, out.data(), startCountHead); + idDeltaHead = writeU16(1, out.data(), idDeltaHead); + idRangeOffsetHead = writeU16(0, out.data(), idRangeOffsetHead); + LOG_ALWAYS_FATAL_IF(endCountHead > finalLength); + LOG_ALWAYS_FATAL_IF(startCountHead > finalLength); + LOG_ALWAYS_FATAL_IF(idDeltaHead > finalLength); + LOG_ALWAYS_FATAL_IF(idRangeOffsetHead != finalLength); + return out; +} + +// Returns valid cmap format 4 table contents. All glyph ID is same value as code point. (e.g. +// 'a' (U+0061) is mapped to Glyph ID = 0x0061). +// 'range' should be specified with inclusive-inclusive values. +static std::vector buildCmapFormat12Table(const std::vector& ranges) { + uint32_t numGroups = ranges.size() / 2; + + const size_t finalLength = 2 /* format */ + 2 /* reserved */ + 4 /* length */ + + 4 /* languages */ + 4 /* numGroups */ + 12 /* size of a group */ * numGroups; + + std::vector out(finalLength); + size_t head = 0; + head = writeU16(12, out.data(), head); // format + head = writeU16(0, out.data(), head); // reserved + head = writeU32(finalLength, out.data(), head); // length + head = writeU32(0, out.data(), head); // langauge + head = writeU32(numGroups, out.data(), head); // numGroups + + for (uint32_t i = 0; i < numGroups; ++i) { + const uint32_t start = ranges[2 * i]; + const uint32_t end = ranges[2 * i + 1]; + head = writeU32(start, out.data(), head); + head = writeU32(end, out.data(), head); + // map glyph ID as the same value of the code point. + // TODO: Use glyph IDs lower than 65535. + // Cmap can store 32 bit glyph ID but due to the size of numGlyph, a font file can contain + // up to 65535 glyphs in a file. + head = writeU32(start, out.data(), head); + } + + LOG_ALWAYS_FATAL_IF(head != finalLength); + return out; +} + +class CmapBuilder { +public: + static constexpr size_t kEncodingTableHead = 4; + static constexpr size_t kEncodingTableSize = 8; + + CmapBuilder(int numTables) : mNumTables(numTables), mCurrentTableIndex(0) { + const size_t headerSize = + 2 /* version */ + 2 /* numTables */ + kEncodingTableSize * numTables; + out.resize(headerSize); + writeU16(0, out.data(), 0); + writeU16(numTables, out.data(), 2); + } + + void appendTable(uint16_t platformId, uint16_t encodingId, + const std::vector& table) { + appendEncodingTable(platformId, encodingId, out.size()); + out.insert(out.end(), table.begin(), table.end()); + } + + // TODO: Introduce Format 14 table builder. + + std::vector build() { + LOG_ALWAYS_FATAL_IF(mCurrentTableIndex != mNumTables); + return out; + } + + // Helper functions. + static std::vector buildSingleFormat4Cmap(uint16_t platformId, uint16_t encodingId, + const std::vector& ranges) { + CmapBuilder builder(1); + builder.appendTable(platformId, encodingId, buildCmapFormat4Table(ranges)); + return builder.build(); + } + + static std::vector buildSingleFormat12Cmap(uint16_t platformId, uint16_t encodingId, + const std::vector& ranges) { + CmapBuilder builder(1); + builder.appendTable(platformId, encodingId, buildCmapFormat12Table(ranges)); + return builder.build(); + } + +private: + void appendEncodingTable(uint16_t platformId, uint16_t encodingId, uint32_t offset) { + LOG_ALWAYS_FATAL_IF(mCurrentTableIndex == mNumTables); + + const size_t currentEncodingTableHead = + kEncodingTableHead + mCurrentTableIndex * kEncodingTableSize; + size_t head = writeU16(platformId, out.data(), currentEncodingTableHead); + head = writeU16(encodingId, out.data(), head); + head = writeU32(offset, out.data(), head); + LOG_ALWAYS_FATAL_IF((head - currentEncodingTableHead) != kEncodingTableSize); + mCurrentTableIndex++; + } + + int mNumTables; + int mCurrentTableIndex; + std::vector out; +}; + +TEST(CmapCoverageTest, SingleFormat4_brokenCmap) { + bool has_cmap_format_14_subtable = false; + { + SCOPED_TRACE("Reading beyond buffer size - Too small cmap size"); + std::vector cmap = + CmapBuilder::buildSingleFormat4Cmap(0, 0, std::vector({'a', 'a'})); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), 3 /* too small */, &has_cmap_format_14_subtable); + EXPECT_EQ(0U, coverage.length()); + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Reading beyond buffer size - space needed for tables goes beyond cmap size"); + std::vector cmap = + CmapBuilder::buildSingleFormat4Cmap(0, 0, std::vector({'a', 'a'})); + + writeU16(1000, cmap.data(), 2 /* offset of num tables in cmap header */); + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_EQ(0U, coverage.length()); + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Reading beyond buffer size - Invalid offset in encoding table"); + std::vector cmap = + CmapBuilder::buildSingleFormat4Cmap(0, 0, std::vector({'a', 'a'})); + + writeU16(1000, cmap.data(), 8 /* offset of the offset in the first encoding record */); + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_EQ(0U, coverage.length()); + EXPECT_FALSE(has_cmap_format_14_subtable); + } +} + +TEST(CmapCoverageTest, SingleFormat4) { + bool has_cmap_format_14_subtable = false; + struct TestCast { + std::string testTitle; + uint16_t platformId; + uint16_t encodingId; + } TEST_CASES[] = { + { "Platform 0, Encoding 0", 0, 0 }, + { "Platform 0, Encoding 1", 0, 1 }, + { "Platform 0, Encoding 2", 0, 2 }, + { "Platform 0, Encoding 3", 0, 3 }, + { "Platform 3, Encoding 1", 3, 1 }, + }; + + for (const auto& testCase : TEST_CASES) { + SCOPED_TRACE(testCase.testTitle.c_str()); + std::vector cmap = CmapBuilder::buildSingleFormat4Cmap( + testCase.platformId, testCase.encodingId, std::vector({'a', 'a'})); + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); + EXPECT_FALSE(coverage.get('b')); + EXPECT_FALSE(has_cmap_format_14_subtable); + } +} + +TEST(CmapCoverageTest, SingleFormat12) { + bool has_cmap_format_14_subtable = false; + + struct TestCast { + std::string testTitle; + uint16_t platformId; + uint16_t encodingId; + } TEST_CASES[] = { + { "Platform 0, Encoding 4", 0, 4 }, + { "Platform 0, Encoding 6", 0, 6 }, + { "Platform 3, Encoding 10", 3, 10 }, + }; + + for (const auto& testCase : TEST_CASES) { + SCOPED_TRACE(testCase.testTitle.c_str()); + std::vector cmap = CmapBuilder::buildSingleFormat12Cmap( + testCase.platformId, testCase.encodingId, std::vector({'a', 'a'})); + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); + EXPECT_FALSE(coverage.get('b')); + EXPECT_FALSE(has_cmap_format_14_subtable); + } +} + +TEST(CmapCoverageTest, notSupportedEncodings) { + bool has_cmap_format_14_subtable = false; + + struct TestCast { + std::string testTitle; + uint16_t platformId; + uint16_t encodingId; + } TEST_CASES[] = { + // Any encodings with platform 2 is not supported. + { "Platform 2, Encoding 0", 2, 0 }, + { "Platform 2, Encoding 1", 2, 1 }, + { "Platform 2, Encoding 2", 2, 2 }, + { "Platform 2, Encoding 3", 2, 3 }, + // UCS-2 or UCS-4 are supported on Platform == 3. Others are not supported. + { "Platform 3, Encoding 0", 3, 0 }, // Symbol + { "Platform 3, Encoding 2", 3, 2 }, // ShiftJIS + { "Platform 3, Encoding 3", 3, 3 }, // RPC + { "Platform 3, Encoding 4", 3, 4 }, // Big5 + { "Platform 3, Encoding 5", 3, 5 }, // Wansung + { "Platform 3, Encoding 6", 3, 6 }, // Johab + { "Platform 3, Encoding 7", 3, 7 }, // Reserved + { "Platform 3, Encoding 8", 3, 8 }, // Reserved + { "Platform 3, Encoding 9", 3, 9 }, // Reserved + // Uknown platforms + { "Platform 4, Encoding 0", 4, 0 }, + { "Platform 5, Encoding 1", 5, 1 }, + { "Platform 6, Encoding 0", 6, 0 }, + { "Platform 7, Encoding 1", 7, 1 }, + }; + + for (const auto& testCase : TEST_CASES) { + SCOPED_TRACE(testCase.testTitle.c_str()); + CmapBuilder builder(1); + std::vector cmap = CmapBuilder::buildSingleFormat4Cmap( + testCase.platformId, testCase.encodingId, std::vector({'a', 'a'})); + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_EQ(0U, coverage.length()); + EXPECT_FALSE(has_cmap_format_14_subtable); + } +} + +TEST(CmapCoverageTest, brokenFormat4Table) { + bool has_cmap_format_14_subtable = false; + { + SCOPED_TRACE("Too small table cmap size"); + std::vector table = buildCmapFormat4Table(std::vector({'a', 'a'})); + table.resize(2); // Remove trailing data. + + CmapBuilder builder(1); + builder.appendTable(0, 0, table); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_EQ(0U, coverage.length()); + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Too many segments"); + std::vector table = buildCmapFormat4Table(std::vector({'a', 'a'})); + writeU16(5000, table.data(), 6 /* segment count offset */); // 5000 segments. + CmapBuilder builder(1); + builder.appendTable(0, 0, table); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_EQ(0U, coverage.length()); + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Inversed range"); + std::vector table = buildCmapFormat4Table(std::vector({'b', 'b'})); + // Put smaller end code point to inverse the range. + writeU16('a', table.data(), 14 /* the first element of endCount offset */); + CmapBuilder builder(1); + builder.appendTable(0, 0, table); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_EQ(0U, coverage.length()); + EXPECT_FALSE(has_cmap_format_14_subtable); + } +} + +TEST(CmapCoverageTest, brokenFormat12Table) { + bool has_cmap_format_14_subtable = false; + { + SCOPED_TRACE("Too small cmap size"); + std::vector table = buildCmapFormat12Table(std::vector({'a', 'a'})); + table.resize(2); // Remove trailing data. + + CmapBuilder builder(1); + builder.appendTable(0, 0, table); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_EQ(0U, coverage.length()); + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Too many groups"); + std::vector table = buildCmapFormat12Table(std::vector({'a', 'a'})); + writeU32(5000, table.data(), 12 /* num group offset */); // 5000 groups. + + CmapBuilder builder(1); + builder.appendTable(0, 0, table); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_EQ(0U, coverage.length()); + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Inversed range."); + std::vector table = buildCmapFormat12Table(std::vector({'a', 'a'})); + // Put larger start code point to inverse the range. + writeU32('b', table.data(), 16 /* start code point offset in the first group */); + + CmapBuilder builder(1); + builder.appendTable(0, 0, table); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_EQ(0U, coverage.length()); + EXPECT_FALSE(has_cmap_format_14_subtable); + } +} + +TEST(CmapCoverageTest, TableSelection_Priority) { + bool has_cmap_format_14_subtable = false; + std::vector highestFormat12Table = + buildCmapFormat12Table(std::vector({'a', 'a'})); + std::vector highestFormat4Table = + buildCmapFormat4Table(std::vector({'a', 'a'})); + std::vector format4 = buildCmapFormat4Table(std::vector({'b', 'b'})); + std::vector format12 = buildCmapFormat12Table(std::vector({'b', 'b'})); + + { + SCOPED_TRACE("(platform, encoding) = (3, 10) is the highest priority."); + + struct LowerPriorityTable { + uint16_t platformId; + uint16_t encodingId; + const std::vector& table; + } LOWER_PRIORITY_TABLES[] = { + { 0, 0, format4 }, + { 0, 1, format4 }, + { 0, 2, format4 }, + { 0, 3, format4 }, + { 0, 4, format12 }, + { 0, 6, format12 }, + { 3, 1, format4 }, + }; + + for (const auto& table : LOWER_PRIORITY_TABLES) { + CmapBuilder builder(2); + builder.appendTable(table.platformId, table.encodingId, table.table); + builder.appendTable(3, 10, highestFormat12Table); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); // comes from highest table + EXPECT_FALSE(coverage.get('b')); // should not use other table. + EXPECT_FALSE(has_cmap_format_14_subtable); + } + } + { + SCOPED_TRACE("(platform, encoding) = (3, 1) case"); + + struct LowerPriorityTable { + uint16_t platformId; + uint16_t encodingId; + const std::vector& table; + } LOWER_PRIORITY_TABLES[] = { + { 0, 0, format4 }, + { 0, 1, format4 }, + { 0, 2, format4 }, + { 0, 3, format4 }, + }; + + for (const auto& table : LOWER_PRIORITY_TABLES) { + CmapBuilder builder(2); + builder.appendTable(table.platformId, table.encodingId, table.table); + builder.appendTable(3, 1, highestFormat4Table); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); // comes from highest table + EXPECT_FALSE(coverage.get('b')); // should not use other table. + EXPECT_FALSE(has_cmap_format_14_subtable); + } + } +} + +TEST(CmapCoverageTest, TableSelection_SkipBrokenFormat4Table) { + SparseBitSet coverage; + bool has_cmap_format_14_subtable = false; + std::vector validTable = + buildCmapFormat4Table(std::vector({'a', 'a'})); + { + SCOPED_TRACE("Unsupported format"); + CmapBuilder builder(2); + std::vector table = + buildCmapFormat4Table(std::vector({'b', 'b'})); + writeU16(0, table.data(), 0 /* format offset */); + builder.appendTable(3, 1, table); + builder.appendTable(0, 0, validTable); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); // comes from valid table + EXPECT_FALSE(coverage.get('b')); // should not use invalid table. + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Invalid language"); + CmapBuilder builder(2); + std::vector table = + buildCmapFormat4Table(std::vector({'b', 'b'})); + writeU16(1, table.data(), 4 /* language offset */); + builder.appendTable(3, 1, table); + builder.appendTable(0, 0, validTable); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); // comes from valid table + EXPECT_FALSE(coverage.get('b')); // should not use invalid table. + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Invalid length"); + CmapBuilder builder(2); + std::vector table = + buildCmapFormat4Table(std::vector({'b', 'b'})); + writeU16(5000, table.data(), 2 /* length offset */); + builder.appendTable(3, 1, table); + builder.appendTable(0, 0, validTable); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); // comes from valid table + EXPECT_FALSE(coverage.get('b')); // should not use invalid table. + EXPECT_FALSE(has_cmap_format_14_subtable); + } +} + +TEST(CmapCoverageTest, TableSelection_SkipBrokenFormat12Table) { + SparseBitSet coverage; + bool has_cmap_format_14_subtable = false; + std::vector validTable = + buildCmapFormat12Table(std::vector({'a', 'a'})); + { + SCOPED_TRACE("Unsupported format"); + CmapBuilder builder(2); + std::vector table = + buildCmapFormat12Table(std::vector({'b', 'b'})); + writeU16(0, table.data(), 0 /* format offset */); + builder.appendTable(3, 1, table); + builder.appendTable(0, 0, validTable); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); // comes from valid table + EXPECT_FALSE(coverage.get('b')); // should not use invalid table. + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Invalid language"); + CmapBuilder builder(2); + std::vector table = + buildCmapFormat12Table(std::vector({'b', 'b'})); + writeU32(1, table.data(), 8 /* language offset */); + builder.appendTable(3, 1, table); + builder.appendTable(0, 0, validTable); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); // comes from valid table + EXPECT_FALSE(coverage.get('b')); // should not use invalid table. + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Invalid length"); + CmapBuilder builder(2); + std::vector table = + buildCmapFormat12Table(std::vector({'b', 'b'})); + writeU32(5000, table.data(), 4 /* length offset */); + builder.appendTable(3, 1, table); + builder.appendTable(0, 0, validTable); + std::vector cmap = builder.build(); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); // comes from valid table + EXPECT_FALSE(coverage.get('b')); // should not use invalid table. + EXPECT_FALSE(has_cmap_format_14_subtable); + } +} + +} // namespace minikin diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 90cc794083..5a775a3587 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -45,6 +45,12 @@ static FontLanguage createFontLanguageWithoutICUSanitization(const std::string& return FontLanguage(input.c_str(), input.size()); } +std::shared_ptr makeFamily(const std::string& fontPath) { + std::shared_ptr font(new MinikinFontForTest(fontPath)); + return std::make_shared( + std::vector({Font(font, FontStyle())})); +} + TEST_F(FontLanguageTest, basicTests) { FontLanguage defaultLang; FontLanguage emptyLang("", 0); @@ -596,15 +602,8 @@ TEST_F(FontFamilyTest, createFamilyWithVariationTest) { const char kMultiAxisFont[] = kTestFontDir "/MultiAxis.ttf"; const char kNoAxisFont[] = kTestFontDir "/Regular.ttf"; - std::shared_ptr multiAxisFont(new MinikinFontForTest(kMultiAxisFont)); - std::shared_ptr multiAxisFamily( - std::shared_ptr(new FontFamily( - std::vector({Font(multiAxisFont, FontStyle())})))); - - std::shared_ptr noAxisFont(new MinikinFontForTest(kNoAxisFont)); - std::shared_ptr noAxisFamily( - std::shared_ptr(new FontFamily( - std::vector({Font(noAxisFont, FontStyle())})))); + std::shared_ptr multiAxisFamily = makeFamily(kMultiAxisFont); + std::shared_ptr noAxisFamily = makeFamily(kNoAxisFont); { // Do not ceate new instance if none of variations are specified. @@ -656,4 +655,31 @@ TEST_F(FontFamilyTest, createFamilyWithVariationTest) { } } +TEST_F(FontFamilyTest, coverageTableSelectionTest) { + // This font supports U+0061. The cmap subtable is format 4 and its platform ID is 0 and + // encoding ID is 1. + const char kUnicodeEncoding1Font[] = kTestFontDir "UnicodeBMPOnly.ttf"; + + // This font supports U+0061. The cmap subtable is format 4 and its platform ID is 0 and + // encoding ID is 3. + const char kUnicodeEncoding3Font[] = kTestFontDir "UnicodeBMPOnly2.ttf"; + + // This font has both cmap format 4 subtable which platform ID is 0 and encoding ID is 1 + // and cmap format 14 subtable which platform ID is 0 and encoding ID is 10. + // U+0061 is listed in both subtable but U+1F926 is only listed in latter. + const char kUnicodeEncoding4Font[] = kTestFontDir "UnicodeUCS4.ttf"; + + std::shared_ptr unicodeEnc1Font = makeFamily(kUnicodeEncoding1Font); + std::shared_ptr unicodeEnc3Font = makeFamily(kUnicodeEncoding3Font); + std::shared_ptr unicodeEnc4Font = makeFamily(kUnicodeEncoding4Font); + + android::AutoMutex _l(gMinikinLock); + + EXPECT_TRUE(unicodeEnc1Font->hasGlyph(0x0061, 0)); + EXPECT_TRUE(unicodeEnc3Font->hasGlyph(0x0061, 0)); + EXPECT_TRUE(unicodeEnc4Font->hasGlyph(0x0061, 0)); + + EXPECT_TRUE(unicodeEnc4Font->hasGlyph(0x1F926, 0)); +} + } // namespace minikin diff --git a/engine/src/flutter/tests/unittest/SparseBitSetTest.cpp b/engine/src/flutter/tests/unittest/SparseBitSetTest.cpp index cfb437f3f5..39c9e1b912 100644 --- a/engine/src/flutter/tests/unittest/SparseBitSetTest.cpp +++ b/engine/src/flutter/tests/unittest/SparseBitSetTest.cpp @@ -32,8 +32,7 @@ TEST(SparseBitSetTest, randomTest) { range.push_back((range.back() - 1) + distribution(mt)); } - SparseBitSet bitset; - bitset.initFromRanges(range.data(), range.size() / 2); + SparseBitSet bitset(range.data(), range.size() / 2); uint32_t ch = 0; for (size_t i = 0; i < range.size() / 2; ++i) { From 97ee89d60507006b2988734e7fd44d9d16f99fb1 Mon Sep 17 00:00:00 2001 From: Seigo Nonaka Date: Fri, 14 Apr 2017 11:08:12 -0700 Subject: [PATCH 264/364] Reduce heap memory in minikin. This patch reduces about 73 kB memory. The original SparseBitSet could contain full 32bit integers, but all of that is not necessary for Unicode code points. By reducing the supported range to up to Unicode maximum, U+10FFFF, we can save extra memory. SparseBitSet holds 256-bit sliced pages and indices of them. Previously, we needed to hold up to 2^24-1 pages for keeping 32-bit integers. This CL limits the number of pages to 2^16-1 (65535), so that SparseBitSet only supports 24-bit integers now, but this is sufficient for keeping all Unicode code points. With this change, we can change the index integer type from uint32_t to uint16_t. Bug: 37357593 Test: minikin_tests passes Change-Id: I462cc27927752c942ac5da0bf303a5afb81b87a3 --- .../flutter/include/minikin/SparseBitSet.h | 7 ++-- .../src/flutter/libs/minikin/CmapCoverage.cpp | 11 ++++++ .../flutter/libs/minikin/MinikinInternal.h | 2 + .../src/flutter/libs/minikin/SparseBitSet.cpp | 10 +++-- .../tests/unittest/CmapCoverageTest.cpp | 38 +++++++++++++++++++ 5 files changed, 62 insertions(+), 6 deletions(-) diff --git a/engine/src/flutter/include/minikin/SparseBitSet.h b/engine/src/flutter/include/minikin/SparseBitSet.h index 91288988ac..62aece209d 100644 --- a/engine/src/flutter/include/minikin/SparseBitSet.h +++ b/engine/src/flutter/include/minikin/SparseBitSet.h @@ -68,6 +68,7 @@ public: private: void initFromRanges(const uint32_t* ranges, size_t nRanges); + static const uint32_t kMaximumCapacity = 0xFFFFFF; static const int kLogValuesPerPage = 8; static const int kPageMask = (1 << kLogValuesPerPage) - 1; static const int kLogBytesPerEl = 2; @@ -77,16 +78,16 @@ private: typedef uint32_t element; static const element kElAllOnes = ~((element)0); static const element kElFirst = ((element)1) << kElMask; - static const uint32_t noZeroPage = ~0u; + static const uint16_t noZeroPage = 0xFFFF; static uint32_t calcNumPages(const uint32_t* ranges, size_t nRanges); static int CountLeadingZeros(element x); uint32_t mMaxVal; - std::unique_ptr mIndices; + std::unique_ptr mIndices; std::unique_ptr mBitmaps; - uint32_t mZeroPageIndex; + uint16_t mZeroPageIndex; // Forbid copy and assign. SparseBitSet(const SparseBitSet&) = delete; diff --git a/engine/src/flutter/libs/minikin/CmapCoverage.cpp b/engine/src/flutter/libs/minikin/CmapCoverage.cpp index ed053da788..a953304e5b 100644 --- a/engine/src/flutter/libs/minikin/CmapCoverage.cpp +++ b/engine/src/flutter/libs/minikin/CmapCoverage.cpp @@ -25,6 +25,7 @@ using std::vector; #include #include +#include "MinikinInternal.h" namespace minikin { @@ -127,6 +128,16 @@ static bool getCoverageFormat12(vector& coverage, const uint8_t* data, android_errorWriteLog(0x534e4554, "26413177"); return false; } + + // No need to read outside of Unicode code point range. + if (start > MAX_UNICODE_CODE_POINT) { + return true; + } + if (end > MAX_UNICODE_CODE_POINT) { + // file is inclusive, vector is exclusive + addRange(coverage, start, MAX_UNICODE_CODE_POINT + 1); + return true; + } addRange(coverage, start, end + 1); // file is inclusive, vector is exclusive } return true; diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index 250f63d74b..1ed0816188 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -38,6 +38,8 @@ void assertMinikinLocked(); hb_blob_t* getFontTable(const MinikinFont* minikinFont, uint32_t tag); +constexpr uint32_t MAX_UNICODE_CODE_POINT = 0x10FFFF; + // An RAII wrapper for hb_blob_t class HbBlob { public: diff --git a/engine/src/flutter/libs/minikin/SparseBitSet.cpp b/engine/src/flutter/libs/minikin/SparseBitSet.cpp index 28ae710c18..9fad6a0cc7 100644 --- a/engine/src/flutter/libs/minikin/SparseBitSet.cpp +++ b/engine/src/flutter/libs/minikin/SparseBitSet.cpp @@ -55,8 +55,12 @@ void SparseBitSet::initFromRanges(const uint32_t* ranges, size_t nRanges) { if (nRanges == 0) { return; } - mMaxVal = ranges[nRanges * 2 - 1]; - mIndices.reset(new uint32_t[(mMaxVal + kPageMask) >> kLogValuesPerPage]); + const uint32_t maxVal = ranges[nRanges * 2 - 1]; + if (maxVal >= kMaximumCapacity) { + return; + } + mMaxVal = maxVal; + mIndices.reset(new uint16_t[(mMaxVal + kPageMask) >> kLogValuesPerPage]); uint32_t nPages = calcNumPages(ranges, nRanges); mBitmaps.reset(new element[nPages << (kLogValuesPerPage - kLogBitsPerEl)]()); mZeroPageIndex = noZeroPage; @@ -124,7 +128,7 @@ uint32_t SparseBitSet::nextSetBit(uint32_t fromIndex) const { } uint32_t maxPage = (mMaxVal + kPageMask) >> kLogValuesPerPage; for (uint32_t page = fromPage + 1; page < maxPage; page++) { - uint32_t index = mIndices[page]; + uint16_t index = mIndices[page]; if (index == mZeroPageIndex) { continue; } diff --git a/engine/src/flutter/tests/unittest/CmapCoverageTest.cpp b/engine/src/flutter/tests/unittest/CmapCoverageTest.cpp index cbcc557a34..dd61940868 100644 --- a/engine/src/flutter/tests/unittest/CmapCoverageTest.cpp +++ b/engine/src/flutter/tests/unittest/CmapCoverageTest.cpp @@ -271,6 +271,34 @@ TEST(CmapCoverageTest, SingleFormat12) { } } +TEST(CmapCoverageTest, Format12_beyondTheUnicodeLimit) { + bool has_cmap_format_14_subtable = false; + { + SCOPED_TRACE("Starting range is out of Unicode code point. Should be ignored."); + std::vector cmap = CmapBuilder::buildSingleFormat12Cmap( + 0, 0, std::vector({'a', 'a', 0x110000, 0x110000})); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); + EXPECT_FALSE(coverage.get(0x110000)); + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Ending range is out of Unicode code point. Should be ignored."); + std::vector cmap = CmapBuilder::buildSingleFormat12Cmap( + 0, 0, std::vector({'a', 'a', 0x10FF00, 0x110000})); + + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_TRUE(coverage.get('a')); + EXPECT_TRUE(coverage.get(0x10FF00)); + EXPECT_TRUE(coverage.get(0x10FFFF)); + EXPECT_FALSE(coverage.get(0x110000)); + EXPECT_FALSE(has_cmap_format_14_subtable); + } +} + TEST(CmapCoverageTest, notSupportedEncodings) { bool has_cmap_format_14_subtable = false; @@ -398,6 +426,16 @@ TEST(CmapCoverageTest, brokenFormat12Table) { builder.appendTable(0, 0, table); std::vector cmap = builder.build(); + SparseBitSet coverage = CmapCoverage::getCoverage( + cmap.data(), cmap.size(), &has_cmap_format_14_subtable); + EXPECT_EQ(0U, coverage.length()); + EXPECT_FALSE(has_cmap_format_14_subtable); + } + { + SCOPED_TRACE("Too large code point"); + std::vector cmap = CmapBuilder::buildSingleFormat12Cmap( + 0, 0, std::vector({0x110000, 0x110000})); + SparseBitSet coverage = CmapCoverage::getCoverage( cmap.data(), cmap.size(), &has_cmap_format_14_subtable); EXPECT_EQ(0U, coverage.length()); From 716f07be94544d97039fbcb01df876e092d61d37 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Fri, 2 Dec 2016 17:59:14 -0800 Subject: [PATCH 265/364] Convert frameworks/minikin to Android.bp See build/soong/README.md for more information. Test: m -j checkbuild Change-Id: I71d3406054b35dd4e8ae30f46eec6cef77eef160 --- engine/src/flutter/Android.bp | 10 ++ engine/src/flutter/app/Android.bp | 30 ++++++ engine/src/flutter/app/Android.mk | 36 -------- engine/src/flutter/libs/minikin/Android.bp | 78 ++++++++++++++++ engine/src/flutter/libs/minikin/Android.mk | 102 --------------------- 5 files changed, 118 insertions(+), 138 deletions(-) create mode 100644 engine/src/flutter/Android.bp create mode 100644 engine/src/flutter/app/Android.bp delete mode 100644 engine/src/flutter/app/Android.mk create mode 100644 engine/src/flutter/libs/minikin/Android.bp delete mode 100644 engine/src/flutter/libs/minikin/Android.mk diff --git a/engine/src/flutter/Android.bp b/engine/src/flutter/Android.bp new file mode 100644 index 0000000000..26d5027683 --- /dev/null +++ b/engine/src/flutter/Android.bp @@ -0,0 +1,10 @@ +cc_library_headers { + name: "libminikin_headers", + host_supported: true, + export_include_dirs: ["include"], +} + +subdirs = [ + "app", + "libs/minikin", +] diff --git a/engine/src/flutter/app/Android.bp b/engine/src/flutter/app/Android.bp new file mode 100644 index 0000000000..e8085c1f3e --- /dev/null +++ b/engine/src/flutter/app/Android.bp @@ -0,0 +1,30 @@ +// 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. + +// see how_to_run.txt for instructions on running these tests + +cc_binary_host { + name: "hyphtool", + + static_libs: ["libminikin"], + + // Shared libraries which are dependencies of minikin; these are not automatically + // pulled in by the build system (and thus sadly must be repeated). + shared_libs: [ + "liblog", + "libicuuc", + ], + + srcs: ["HyphTool.cpp"], +} diff --git a/engine/src/flutter/app/Android.mk b/engine/src/flutter/app/Android.mk deleted file mode 100644 index 23305b7b4c..0000000000 --- a/engine/src/flutter/app/Android.mk +++ /dev/null @@ -1,36 +0,0 @@ -# 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. - -# see how_to_run.txt for instructions on running these tests - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_MODULE := hyphtool -LOCAL_MODULE_TAGS := optional - -LOCAL_STATIC_LIBRARIES := libminikin_host - -# Shared libraries which are dependencies of minikin; these are not automatically -# pulled in by the build system (and thus sadly must be repeated). - -LOCAL_SHARED_LIBRARIES := \ - liblog \ - libicuuc - -LOCAL_SRC_FILES += \ - HyphTool.cpp - -include $(BUILD_HOST_EXECUTABLE) diff --git a/engine/src/flutter/libs/minikin/Android.bp b/engine/src/flutter/libs/minikin/Android.bp new file mode 100644 index 0000000000..ef721ea80b --- /dev/null +++ b/engine/src/flutter/libs/minikin/Android.bp @@ -0,0 +1,78 @@ +// Copyright (C) 2013 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +cc_library { + name: "libminikin", + host_supported: true, + srcs: [ + "Hyphenator.cpp", + ], + target: { + android: { + srcs: [ + "CmapCoverage.cpp", + "Emoji.cpp", + "FontCollection.cpp", + "FontFamily.cpp", + "FontLanguage.cpp", + "FontLanguageListCache.cpp", + "FontUtils.cpp", + "GraphemeBreak.cpp", + "HbFontCache.cpp", + "Layout.cpp", + "LayoutUtils.cpp", + "LineBreaker.cpp", + "Measurement.cpp", + "MinikinInternal.cpp", + "MinikinFont.cpp", + "SparseBitSet.cpp", + "WordBreaker.cpp", + ], + shared_libs: [ + "libharfbuzz_ng", + "libft2", + "libz", + "libutils", + ], + // TODO: clean up Minikin so it doesn't need the freetype include + export_shared_lib_headers: ["libft2"], + }, + }, + cppflags: [ + "-Werror", + "-Wall", + "-Wextra", + ], + product_variables: { + debuggable: { + // Enable race detection on eng and userdebug build. + cppflags: ["-DENABLE_RACE_DETECTION"], + }, + }, + shared_libs: [ + "liblog", + "libicuuc", + ], + header_libs: ["libminikin_headers"], + export_header_lib_headers: ["libminikin_headers"], + + clang: true, + sanitize: { + misc_undefined: [ + "signed-integer-overflow", + // b/26432628. + //"unsigned-integer-overflow", + ], + }, +} diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk deleted file mode 100644 index bb6234a123..0000000000 --- a/engine/src/flutter/libs/minikin/Android.mk +++ /dev/null @@ -1,102 +0,0 @@ -# Copyright (C) 2013 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -include $(CLEAR_VARS) -minikin_src_files := \ - CmapCoverage.cpp \ - Emoji.cpp \ - FontCollection.cpp \ - FontFamily.cpp \ - FontLanguage.cpp \ - FontLanguageListCache.cpp \ - FontUtils.cpp \ - GraphemeBreak.cpp \ - HbFontCache.cpp \ - Hyphenator.cpp \ - Layout.cpp \ - LayoutUtils.cpp \ - LineBreaker.cpp \ - Measurement.cpp \ - MinikinInternal.cpp \ - MinikinFont.cpp \ - SparseBitSet.cpp \ - WordBreaker.cpp - -minikin_c_includes := \ - external/harfbuzz_ng/src \ - frameworks/minikin/include \ - $(intermediates) - -minikin_shared_libraries := \ - libharfbuzz_ng \ - libft2 \ - liblog \ - libz \ - libicuuc \ - libutils - -ifneq (,$(filter userdebug eng, $(TARGET_BUILD_VARIANT))) -# Enable race detection on eng and userdebug build. -enable_race_detection := -DENABLE_RACE_DETECTION -else -enable_race_detection := -endif - -LOCAL_MODULE := libminikin -LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include -LOCAL_SRC_FILES := $(minikin_src_files) -LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) -LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) -LOCAL_CLANG := true -LOCAL_SANITIZE := signed-integer-overflow -# b/26432628. -#LOCAL_SANITIZE += unsigned-integer-overflow - -include $(BUILD_SHARED_LIBRARY) - -include $(CLEAR_VARS) - -LOCAL_MODULE := libminikin -LOCAL_MODULE_TAGS := optional -LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include -LOCAL_SRC_FILES := $(minikin_src_files) -LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) -LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) -LOCAL_CLANG := true -LOCAL_SANITIZE := signed-integer-overflow -# b/26432628. -#LOCAL_SANITIZE += unsigned-integer-overflow - -include $(BUILD_STATIC_LIBRARY) - -include $(CLEAR_VARS) - -# Reduced library (currently just hyphenation) for host - -LOCAL_MODULE := libminikin_host -LOCAL_MODULE_TAGS := optional -LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include -LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) -LOCAL_SHARED_LIBRARIES := liblog libicuuc - -LOCAL_SRC_FILES := Hyphenator.cpp - -include $(BUILD_HOST_STATIC_LIBRARY) From befc483dfb21b58a9383541742598eda614d6bad Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Fri, 2 Dec 2016 17:59:14 -0800 Subject: [PATCH 266/364] Convert frameworks/minikin to Android.bp See build/soong/README.md for more information. Test: m -j checkbuild Change-Id: I71d3406054b35dd4e8ae30f46eec6cef77eef160 Merged-In: I71d3406054b35dd4e8ae30f46eec6cef77eef160 --- engine/src/flutter/Android.bp | 11 ++ engine/src/flutter/app/Android.bp | 30 +++++ engine/src/flutter/app/Android.mk | 36 ------ engine/src/flutter/libs/minikin/Android.bp | 89 ++++++++++++++ engine/src/flutter/libs/minikin/Android.mk | 116 ------------------ .../src/flutter/libs/minikin/emoji-data.txt | 1 + engine/src/flutter/sample/Android.bp | 53 ++++++++ engine/src/flutter/sample/Android.mk | 69 ----------- 8 files changed, 184 insertions(+), 221 deletions(-) create mode 100644 engine/src/flutter/Android.bp create mode 100644 engine/src/flutter/app/Android.bp delete mode 100644 engine/src/flutter/app/Android.mk create mode 100644 engine/src/flutter/libs/minikin/Android.bp delete mode 100644 engine/src/flutter/libs/minikin/Android.mk create mode 120000 engine/src/flutter/libs/minikin/emoji-data.txt create mode 100644 engine/src/flutter/sample/Android.bp delete mode 100644 engine/src/flutter/sample/Android.mk diff --git a/engine/src/flutter/Android.bp b/engine/src/flutter/Android.bp new file mode 100644 index 0000000000..b1a778c563 --- /dev/null +++ b/engine/src/flutter/Android.bp @@ -0,0 +1,11 @@ +cc_library_headers { + name: "libminikin_headers", + host_supported: true, + export_include_dirs: ["include"], +} + +subdirs = [ + "app", + "libs/minikin", + "sample", +] diff --git a/engine/src/flutter/app/Android.bp b/engine/src/flutter/app/Android.bp new file mode 100644 index 0000000000..e8085c1f3e --- /dev/null +++ b/engine/src/flutter/app/Android.bp @@ -0,0 +1,30 @@ +// 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. + +// see how_to_run.txt for instructions on running these tests + +cc_binary_host { + name: "hyphtool", + + static_libs: ["libminikin"], + + // Shared libraries which are dependencies of minikin; these are not automatically + // pulled in by the build system (and thus sadly must be repeated). + shared_libs: [ + "liblog", + "libicuuc", + ], + + srcs: ["HyphTool.cpp"], +} diff --git a/engine/src/flutter/app/Android.mk b/engine/src/flutter/app/Android.mk deleted file mode 100644 index 23305b7b4c..0000000000 --- a/engine/src/flutter/app/Android.mk +++ /dev/null @@ -1,36 +0,0 @@ -# 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. - -# see how_to_run.txt for instructions on running these tests - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_MODULE := hyphtool -LOCAL_MODULE_TAGS := optional - -LOCAL_STATIC_LIBRARIES := libminikin_host - -# Shared libraries which are dependencies of minikin; these are not automatically -# pulled in by the build system (and thus sadly must be repeated). - -LOCAL_SHARED_LIBRARIES := \ - liblog \ - libicuuc - -LOCAL_SRC_FILES += \ - HyphTool.cpp - -include $(BUILD_HOST_EXECUTABLE) diff --git a/engine/src/flutter/libs/minikin/Android.bp b/engine/src/flutter/libs/minikin/Android.bp new file mode 100644 index 0000000000..f7b2dea057 --- /dev/null +++ b/engine/src/flutter/libs/minikin/Android.bp @@ -0,0 +1,89 @@ +// Copyright (C) 2013 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generate unicode emoji data from UCD. +genrule { + name: "gen-emoji-header", + cmd: "python $(location unicode_emoji_h_gen.py) -i $(in) -o $(out)", + srcs: ["emoji-data.txt"], + out: ["generated/UnicodeData.h"], + tool_files: ["unicode_emoji_h_gen.py"], +} + +cc_library { + name: "libminikin", + host_supported: true, + srcs: [ + "Hyphenator.cpp", + ], + target: { + android: { + srcs: [ + "AnalyzeStyle.cpp", + "CmapCoverage.cpp", + "FontCollection.cpp", + "FontFamily.cpp", + "FontLanguage.cpp", + "FontLanguageListCache.cpp", + "GraphemeBreak.cpp", + "HbFontCache.cpp", + "Layout.cpp", + "LayoutUtils.cpp", + "LineBreaker.cpp", + "Measurement.cpp", + "MinikinInternal.cpp", + "MinikinRefCounted.cpp", + "MinikinFont.cpp", + "MinikinFontFreeType.cpp", + "SparseBitSet.cpp", + "WordBreaker.cpp", + ], + shared_libs: [ + "libharfbuzz_ng", + "libft2", + "libz", + "libutils", + ], + // TODO: clean up Minikin so it doesn't need the freetype include + export_shared_lib_headers: ["libft2"], + }, + }, + generated_headers: ["gen-emoji-header"], + cppflags: [ + "-Werror", + "-Wall", + "-Wextra", + ], + product_variables: { + debuggable: { + // Enable race detection on eng and userdebug build. + cppflags: ["-DENABLE_RACE_DETECTION"], + }, + }, + shared_libs: [ + "liblog", + "libicuuc", + ], + header_libs: ["libminikin_headers"], + export_header_lib_headers: ["libminikin_headers"], + + clang: true, + sanitize: { + misc_undefined: [ + "signed-integer-overflow", + // b/26432628. + //"unsigned-integer-overflow", + ], + }, +} diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk deleted file mode 100644 index d6c3df7f62..0000000000 --- a/engine/src/flutter/libs/minikin/Android.mk +++ /dev/null @@ -1,116 +0,0 @@ -# Copyright (C) 2013 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) -# Generate unicode emoji data from UCD. -UNICODE_EMOJI_H_GEN_PY := $(LOCAL_PATH)/unicode_emoji_h_gen.py -UNICODE_EMOJI_DATA := $(TOP)/external/unicode/emoji-data.txt - -UNICODE_EMOJI_H := $(intermediates)/generated/UnicodeData.h -$(UNICODE_EMOJI_H): $(UNICODE_EMOJI_H_GEN_PY) $(UNICODE_EMOJI_DATA) -$(LOCAL_PATH)/MinikinInternal.cpp: $(UNICODE_EMOJI_H) -$(UNICODE_EMOJI_H): PRIVATE_CUSTOM_TOOL := python $(UNICODE_EMOJI_H_GEN_PY) \ - -i $(UNICODE_EMOJI_DATA) \ - -o $(UNICODE_EMOJI_H) -$(UNICODE_EMOJI_H): - $(transform-generated-source) - -include $(CLEAR_VARS) -minikin_src_files := \ - AnalyzeStyle.cpp \ - CmapCoverage.cpp \ - FontCollection.cpp \ - FontFamily.cpp \ - FontLanguage.cpp \ - FontLanguageListCache.cpp \ - GraphemeBreak.cpp \ - HbFontCache.cpp \ - Hyphenator.cpp \ - Layout.cpp \ - LayoutUtils.cpp \ - LineBreaker.cpp \ - Measurement.cpp \ - MinikinInternal.cpp \ - MinikinRefCounted.cpp \ - MinikinFont.cpp \ - MinikinFontFreeType.cpp \ - SparseBitSet.cpp \ - WordBreaker.cpp - -minikin_c_includes := \ - external/harfbuzz_ng/src \ - external/freetype/include \ - frameworks/minikin/include \ - $(intermediates) - -minikin_shared_libraries := \ - libharfbuzz_ng \ - libft2 \ - liblog \ - libz \ - libicuuc \ - libutils - -ifneq (,$(filter userdebug eng, $(TARGET_BUILD_VARIANT))) -# Enable race detection on eng and userdebug build. -enable_race_detection := -DENABLE_RACE_DETECTION -else -enable_race_detection := -endif - -LOCAL_MODULE := libminikin -LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include -LOCAL_SRC_FILES := $(minikin_src_files) -LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) -LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) -LOCAL_CLANG := true -LOCAL_SANITIZE := signed-integer-overflow -# b/26432628. -#LOCAL_SANITIZE += unsigned-integer-overflow - -include $(BUILD_SHARED_LIBRARY) - -include $(CLEAR_VARS) - -LOCAL_MODULE := libminikin -LOCAL_MODULE_TAGS := optional -LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include -LOCAL_SRC_FILES := $(minikin_src_files) -LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) -LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) -LOCAL_CLANG := true -LOCAL_SANITIZE := signed-integer-overflow -# b/26432628. -#LOCAL_SANITIZE += unsigned-integer-overflow - -include $(BUILD_STATIC_LIBRARY) - -include $(CLEAR_VARS) - -# Reduced library (currently just hyphenation) for host - -LOCAL_MODULE := libminikin_host -LOCAL_MODULE_TAGS := optional -LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include -LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) -LOCAL_SHARED_LIBRARIES := liblog libicuuc - -LOCAL_SRC_FILES := Hyphenator.cpp - -include $(BUILD_HOST_STATIC_LIBRARY) diff --git a/engine/src/flutter/libs/minikin/emoji-data.txt b/engine/src/flutter/libs/minikin/emoji-data.txt new file mode 120000 index 0000000000..90161250c5 --- /dev/null +++ b/engine/src/flutter/libs/minikin/emoji-data.txt @@ -0,0 +1 @@ +../../../../external/unicode/emoji-data.txt \ No newline at end of file diff --git a/engine/src/flutter/sample/Android.bp b/engine/src/flutter/sample/Android.bp new file mode 100644 index 0000000000..208988969a --- /dev/null +++ b/engine/src/flutter/sample/Android.bp @@ -0,0 +1,53 @@ +// Copyright (C) 2013 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +cc_test { + name: "minikin_example", + gtest: false, + + srcs: ["example.cpp"], + + shared_libs: [ + "libutils", + "liblog", + "libcutils", + "libharfbuzz_ng", + "libicuuc", + "libft2", + "libpng", + "libz", + "libminikin", + ], +} + +cc_test { + name: "minikin_skia_example", + gtest: false, + + srcs: [ + "example_skia.cpp", + "MinikinSkia.cpp", + ], + + shared_libs: [ + "libutils", + "liblog", + "libcutils", + "libharfbuzz_ng", + "libicuuc", + "libskia", + "libminikin", + "libft2", + ], +} diff --git a/engine/src/flutter/sample/Android.mk b/engine/src/flutter/sample/Android.mk deleted file mode 100644 index c4a644d74d..0000000000 --- a/engine/src/flutter/sample/Android.mk +++ /dev/null @@ -1,69 +0,0 @@ -# Copyright (C) 2013 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -LOCAL_PATH:= $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_MODULE_TAGS := tests - -LOCAL_C_INCLUDES += \ - external/harfbuzz_ng/src \ - external/freetype/include \ - frameworks/minikin/include - -LOCAL_SRC_FILES:= example.cpp - -LOCAL_SHARED_LIBRARIES += \ - libutils \ - liblog \ - libcutils \ - libharfbuzz_ng \ - libicuuc \ - libft2 \ - libpng \ - libz \ - libminikin - -LOCAL_MODULE:= minikin_example - -include $(BUILD_EXECUTABLE) - - -include $(CLEAR_VARS) - -LOCAL_MODULE_TAG := tests - -LOCAL_C_INCLUDES += \ - external/harfbuzz_ng/src \ - external/freetype/include \ - frameworks/minikin/include \ - external/skia/src/core - -LOCAL_SRC_FILES:= example_skia.cpp \ - MinikinSkia.cpp - -LOCAL_SHARED_LIBRARIES += \ - libutils \ - liblog \ - libcutils \ - libharfbuzz_ng \ - libicuuc \ - libskia \ - libminikin \ - libft2 - -LOCAL_MODULE:= minikin_skia_example - -include $(BUILD_EXECUTABLE) From fa994b25d1885d67a317e685b2ea8e6bbfdfc655 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Tue, 25 Apr 2017 10:53:34 -0700 Subject: [PATCH 267/364] Convert frameworks/minikin/tests to Android.bp See build/soong/README.md for more information. Test: m -j checkbuild Change-Id: I930debdd129da7f61ac4b764980f73dfd487785d --- engine/src/flutter/Android.bp | 1 + engine/src/flutter/libs/minikin/Android.bp | 7 ++ engine/src/flutter/tests/Android.bp | 33 ++++++ engine/src/flutter/tests/perftests/Android.bp | 49 +++++++++ engine/src/flutter/tests/perftests/Android.mk | 53 --------- .../tests/perftests/FontCollection.cpp | 4 +- .../flutter/tests/perftests/GraphemeBreak.cpp | 2 +- .../flutter/tests/perftests/Hyphenator.cpp | 4 +- .../flutter/tests/perftests/WordBreaker.cpp | 2 +- .../src/flutter/tests/stresstest/Android.bp | 49 +++++++++ .../src/flutter/tests/stresstest/Android.mk | 56 ---------- engine/src/flutter/tests/unittest/Android.bp | 74 +++++++++++++ engine/src/flutter/tests/unittest/Android.mk | 101 ------------------ engine/src/flutter/tests/util/Android.bp | 13 +++ 14 files changed, 232 insertions(+), 216 deletions(-) create mode 100644 engine/src/flutter/tests/Android.bp create mode 100644 engine/src/flutter/tests/perftests/Android.bp delete mode 100644 engine/src/flutter/tests/perftests/Android.mk create mode 100644 engine/src/flutter/tests/stresstest/Android.bp delete mode 100644 engine/src/flutter/tests/stresstest/Android.mk create mode 100644 engine/src/flutter/tests/unittest/Android.bp delete mode 100644 engine/src/flutter/tests/unittest/Android.mk create mode 100644 engine/src/flutter/tests/util/Android.bp diff --git a/engine/src/flutter/Android.bp b/engine/src/flutter/Android.bp index 26d5027683..e875a172b0 100644 --- a/engine/src/flutter/Android.bp +++ b/engine/src/flutter/Android.bp @@ -7,4 +7,5 @@ cc_library_headers { subdirs = [ "app", "libs/minikin", + "tests", ] diff --git a/engine/src/flutter/libs/minikin/Android.bp b/engine/src/flutter/libs/minikin/Android.bp index ef721ea80b..2489ba7749 100644 --- a/engine/src/flutter/libs/minikin/Android.bp +++ b/engine/src/flutter/libs/minikin/Android.bp @@ -12,6 +12,13 @@ // See the License for the specific language governing permissions and // limitations under the License. +cc_library_headers { + name: "libminikin-headers-for-tests", + export_include_dirs: ["."], + shared_libs: ["libharfbuzz_ng"], + export_shared_lib_headers: ["libharfbuzz_ng"], +} + cc_library { name: "libminikin", host_supported: true, diff --git a/engine/src/flutter/tests/Android.bp b/engine/src/flutter/tests/Android.bp new file mode 100644 index 0000000000..ddc5012511 --- /dev/null +++ b/engine/src/flutter/tests/Android.bp @@ -0,0 +1,33 @@ +filegroup { + name: "minikin-test-data", + srcs: [ + "data/Bold.ttf", + "data/BoldItalic.ttf", + "data/ColorEmojiFont.ttf", + "data/ColorTextMixedEmojiFont.ttf", + "data/Emoji.ttf", + "data/Italic.ttf", + "data/Ja.ttf", + "data/Ko.ttf", + "data/MultiAxis.ttf", + "data/NoCmapFormat14.ttf", + "data/NoGlyphFont.ttf", + "data/Regular.ttf", + "data/TextEmojiFont.ttf", + "data/UnicodeBMPOnly.ttf", + "data/UnicodeBMPOnly2.ttf", + "data/UnicodeUCS4.ttf", + "data/VariationSelectorTest-Regular.ttf", + "data/ZhHans.ttf", + "data/ZhHant.ttf", + "data/emoji.xml", + "data/itemize.xml", + ], +} + +subdirs = [ + "perftests", + "stresstest", + "unittest", + "util", +] diff --git a/engine/src/flutter/tests/perftests/Android.bp b/engine/src/flutter/tests/perftests/Android.bp new file mode 100644 index 0000000000..f8847ac4cb --- /dev/null +++ b/engine/src/flutter/tests/perftests/Android.bp @@ -0,0 +1,49 @@ +// +// Copyright (C) 2016 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. +// + +cc_benchmark { + name: "minikin_perftests", + test_suites: ["device-tests"], + cppflags: [ + "-Werror", + "-Wall", + "-Wextra", + ], + srcs: [ + "FontCollection.cpp", + "FontFamily.cpp", + "FontLanguage.cpp", + "GraphemeBreak.cpp", + "Hyphenator.cpp", + "WordBreaker.cpp", + "main.cpp", + ], + + header_libs: ["libminikin-headers-for-tests"], + + static_libs: [ + "libminikin-tests-util", + "libminikin", + "libxml2", + ], + + shared_libs: [ + "libharfbuzz_ng", + "libicuuc", + "liblog", + "libskia", + ], +} diff --git a/engine/src/flutter/tests/perftests/Android.mk b/engine/src/flutter/tests/perftests/Android.mk deleted file mode 100644 index aa18f8b27a..0000000000 --- a/engine/src/flutter/tests/perftests/Android.mk +++ /dev/null @@ -1,53 +0,0 @@ -# -# Copyright (C) 2016 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. -# - -LOCAL_PATH := $(call my-dir) - -perftest_src_files := \ - ../util/FileUtils.cpp \ - ../util/FontTestUtils.cpp \ - ../util/MinikinFontForTest.cpp \ - ../util/UnicodeUtils.cpp \ - FontCollection.cpp \ - FontFamily.cpp \ - FontLanguage.cpp \ - GraphemeBreak.cpp \ - Hyphenator.cpp \ - WordBreaker.cpp \ - main.cpp - -include $(CLEAR_VARS) -LOCAL_MODULE := minikin_perftests -LOCAL_COMPATIBILITY_SUITE := device-tests -LOCAL_CPPFLAGS := -Werror -Wall -Wextra -LOCAL_SRC_FILES := $(perftest_src_files) -LOCAL_STATIC_LIBRARIES := \ - libminikin \ - libxml2 - -LOCAL_SHARED_LIBRARIES := \ - libharfbuzz_ng \ - libicuuc \ - liblog \ - libskia - -LOCAL_C_INCLUDES := \ - $(LOCAL_PATH)/../ \ - $(LOCAL_PATH)/../../libs/minikin \ - external/harfbuzz_ng/src \ - external/libxml2/include - -include $(BUILD_NATIVE_BENCHMARK) diff --git a/engine/src/flutter/tests/perftests/FontCollection.cpp b/engine/src/flutter/tests/perftests/FontCollection.cpp index fd95cf1a60..79f25631b0 100644 --- a/engine/src/flutter/tests/perftests/FontCollection.cpp +++ b/engine/src/flutter/tests/perftests/FontCollection.cpp @@ -18,8 +18,8 @@ #include #include -#include -#include +#include +#include #include namespace minikin { diff --git a/engine/src/flutter/tests/perftests/GraphemeBreak.cpp b/engine/src/flutter/tests/perftests/GraphemeBreak.cpp index 6d6cf5b178..830586f44e 100644 --- a/engine/src/flutter/tests/perftests/GraphemeBreak.cpp +++ b/engine/src/flutter/tests/perftests/GraphemeBreak.cpp @@ -18,7 +18,7 @@ #include #include "minikin/GraphemeBreak.h" -#include "util/UnicodeUtils.h" +#include "UnicodeUtils.h" namespace minikin { diff --git a/engine/src/flutter/tests/perftests/Hyphenator.cpp b/engine/src/flutter/tests/perftests/Hyphenator.cpp index 2107e0575c..ae6249875a 100644 --- a/engine/src/flutter/tests/perftests/Hyphenator.cpp +++ b/engine/src/flutter/tests/perftests/Hyphenator.cpp @@ -16,8 +16,8 @@ #include #include -#include -#include +#include +#include namespace minikin { diff --git a/engine/src/flutter/tests/perftests/WordBreaker.cpp b/engine/src/flutter/tests/perftests/WordBreaker.cpp index 6758cf97e5..f9ef2144db 100644 --- a/engine/src/flutter/tests/perftests/WordBreaker.cpp +++ b/engine/src/flutter/tests/perftests/WordBreaker.cpp @@ -16,7 +16,7 @@ #include #include "minikin/WordBreaker.h" -#include "util/UnicodeUtils.h" +#include "UnicodeUtils.h" namespace minikin { diff --git a/engine/src/flutter/tests/stresstest/Android.bp b/engine/src/flutter/tests/stresstest/Android.bp new file mode 100644 index 0000000000..96a23dcfb7 --- /dev/null +++ b/engine/src/flutter/tests/stresstest/Android.bp @@ -0,0 +1,49 @@ +// Copyright (C) 2017 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. + +// see how_to_run.txt for instructions on running these tests + +cc_test { + name: "minikin_stress_tests", + + header_libs: ["libminikin-headers-for-tests"], + + static_libs: [ + "libminikin-tests-util", + "libminikin", + "libxml2", + ], + + // Shared libraries which are dependencies of minikin; these are not automatically + // pulled in by the build system (and thus sadly must be repeated). + shared_libs: [ + "libskia", + "libft2", + "libharfbuzz_ng", + "libicuuc", + "liblog", + "libutils", + "libz", + ], + + srcs: [ + "MultithreadTest.cpp", + ], + + cppflags: [ + "-Werror", + "-Wall", + "-Wextra", + ], +} diff --git a/engine/src/flutter/tests/stresstest/Android.mk b/engine/src/flutter/tests/stresstest/Android.mk deleted file mode 100644 index 961978b5cc..0000000000 --- a/engine/src/flutter/tests/stresstest/Android.mk +++ /dev/null @@ -1,56 +0,0 @@ -# Copyright (C) 2017 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. - -# see how_to_run.txt for instructions on running these tests - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_TEST_DATA := $(foreach f,$(LOCAL_TEST_DATA),frameworks/minikin/tests:$(f)) - -LOCAL_MODULE := minikin_stress_tests -LOCAL_MODULE_TAGS := tests -LOCAL_MODULE_CLASS := NATIVE_TESTS - -LOCAL_STATIC_LIBRARIES := libminikin - -# Shared libraries which are dependencies of minikin; these are not automatically -# pulled in by the build system (and thus sadly must be repeated). - -LOCAL_SHARED_LIBRARIES := \ - libskia \ - libft2 \ - libharfbuzz_ng \ - libicuuc \ - liblog \ - libutils \ - libz - -LOCAL_STATIC_LIBRARIES += \ - libxml2 - -LOCAL_SRC_FILES += \ - ../util/FontTestUtils.cpp \ - ../util/MinikinFontForTest.cpp \ - MultithreadTest.cpp \ - -LOCAL_C_INCLUDES := \ - $(LOCAL_PATH)/../../libs/minikin/ \ - $(LOCAL_PATH)/../util \ - external/libxml2/include \ - -LOCAL_CPPFLAGS += -Werror -Wall -Wextra - -include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/unittest/Android.bp b/engine/src/flutter/tests/unittest/Android.bp new file mode 100644 index 0000000000..2353d4cc76 --- /dev/null +++ b/engine/src/flutter/tests/unittest/Android.bp @@ -0,0 +1,74 @@ +// 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. + +// see how_to_run.txt for instructions on running these tests + +cc_test { + name: "minikin_tests", + test_suites: ["device-tests"], + data: [":minikin-test-data"], + + header_libs: ["libminikin-headers-for-tests"], + + static_libs: [ + "libminikin-tests-util", + "libminikin", + "libxml2", + ], + + // Shared libraries which are dependencies of minikin; these are not automatically + // pulled in by the build system (and thus sadly must be repeated). + shared_libs: [ + "libskia", + "libft2", + "libharfbuzz_ng", + "libicuuc", + "liblog", + "libutils", + "libz", + ], + + srcs: [ + "CmapCoverageTest.cpp", + "EmojiTest.cpp", + "FontCollectionTest.cpp", + "FontCollectionItemizeTest.cpp", + "FontFamilyTest.cpp", + "FontLanguageListCacheTest.cpp", + "HbFontCacheTest.cpp", + "HyphenatorTest.cpp", + "GraphemeBreakTests.cpp", + "LayoutTest.cpp", + "LayoutUtilsTest.cpp", + "MeasurementTests.cpp", + "SparseBitSetTest.cpp", + "UnicodeUtilsTest.cpp", + "WordBreakerTests.cpp", + ], + + cppflags: [ + "-Werror", + "-Wall", + "-Wextra", + ], + + multilib: { + lib32: { + cppflags: ["-DkTestFontDir=\"/data/nativetest/minikin_tests/data/\""], + }, + lib64: { + cppflags: ["-DkTestFontDir=\"/data/nativetest64/minikin_tests/data/\""], + }, + }, +} diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk deleted file mode 100644 index 55ff9babfe..0000000000 --- a/engine/src/flutter/tests/unittest/Android.mk +++ /dev/null @@ -1,101 +0,0 @@ -# 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. - -# see how_to_run.txt for instructions on running these tests - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_TEST_DATA := \ - data/Bold.ttf \ - data/BoldItalic.ttf \ - data/ColorEmojiFont.ttf \ - data/ColorTextMixedEmojiFont.ttf \ - data/Emoji.ttf \ - data/Italic.ttf \ - data/Ja.ttf \ - data/Ko.ttf \ - data/MultiAxis.ttf \ - data/NoCmapFormat14.ttf \ - data/NoGlyphFont.ttf \ - data/Regular.ttf \ - data/TextEmojiFont.ttf \ - data/UnicodeBMPOnly.ttf \ - data/UnicodeBMPOnly2.ttf \ - data/UnicodeUCS4.ttf \ - data/VariationSelectorTest-Regular.ttf \ - data/ZhHans.ttf \ - data/ZhHant.ttf \ - data/emoji.xml \ - data/itemize.xml \ - -LOCAL_TEST_DATA := $(foreach f,$(LOCAL_TEST_DATA),frameworks/minikin/tests:$(f)) - -LOCAL_MODULE := minikin_tests -LOCAL_COMPATIBILITY_SUITE := device-tests -LOCAL_MODULE_TAGS := tests -LOCAL_MODULE_CLASS := NATIVE_TESTS - -LOCAL_STATIC_LIBRARIES := libminikin - -# Shared libraries which are dependencies of minikin; these are not automatically -# pulled in by the build system (and thus sadly must be repeated). - -LOCAL_SHARED_LIBRARIES := \ - libskia \ - libft2 \ - libharfbuzz_ng \ - libicuuc \ - liblog \ - libutils \ - libz - -LOCAL_STATIC_LIBRARIES += \ - libxml2 - -LOCAL_SRC_FILES += \ - ../util/FileUtils.cpp \ - ../util/FontTestUtils.cpp \ - ../util/MinikinFontForTest.cpp \ - ../util/UnicodeUtils.cpp \ - CmapCoverageTest.cpp \ - EmojiTest.cpp \ - FontCollectionTest.cpp \ - FontCollectionItemizeTest.cpp \ - FontFamilyTest.cpp \ - FontLanguageListCacheTest.cpp \ - HbFontCacheTest.cpp \ - HyphenatorTest.cpp \ - GraphemeBreakTests.cpp \ - LayoutTest.cpp \ - LayoutUtilsTest.cpp \ - MeasurementTests.cpp \ - SparseBitSetTest.cpp \ - UnicodeUtilsTest.cpp \ - WordBreakerTests.cpp - -LOCAL_C_INCLUDES := \ - $(LOCAL_PATH)/../../libs/minikin/ \ - $(LOCAL_PATH)/../util \ - external/harfbuzz_ng/src \ - external/libxml2/include \ - external/skia/src/core - -LOCAL_CPPFLAGS += -Werror -Wall -Wextra - -LOCAL_CPPFLAGS_32 += -DkTestFontDir="\"/data/nativetest/minikin_tests/data/\"" -LOCAL_CPPFLAGS_64 += -DkTestFontDir="\"/data/nativetest64/minikin_tests/data/\"" - -include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/util/Android.bp b/engine/src/flutter/tests/util/Android.bp new file mode 100644 index 0000000000..50a2cd722f --- /dev/null +++ b/engine/src/flutter/tests/util/Android.bp @@ -0,0 +1,13 @@ +cc_library_static { + name: "libminikin-tests-util", + srcs: [ + "FileUtils.cpp", + "FontTestUtils.cpp", + "MinikinFontForTest.cpp", + "UnicodeUtils.cpp", + ], + export_include_dirs: ["."], + shared_libs: ["libxml2"], + static_libs: ["libminikin"], + header_libs: ["libminikin-headers-for-tests"], +} From f3ba5a36bf209bc73cff4d082aead5c8606514c4 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Fri, 2 Dec 2016 17:59:14 -0800 Subject: [PATCH 268/364] Convert frameworks/minikin to Android.bp See build/soong/README.md for more information. Test: m -j checkbuild Change-Id: I71d3406054b35dd4e8ae30f46eec6cef77eef160 (cherry picked from commit 716f07be94544d97039fbcb01df876e092d61d37) --- engine/src/flutter/Android.bp | 10 ++ engine/src/flutter/app/Android.bp | 30 ++++++ engine/src/flutter/app/Android.mk | 36 -------- engine/src/flutter/libs/minikin/Android.bp | 78 ++++++++++++++++ engine/src/flutter/libs/minikin/Android.mk | 102 --------------------- 5 files changed, 118 insertions(+), 138 deletions(-) create mode 100644 engine/src/flutter/Android.bp create mode 100644 engine/src/flutter/app/Android.bp delete mode 100644 engine/src/flutter/app/Android.mk create mode 100644 engine/src/flutter/libs/minikin/Android.bp delete mode 100644 engine/src/flutter/libs/minikin/Android.mk diff --git a/engine/src/flutter/Android.bp b/engine/src/flutter/Android.bp new file mode 100644 index 0000000000..26d5027683 --- /dev/null +++ b/engine/src/flutter/Android.bp @@ -0,0 +1,10 @@ +cc_library_headers { + name: "libminikin_headers", + host_supported: true, + export_include_dirs: ["include"], +} + +subdirs = [ + "app", + "libs/minikin", +] diff --git a/engine/src/flutter/app/Android.bp b/engine/src/flutter/app/Android.bp new file mode 100644 index 0000000000..e8085c1f3e --- /dev/null +++ b/engine/src/flutter/app/Android.bp @@ -0,0 +1,30 @@ +// 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. + +// see how_to_run.txt for instructions on running these tests + +cc_binary_host { + name: "hyphtool", + + static_libs: ["libminikin"], + + // Shared libraries which are dependencies of minikin; these are not automatically + // pulled in by the build system (and thus sadly must be repeated). + shared_libs: [ + "liblog", + "libicuuc", + ], + + srcs: ["HyphTool.cpp"], +} diff --git a/engine/src/flutter/app/Android.mk b/engine/src/flutter/app/Android.mk deleted file mode 100644 index 23305b7b4c..0000000000 --- a/engine/src/flutter/app/Android.mk +++ /dev/null @@ -1,36 +0,0 @@ -# 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. - -# see how_to_run.txt for instructions on running these tests - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_MODULE := hyphtool -LOCAL_MODULE_TAGS := optional - -LOCAL_STATIC_LIBRARIES := libminikin_host - -# Shared libraries which are dependencies of minikin; these are not automatically -# pulled in by the build system (and thus sadly must be repeated). - -LOCAL_SHARED_LIBRARIES := \ - liblog \ - libicuuc - -LOCAL_SRC_FILES += \ - HyphTool.cpp - -include $(BUILD_HOST_EXECUTABLE) diff --git a/engine/src/flutter/libs/minikin/Android.bp b/engine/src/flutter/libs/minikin/Android.bp new file mode 100644 index 0000000000..ef721ea80b --- /dev/null +++ b/engine/src/flutter/libs/minikin/Android.bp @@ -0,0 +1,78 @@ +// Copyright (C) 2013 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +cc_library { + name: "libminikin", + host_supported: true, + srcs: [ + "Hyphenator.cpp", + ], + target: { + android: { + srcs: [ + "CmapCoverage.cpp", + "Emoji.cpp", + "FontCollection.cpp", + "FontFamily.cpp", + "FontLanguage.cpp", + "FontLanguageListCache.cpp", + "FontUtils.cpp", + "GraphemeBreak.cpp", + "HbFontCache.cpp", + "Layout.cpp", + "LayoutUtils.cpp", + "LineBreaker.cpp", + "Measurement.cpp", + "MinikinInternal.cpp", + "MinikinFont.cpp", + "SparseBitSet.cpp", + "WordBreaker.cpp", + ], + shared_libs: [ + "libharfbuzz_ng", + "libft2", + "libz", + "libutils", + ], + // TODO: clean up Minikin so it doesn't need the freetype include + export_shared_lib_headers: ["libft2"], + }, + }, + cppflags: [ + "-Werror", + "-Wall", + "-Wextra", + ], + product_variables: { + debuggable: { + // Enable race detection on eng and userdebug build. + cppflags: ["-DENABLE_RACE_DETECTION"], + }, + }, + shared_libs: [ + "liblog", + "libicuuc", + ], + header_libs: ["libminikin_headers"], + export_header_lib_headers: ["libminikin_headers"], + + clang: true, + sanitize: { + misc_undefined: [ + "signed-integer-overflow", + // b/26432628. + //"unsigned-integer-overflow", + ], + }, +} diff --git a/engine/src/flutter/libs/minikin/Android.mk b/engine/src/flutter/libs/minikin/Android.mk deleted file mode 100644 index bb6234a123..0000000000 --- a/engine/src/flutter/libs/minikin/Android.mk +++ /dev/null @@ -1,102 +0,0 @@ -# Copyright (C) 2013 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -include $(CLEAR_VARS) -minikin_src_files := \ - CmapCoverage.cpp \ - Emoji.cpp \ - FontCollection.cpp \ - FontFamily.cpp \ - FontLanguage.cpp \ - FontLanguageListCache.cpp \ - FontUtils.cpp \ - GraphemeBreak.cpp \ - HbFontCache.cpp \ - Hyphenator.cpp \ - Layout.cpp \ - LayoutUtils.cpp \ - LineBreaker.cpp \ - Measurement.cpp \ - MinikinInternal.cpp \ - MinikinFont.cpp \ - SparseBitSet.cpp \ - WordBreaker.cpp - -minikin_c_includes := \ - external/harfbuzz_ng/src \ - frameworks/minikin/include \ - $(intermediates) - -minikin_shared_libraries := \ - libharfbuzz_ng \ - libft2 \ - liblog \ - libz \ - libicuuc \ - libutils - -ifneq (,$(filter userdebug eng, $(TARGET_BUILD_VARIANT))) -# Enable race detection on eng and userdebug build. -enable_race_detection := -DENABLE_RACE_DETECTION -else -enable_race_detection := -endif - -LOCAL_MODULE := libminikin -LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include -LOCAL_SRC_FILES := $(minikin_src_files) -LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) -LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) -LOCAL_CLANG := true -LOCAL_SANITIZE := signed-integer-overflow -# b/26432628. -#LOCAL_SANITIZE += unsigned-integer-overflow - -include $(BUILD_SHARED_LIBRARY) - -include $(CLEAR_VARS) - -LOCAL_MODULE := libminikin -LOCAL_MODULE_TAGS := optional -LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include -LOCAL_SRC_FILES := $(minikin_src_files) -LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) -LOCAL_SHARED_LIBRARIES := $(minikin_shared_libraries) -LOCAL_CLANG := true -LOCAL_SANITIZE := signed-integer-overflow -# b/26432628. -#LOCAL_SANITIZE += unsigned-integer-overflow - -include $(BUILD_STATIC_LIBRARY) - -include $(CLEAR_VARS) - -# Reduced library (currently just hyphenation) for host - -LOCAL_MODULE := libminikin_host -LOCAL_MODULE_TAGS := optional -LOCAL_EXPORT_C_INCLUDE_DIRS := frameworks/minikin/include -LOCAL_C_INCLUDES := $(minikin_c_includes) -LOCAL_CPPFLAGS += -Werror -Wall -Wextra $(enable_race_detection) -LOCAL_SHARED_LIBRARIES := liblog libicuuc - -LOCAL_SRC_FILES := Hyphenator.cpp - -include $(BUILD_HOST_STATIC_LIBRARY) From fcb08dbdeee43f133f3f524f4cc142e41a181f19 Mon Sep 17 00:00:00 2001 From: Fredrik Roubert Date: Thu, 13 Apr 2017 20:06:05 +0200 Subject: [PATCH 269/364] =?UTF-8?q?Let=20mk=5Fhyb=5Ffile.py=20replace=20?= =?UTF-8?q?=C3=9FSS=20in=20.chr.txt=20files=20with=20=C3=9F=E1=BA=9E.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Here these mappings are used to convert from uppercase to lowercase, and mk_hyb_file.py doesn't handle multi-character uppercase sequences. Therefore, in case the sequence ßSS is encountered in a .chr.txt, replace it internally with ßẞ. Test: make -j Change-Id: I8f678aad9298784f70645c453ec07da5bf43cb66 --- engine/src/flutter/tools/mk_hyb_file.py | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/tools/mk_hyb_file.py b/engine/src/flutter/tools/mk_hyb_file.py index a9b8932c95..545e9b7b93 100755 --- a/engine/src/flutter/tools/mk_hyb_file.py +++ b/engine/src/flutter/tools/mk_hyb_file.py @@ -35,6 +35,10 @@ import getopt VERBOSE = False +# U+00DF is LATIN SMALL LETTER SHARP S +# U+1E9E is LATIN CAPITAL LETTER SHARP S +SHARP_S_TO_DOUBLE = u'\u00dfSS' +SHARP_S_TO_CAPITAL = u'\u00df\u1e9e' if sys.version_info[0] >= 3: def unichr(x): @@ -283,8 +287,12 @@ def load_chr(fn): for i, l in enumerate(f): l = l.strip() if len(l) > 2: - # lowercase maps to multi-character uppercase sequence, ignore uppercase for now - l = l[:1] + if l == SHARP_S_TO_DOUBLE: + # replace with lowercasing from capital letter sharp s + l = SHARP_S_TO_CAPITAL + else: + # lowercase maps to multi-character uppercase sequence, ignore uppercase for now + l = l[:1] else: assert len(l) == 2, 'expected 2 chars in chr' for c in l: @@ -419,6 +427,9 @@ def verify_file_sorted(lines, fn): file_lines = [l.strip() for l in io.open(fn, encoding='UTF-8')] line_set = set(lines) file_set = set(file_lines) + if SHARP_S_TO_DOUBLE in file_set: + # ignore difference of double capital letter s and capital letter sharp s + file_set.symmetric_difference_update([SHARP_S_TO_DOUBLE, SHARP_S_TO_CAPITAL]) if line_set == file_set: return True for line in line_set - file_set: From 6e0a223dbb6457ce95347e426b9b6c9662166cb9 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Tue, 2 May 2017 17:18:30 -0700 Subject: [PATCH 270/364] Export libicuuc headers from libminikin Test: m -j checkbuild Change-Id: Ibecebc8a1bd4028c083424476dd379c0ce0149a1 --- engine/src/flutter/libs/minikin/Android.bp | 1 + 1 file changed, 1 insertion(+) diff --git a/engine/src/flutter/libs/minikin/Android.bp b/engine/src/flutter/libs/minikin/Android.bp index f7b2dea057..444bd9a8b5 100644 --- a/engine/src/flutter/libs/minikin/Android.bp +++ b/engine/src/flutter/libs/minikin/Android.bp @@ -77,6 +77,7 @@ cc_library { ], header_libs: ["libminikin_headers"], export_header_lib_headers: ["libminikin_headers"], + export_shared_lib_headers: ["libicuuc"], clang: true, sanitize: { From d9ff3a728957fe19842cc1c2d3554aee624bcbc2 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Tue, 25 Apr 2017 10:53:34 -0700 Subject: [PATCH 271/364] Convert frameworks/minikin/tests to Android.bp See build/soong/README.md for more information. Test: m -j checkbuild Change-Id: I930debdd129da7f61ac4b764980f73dfd487785d Merged-In: I930debdd129da7f61ac4b764980f73dfd487785d (cherry picked from commit fa994b25d1885d67a317e685b2ea8e6bbfdfc655) --- engine/src/flutter/Android.bp | 1 + engine/src/flutter/libs/minikin/Android.bp | 7 ++ engine/src/flutter/tests/Android.bp | 86 ++++++++++++++++++++++ engine/src/flutter/tests/Android.mk | 85 --------------------- 4 files changed, 94 insertions(+), 85 deletions(-) create mode 100644 engine/src/flutter/tests/Android.bp delete mode 100644 engine/src/flutter/tests/Android.mk diff --git a/engine/src/flutter/Android.bp b/engine/src/flutter/Android.bp index b1a778c563..84de9fb2b2 100644 --- a/engine/src/flutter/Android.bp +++ b/engine/src/flutter/Android.bp @@ -8,4 +8,5 @@ subdirs = [ "app", "libs/minikin", "sample", + "tests", ] diff --git a/engine/src/flutter/libs/minikin/Android.bp b/engine/src/flutter/libs/minikin/Android.bp index 444bd9a8b5..1109280faf 100644 --- a/engine/src/flutter/libs/minikin/Android.bp +++ b/engine/src/flutter/libs/minikin/Android.bp @@ -21,6 +21,13 @@ genrule { tool_files: ["unicode_emoji_h_gen.py"], } +cc_library_headers { + name: "libminikin-headers-for-tests", + export_include_dirs: ["."], + shared_libs: ["libharfbuzz_ng"], + export_shared_lib_headers: ["libharfbuzz_ng"], +} + cc_library { name: "libminikin", host_supported: true, diff --git a/engine/src/flutter/tests/Android.bp b/engine/src/flutter/tests/Android.bp new file mode 100644 index 0000000000..895cd2a481 --- /dev/null +++ b/engine/src/flutter/tests/Android.bp @@ -0,0 +1,86 @@ +// 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. + +// see how_to_run.txt for instructions on running these tests + +cc_test { + name: "minikin_tests", + data: [ + "data/BoldItalic.ttf", + "data/Bold.ttf", + "data/ColorEmojiFont.ttf", + "data/ColorTextMixedEmojiFont.ttf", + "data/Emoji.ttf", + "data/Italic.ttf", + "data/Ja.ttf", + "data/Ko.ttf", + "data/NoGlyphFont.ttf", + "data/Regular.ttf", + "data/TextEmojiFont.ttf", + "data/VarioationSelectorTest-Regular.ttf", + "data/ZhHans.ttf", + "data/ZhHant.ttf", + "data/itemize.xml", + "data/emoji.xml", + ], + + static_libs: [ + "libminikin", + "libxml2", + ], + + // Shared libraries which are dependencies of minikin; these are not automatically + // pulled in by the build system (and thus sadly must be repeated). + shared_libs: [ + "libskia", + "libft2", + "libharfbuzz_ng", + "libicuuc", + "liblog", + "libutils", + "libz", + ], + + srcs: [ + "FontCollectionTest.cpp", + "FontCollectionItemizeTest.cpp", + "FontFamilyTest.cpp", + "FontLanguageListCacheTest.cpp", + "FontTestUtils.cpp", + "HbFontCacheTest.cpp", + "MinikinFontForTest.cpp", + "MinikinInternalTest.cpp", + "GraphemeBreakTests.cpp", + "LayoutUtilsTest.cpp", + "UnicodeUtils.cpp", + "WordBreakerTests.cpp", + ], + + header_libs: ["libminikin-headers-for-tests"], + + cppflags: [ + "-Werror", + "-Wall", + "-Wextra", + ], + + multilib: { + lib32: { + cppflags: ["-DkTestFontDir=\"/data/nativetest/minikin_tests/data/\""], + }, + lib64: { + cppflags: ["-DkTestFontDir=\"/data/nativetest64/minikin_tests/data/\""], + }, + }, +} diff --git a/engine/src/flutter/tests/Android.mk b/engine/src/flutter/tests/Android.mk deleted file mode 100644 index 2f21532377..0000000000 --- a/engine/src/flutter/tests/Android.mk +++ /dev/null @@ -1,85 +0,0 @@ -# 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. - -# see how_to_run.txt for instructions on running these tests - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_TEST_DATA := \ - data/BoldItalic.ttf \ - data/Bold.ttf \ - data/ColorEmojiFont.ttf \ - data/ColorTextMixedEmojiFont.ttf \ - data/Emoji.ttf \ - data/Italic.ttf \ - data/Ja.ttf \ - data/Ko.ttf \ - data/NoGlyphFont.ttf \ - data/Regular.ttf \ - data/TextEmojiFont.ttf \ - data/VarioationSelectorTest-Regular.ttf \ - data/ZhHans.ttf \ - data/ZhHant.ttf \ - data/itemize.xml \ - data/emoji.xml - -LOCAL_MODULE := minikin_tests -LOCAL_MODULE_TAGS := tests -LOCAL_MODULE_CLASS := NATIVE_TESTS - -LOCAL_STATIC_LIBRARIES := libminikin - -# Shared libraries which are dependencies of minikin; these are not automatically -# pulled in by the build system (and thus sadly must be repeated). - -LOCAL_SHARED_LIBRARIES := \ - libskia \ - libft2 \ - libharfbuzz_ng \ - libicuuc \ - liblog \ - libutils \ - libz - -LOCAL_STATIC_LIBRARIES += \ - libxml2 - -LOCAL_SRC_FILES += \ - FontCollectionTest.cpp \ - FontCollectionItemizeTest.cpp \ - FontFamilyTest.cpp \ - FontLanguageListCacheTest.cpp \ - FontTestUtils.cpp \ - HbFontCacheTest.cpp \ - MinikinFontForTest.cpp \ - MinikinInternalTest.cpp \ - GraphemeBreakTests.cpp \ - LayoutUtilsTest.cpp \ - UnicodeUtils.cpp \ - WordBreakerTests.cpp - -LOCAL_C_INCLUDES := \ - $(LOCAL_PATH)/../libs/minikin/ \ - external/harfbuzz_ng/src \ - external/libxml2/include \ - external/skia/src/core - -LOCAL_CPPFLAGS += -Werror -Wall -Wextra - -LOCAL_CPPFLAGS_32 += -DkTestFontDir="\"/data/nativetest/minikin_tests/data/\"" -LOCAL_CPPFLAGS_64 += -DkTestFontDir="\"/data/nativetest64/minikin_tests/data/\"" - -include $(BUILD_NATIVE_TEST) From ede222c03b9757e9a1da85cdc9de4d85b9e7379c Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Tue, 25 Apr 2017 10:53:34 -0700 Subject: [PATCH 272/364] Convert frameworks/minikin/tests to Android.bp See build/soong/README.md for more information. Test: m -j checkbuild Change-Id: I930debdd129da7f61ac4b764980f73dfd487785d Merged-In: I930debdd129da7f61ac4b764980f73dfd487785d (cherry picked from commit fa994b25d1885d67a317e685b2ea8e6bbfdfc655) --- engine/src/flutter/Android.bp | 1 + engine/src/flutter/libs/minikin/Android.bp | 7 ++ engine/src/flutter/tests/Android.bp | 33 ++++++ engine/src/flutter/tests/perftests/Android.bp | 48 +++++++++ engine/src/flutter/tests/perftests/Android.mk | 52 --------- .../tests/perftests/FontCollection.cpp | 4 +- .../flutter/tests/perftests/GraphemeBreak.cpp | 2 +- .../flutter/tests/perftests/Hyphenator.cpp | 4 +- .../flutter/tests/perftests/WordBreaker.cpp | 2 +- .../src/flutter/tests/stresstest/Android.bp | 49 +++++++++ .../src/flutter/tests/stresstest/Android.mk | 56 ---------- engine/src/flutter/tests/unittest/Android.bp | 73 +++++++++++++ engine/src/flutter/tests/unittest/Android.mk | 100 ------------------ engine/src/flutter/tests/util/Android.bp | 13 +++ 14 files changed, 230 insertions(+), 214 deletions(-) create mode 100644 engine/src/flutter/tests/Android.bp create mode 100644 engine/src/flutter/tests/perftests/Android.bp delete mode 100644 engine/src/flutter/tests/perftests/Android.mk create mode 100644 engine/src/flutter/tests/stresstest/Android.bp delete mode 100644 engine/src/flutter/tests/stresstest/Android.mk create mode 100644 engine/src/flutter/tests/unittest/Android.bp delete mode 100644 engine/src/flutter/tests/unittest/Android.mk create mode 100644 engine/src/flutter/tests/util/Android.bp diff --git a/engine/src/flutter/Android.bp b/engine/src/flutter/Android.bp index 26d5027683..e875a172b0 100644 --- a/engine/src/flutter/Android.bp +++ b/engine/src/flutter/Android.bp @@ -7,4 +7,5 @@ cc_library_headers { subdirs = [ "app", "libs/minikin", + "tests", ] diff --git a/engine/src/flutter/libs/minikin/Android.bp b/engine/src/flutter/libs/minikin/Android.bp index c236be3499..71a693ec2c 100644 --- a/engine/src/flutter/libs/minikin/Android.bp +++ b/engine/src/flutter/libs/minikin/Android.bp @@ -12,6 +12,13 @@ // See the License for the specific language governing permissions and // limitations under the License. +cc_library_headers { + name: "libminikin-headers-for-tests", + export_include_dirs: ["."], + shared_libs: ["libharfbuzz_ng"], + export_shared_lib_headers: ["libharfbuzz_ng"], +} + cc_library { name: "libminikin", host_supported: true, diff --git a/engine/src/flutter/tests/Android.bp b/engine/src/flutter/tests/Android.bp new file mode 100644 index 0000000000..ddc5012511 --- /dev/null +++ b/engine/src/flutter/tests/Android.bp @@ -0,0 +1,33 @@ +filegroup { + name: "minikin-test-data", + srcs: [ + "data/Bold.ttf", + "data/BoldItalic.ttf", + "data/ColorEmojiFont.ttf", + "data/ColorTextMixedEmojiFont.ttf", + "data/Emoji.ttf", + "data/Italic.ttf", + "data/Ja.ttf", + "data/Ko.ttf", + "data/MultiAxis.ttf", + "data/NoCmapFormat14.ttf", + "data/NoGlyphFont.ttf", + "data/Regular.ttf", + "data/TextEmojiFont.ttf", + "data/UnicodeBMPOnly.ttf", + "data/UnicodeBMPOnly2.ttf", + "data/UnicodeUCS4.ttf", + "data/VariationSelectorTest-Regular.ttf", + "data/ZhHans.ttf", + "data/ZhHant.ttf", + "data/emoji.xml", + "data/itemize.xml", + ], +} + +subdirs = [ + "perftests", + "stresstest", + "unittest", + "util", +] diff --git a/engine/src/flutter/tests/perftests/Android.bp b/engine/src/flutter/tests/perftests/Android.bp new file mode 100644 index 0000000000..f8068e8b8e --- /dev/null +++ b/engine/src/flutter/tests/perftests/Android.bp @@ -0,0 +1,48 @@ +// +// Copyright (C) 2016 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. +// + +cc_benchmark { + name: "minikin_perftests", + cppflags: [ + "-Werror", + "-Wall", + "-Wextra", + ], + srcs: [ + "FontCollection.cpp", + "FontFamily.cpp", + "FontLanguage.cpp", + "GraphemeBreak.cpp", + "Hyphenator.cpp", + "WordBreaker.cpp", + "main.cpp", + ], + + header_libs: ["libminikin-headers-for-tests"], + + static_libs: [ + "libminikin-tests-util", + "libminikin", + "libxml2", + ], + + shared_libs: [ + "libharfbuzz_ng", + "libicuuc", + "liblog", + "libskia", + ], +} diff --git a/engine/src/flutter/tests/perftests/Android.mk b/engine/src/flutter/tests/perftests/Android.mk deleted file mode 100644 index c60123a83d..0000000000 --- a/engine/src/flutter/tests/perftests/Android.mk +++ /dev/null @@ -1,52 +0,0 @@ -# -# Copyright (C) 2016 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. -# - -LOCAL_PATH := $(call my-dir) - -perftest_src_files := \ - ../util/FileUtils.cpp \ - ../util/FontTestUtils.cpp \ - ../util/MinikinFontForTest.cpp \ - ../util/UnicodeUtils.cpp \ - FontCollection.cpp \ - FontFamily.cpp \ - FontLanguage.cpp \ - GraphemeBreak.cpp \ - Hyphenator.cpp \ - WordBreaker.cpp \ - main.cpp - -include $(CLEAR_VARS) -LOCAL_MODULE := minikin_perftests -LOCAL_CPPFLAGS := -Werror -Wall -Wextra -LOCAL_SRC_FILES := $(perftest_src_files) -LOCAL_STATIC_LIBRARIES := \ - libminikin \ - libxml2 - -LOCAL_SHARED_LIBRARIES := \ - libharfbuzz_ng \ - libicuuc \ - liblog \ - libskia - -LOCAL_C_INCLUDES := \ - $(LOCAL_PATH)/../ \ - $(LOCAL_PATH)/../../libs/minikin \ - external/harfbuzz_ng/src \ - external/libxml2/include - -include $(BUILD_NATIVE_BENCHMARK) diff --git a/engine/src/flutter/tests/perftests/FontCollection.cpp b/engine/src/flutter/tests/perftests/FontCollection.cpp index fd95cf1a60..79f25631b0 100644 --- a/engine/src/flutter/tests/perftests/FontCollection.cpp +++ b/engine/src/flutter/tests/perftests/FontCollection.cpp @@ -18,8 +18,8 @@ #include #include -#include -#include +#include +#include #include namespace minikin { diff --git a/engine/src/flutter/tests/perftests/GraphemeBreak.cpp b/engine/src/flutter/tests/perftests/GraphemeBreak.cpp index 6d6cf5b178..830586f44e 100644 --- a/engine/src/flutter/tests/perftests/GraphemeBreak.cpp +++ b/engine/src/flutter/tests/perftests/GraphemeBreak.cpp @@ -18,7 +18,7 @@ #include #include "minikin/GraphemeBreak.h" -#include "util/UnicodeUtils.h" +#include "UnicodeUtils.h" namespace minikin { diff --git a/engine/src/flutter/tests/perftests/Hyphenator.cpp b/engine/src/flutter/tests/perftests/Hyphenator.cpp index 2107e0575c..ae6249875a 100644 --- a/engine/src/flutter/tests/perftests/Hyphenator.cpp +++ b/engine/src/flutter/tests/perftests/Hyphenator.cpp @@ -16,8 +16,8 @@ #include #include -#include -#include +#include +#include namespace minikin { diff --git a/engine/src/flutter/tests/perftests/WordBreaker.cpp b/engine/src/flutter/tests/perftests/WordBreaker.cpp index 6758cf97e5..f9ef2144db 100644 --- a/engine/src/flutter/tests/perftests/WordBreaker.cpp +++ b/engine/src/flutter/tests/perftests/WordBreaker.cpp @@ -16,7 +16,7 @@ #include #include "minikin/WordBreaker.h" -#include "util/UnicodeUtils.h" +#include "UnicodeUtils.h" namespace minikin { diff --git a/engine/src/flutter/tests/stresstest/Android.bp b/engine/src/flutter/tests/stresstest/Android.bp new file mode 100644 index 0000000000..96a23dcfb7 --- /dev/null +++ b/engine/src/flutter/tests/stresstest/Android.bp @@ -0,0 +1,49 @@ +// Copyright (C) 2017 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. + +// see how_to_run.txt for instructions on running these tests + +cc_test { + name: "minikin_stress_tests", + + header_libs: ["libminikin-headers-for-tests"], + + static_libs: [ + "libminikin-tests-util", + "libminikin", + "libxml2", + ], + + // Shared libraries which are dependencies of minikin; these are not automatically + // pulled in by the build system (and thus sadly must be repeated). + shared_libs: [ + "libskia", + "libft2", + "libharfbuzz_ng", + "libicuuc", + "liblog", + "libutils", + "libz", + ], + + srcs: [ + "MultithreadTest.cpp", + ], + + cppflags: [ + "-Werror", + "-Wall", + "-Wextra", + ], +} diff --git a/engine/src/flutter/tests/stresstest/Android.mk b/engine/src/flutter/tests/stresstest/Android.mk deleted file mode 100644 index 961978b5cc..0000000000 --- a/engine/src/flutter/tests/stresstest/Android.mk +++ /dev/null @@ -1,56 +0,0 @@ -# Copyright (C) 2017 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. - -# see how_to_run.txt for instructions on running these tests - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_TEST_DATA := $(foreach f,$(LOCAL_TEST_DATA),frameworks/minikin/tests:$(f)) - -LOCAL_MODULE := minikin_stress_tests -LOCAL_MODULE_TAGS := tests -LOCAL_MODULE_CLASS := NATIVE_TESTS - -LOCAL_STATIC_LIBRARIES := libminikin - -# Shared libraries which are dependencies of minikin; these are not automatically -# pulled in by the build system (and thus sadly must be repeated). - -LOCAL_SHARED_LIBRARIES := \ - libskia \ - libft2 \ - libharfbuzz_ng \ - libicuuc \ - liblog \ - libutils \ - libz - -LOCAL_STATIC_LIBRARIES += \ - libxml2 - -LOCAL_SRC_FILES += \ - ../util/FontTestUtils.cpp \ - ../util/MinikinFontForTest.cpp \ - MultithreadTest.cpp \ - -LOCAL_C_INCLUDES := \ - $(LOCAL_PATH)/../../libs/minikin/ \ - $(LOCAL_PATH)/../util \ - external/libxml2/include \ - -LOCAL_CPPFLAGS += -Werror -Wall -Wextra - -include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/unittest/Android.bp b/engine/src/flutter/tests/unittest/Android.bp new file mode 100644 index 0000000000..e6d1356903 --- /dev/null +++ b/engine/src/flutter/tests/unittest/Android.bp @@ -0,0 +1,73 @@ +// 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. + +// see how_to_run.txt for instructions on running these tests + +cc_test { + name: "minikin_tests", + data: [":minikin-test-data"], + + header_libs: ["libminikin-headers-for-tests"], + + static_libs: [ + "libminikin-tests-util", + "libminikin", + "libxml2", + ], + + // Shared libraries which are dependencies of minikin; these are not automatically + // pulled in by the build system (and thus sadly must be repeated). + shared_libs: [ + "libskia", + "libft2", + "libharfbuzz_ng", + "libicuuc", + "liblog", + "libutils", + "libz", + ], + + srcs: [ + "CmapCoverageTest.cpp", + "EmojiTest.cpp", + "FontCollectionTest.cpp", + "FontCollectionItemizeTest.cpp", + "FontFamilyTest.cpp", + "FontLanguageListCacheTest.cpp", + "HbFontCacheTest.cpp", + "HyphenatorTest.cpp", + "GraphemeBreakTests.cpp", + "LayoutTest.cpp", + "LayoutUtilsTest.cpp", + "MeasurementTests.cpp", + "SparseBitSetTest.cpp", + "UnicodeUtilsTest.cpp", + "WordBreakerTests.cpp", + ], + + cppflags: [ + "-Werror", + "-Wall", + "-Wextra", + ], + + multilib: { + lib32: { + cppflags: ["-DkTestFontDir=\"/data/nativetest/minikin_tests/data/\""], + }, + lib64: { + cppflags: ["-DkTestFontDir=\"/data/nativetest64/minikin_tests/data/\""], + }, + }, +} diff --git a/engine/src/flutter/tests/unittest/Android.mk b/engine/src/flutter/tests/unittest/Android.mk deleted file mode 100644 index b817c46961..0000000000 --- a/engine/src/flutter/tests/unittest/Android.mk +++ /dev/null @@ -1,100 +0,0 @@ -# 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. - -# see how_to_run.txt for instructions on running these tests - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_TEST_DATA := \ - data/Bold.ttf \ - data/BoldItalic.ttf \ - data/ColorEmojiFont.ttf \ - data/ColorTextMixedEmojiFont.ttf \ - data/Emoji.ttf \ - data/Italic.ttf \ - data/Ja.ttf \ - data/Ko.ttf \ - data/MultiAxis.ttf \ - data/NoCmapFormat14.ttf \ - data/NoGlyphFont.ttf \ - data/Regular.ttf \ - data/TextEmojiFont.ttf \ - data/UnicodeBMPOnly.ttf \ - data/UnicodeBMPOnly2.ttf \ - data/UnicodeUCS4.ttf \ - data/VariationSelectorTest-Regular.ttf \ - data/ZhHans.ttf \ - data/ZhHant.ttf \ - data/emoji.xml \ - data/itemize.xml \ - -LOCAL_TEST_DATA := $(foreach f,$(LOCAL_TEST_DATA),frameworks/minikin/tests:$(f)) - -LOCAL_MODULE := minikin_tests -LOCAL_MODULE_TAGS := tests -LOCAL_MODULE_CLASS := NATIVE_TESTS - -LOCAL_STATIC_LIBRARIES := libminikin - -# Shared libraries which are dependencies of minikin; these are not automatically -# pulled in by the build system (and thus sadly must be repeated). - -LOCAL_SHARED_LIBRARIES := \ - libskia \ - libft2 \ - libharfbuzz_ng \ - libicuuc \ - liblog \ - libutils \ - libz - -LOCAL_STATIC_LIBRARIES += \ - libxml2 - -LOCAL_SRC_FILES += \ - ../util/FileUtils.cpp \ - ../util/FontTestUtils.cpp \ - ../util/MinikinFontForTest.cpp \ - ../util/UnicodeUtils.cpp \ - CmapCoverageTest.cpp \ - EmojiTest.cpp \ - FontCollectionTest.cpp \ - FontCollectionItemizeTest.cpp \ - FontFamilyTest.cpp \ - FontLanguageListCacheTest.cpp \ - HbFontCacheTest.cpp \ - HyphenatorTest.cpp \ - GraphemeBreakTests.cpp \ - LayoutTest.cpp \ - LayoutUtilsTest.cpp \ - MeasurementTests.cpp \ - SparseBitSetTest.cpp \ - UnicodeUtilsTest.cpp \ - WordBreakerTests.cpp - -LOCAL_C_INCLUDES := \ - $(LOCAL_PATH)/../../libs/minikin/ \ - $(LOCAL_PATH)/../util \ - external/harfbuzz_ng/src \ - external/libxml2/include \ - external/skia/src/core - -LOCAL_CPPFLAGS += -Werror -Wall -Wextra - -LOCAL_CPPFLAGS_32 += -DkTestFontDir="\"/data/nativetest/minikin_tests/data/\"" -LOCAL_CPPFLAGS_64 += -DkTestFontDir="\"/data/nativetest64/minikin_tests/data/\"" - -include $(BUILD_NATIVE_TEST) diff --git a/engine/src/flutter/tests/util/Android.bp b/engine/src/flutter/tests/util/Android.bp new file mode 100644 index 0000000000..50a2cd722f --- /dev/null +++ b/engine/src/flutter/tests/util/Android.bp @@ -0,0 +1,13 @@ +cc_library_static { + name: "libminikin-tests-util", + srcs: [ + "FileUtils.cpp", + "FontTestUtils.cpp", + "MinikinFontForTest.cpp", + "UnicodeUtils.cpp", + ], + export_include_dirs: ["."], + shared_libs: ["libxml2"], + static_libs: ["libminikin"], + header_libs: ["libminikin-headers-for-tests"], +} From ebc9d5808234e678e17ada89d836793bf1f219b5 Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Mon, 8 May 2017 12:12:17 -0700 Subject: [PATCH 273/364] Add BUILD.gn and make the library build Change-Id: Ie2c3d6f97987e8a9938af8f02b093bb74dd22a18 --- engine/src/flutter/BUILD.gn | 9 + engine/src/flutter/LICENSE | 202 +++++++++++ engine/src/flutter/app/HyphTool.cpp | 1 - engine/src/flutter/libs/minikin/BUILD.gn | 59 +++ .../flutter/libs/minikin/FontCollection.cpp | 4 +- .../src/flutter/libs/minikin/FontFamily.cpp | 8 +- .../flutter/libs/minikin/GraphemeBreak.cpp | 32 +- .../src/flutter/libs/minikin/HbFontCache.cpp | 11 +- .../src/flutter/libs/minikin/Hyphenator.cpp | 1 - engine/src/flutter/libs/minikin/Layout.cpp | 22 +- engine/src/flutter/libs/minikin/LayoutUtils.h | 1 + .../src/flutter/libs/minikin/Measurement.cpp | 2 +- .../src/flutter/libs/minikin/MinikinFont.cpp | 2 +- .../flutter/libs/minikin/MinikinInternal.cpp | 2 +- .../flutter/libs/minikin/MinikinInternal.h | 6 +- .../src/flutter/libs/minikin/WordBreaker.cpp | 2 +- engine/src/flutter/shims/BUILD.gn | 33 ++ engine/src/flutter/shims/log/log.cc | 25 ++ engine/src/flutter/shims/log/log.h | 57 +++ engine/src/flutter/shims/utils/JenkinsHash.h | 51 +++ engine/src/flutter/shims/utils/LruCache.h | 298 ++++++++++++++++ engine/src/flutter/shims/utils/TypeHelpers.h | 336 ++++++++++++++++++ .../tests/perftests/FontCollection.cpp | 2 +- .../unittest/FontCollectionItemizeTest.cpp | 4 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 12 +- .../unittest/FontLanguageListCacheTest.cpp | 4 +- .../tests/unittest/HbFontCacheTest.cpp | 10 +- .../tests/unittest/WordBreakerTests.cpp | 2 +- 28 files changed, 1134 insertions(+), 64 deletions(-) create mode 100644 engine/src/flutter/BUILD.gn create mode 100644 engine/src/flutter/LICENSE create mode 100644 engine/src/flutter/libs/minikin/BUILD.gn create mode 100644 engine/src/flutter/shims/BUILD.gn create mode 100644 engine/src/flutter/shims/log/log.cc create mode 100644 engine/src/flutter/shims/log/log.h create mode 100644 engine/src/flutter/shims/utils/JenkinsHash.h create mode 100644 engine/src/flutter/shims/utils/LruCache.h create mode 100644 engine/src/flutter/shims/utils/TypeHelpers.h diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn new file mode 100644 index 0000000000..8a8166708b --- /dev/null +++ b/engine/src/flutter/BUILD.gn @@ -0,0 +1,9 @@ +# Copyright 2017 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +group("txt") { + deps = [ + "libs/minikin", + ] +} diff --git a/engine/src/flutter/LICENSE b/engine/src/flutter/LICENSE new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/engine/src/flutter/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. diff --git a/engine/src/flutter/app/HyphTool.cpp b/engine/src/flutter/app/HyphTool.cpp index 403d37439a..3c1d2f96d6 100644 --- a/engine/src/flutter/app/HyphTool.cpp +++ b/engine/src/flutter/app/HyphTool.cpp @@ -3,7 +3,6 @@ #include #include "unicode/locid.h" -#include "utils/Log.h" #include #include diff --git a/engine/src/flutter/libs/minikin/BUILD.gn b/engine/src/flutter/libs/minikin/BUILD.gn new file mode 100644 index 0000000000..d4104e38a5 --- /dev/null +++ b/engine/src/flutter/libs/minikin/BUILD.gn @@ -0,0 +1,59 @@ +# Copyright 2017 Google Inc. +# +# 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. + +config("minikin_config") { + include_dirs = [ "../../include" ] +} + +static_library("minikin") { + sources = [ + "CmapCoverage.cpp", + "Emoji.cpp", + "FontCollection.cpp", + "FontFamily.cpp", + "FontLanguage.cpp", + "FontLanguage.h", + "FontLanguageListCache.cpp", + "FontLanguageListCache.h", + "FontUtils.cpp", + "FontUtils.h", + "GraphemeBreak.cpp", + "HbFontCache.cpp", + "HbFontCache.h", + "Hyphenator.cpp", + "Layout.cpp", + "LayoutUtils.cpp", + "LayoutUtils.h", + "LineBreaker.cpp", + "Measurement.cpp", + "MinikinFont.cpp", + "MinikinInternal.cpp", + "MinikinInternal.h", + "SparseBitSet.cpp", + "WordBreaker.cpp", + ] + + public_configs = [ ":minikin_config" ] + + public_deps = [ + "//third_party/freetype2", + "//third_party/harfbuzz", + "//third_party/icu:icuuc", + ] + + deps = [ + "//third_party/zlib", + "//lib/txt/shims", + ] +} diff --git a/engine/src/flutter/libs/minikin/FontCollection.cpp b/engine/src/flutter/libs/minikin/FontCollection.cpp index 02ed9dc623..ddb85720de 100644 --- a/engine/src/flutter/libs/minikin/FontCollection.cpp +++ b/engine/src/flutter/libs/minikin/FontCollection.cpp @@ -56,7 +56,7 @@ FontCollection::FontCollection(const vector>& typefa } void FontCollection::init(const vector>& typefaces) { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); mId = sNextId++; vector lastChar; size_t nTypefaces = typefaces.size(); @@ -333,7 +333,7 @@ bool FontCollection::hasVariationSelector(uint32_t baseCodepoint, return false; } - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); // Currently mRanges can not be used here since it isn't aware of the variation sequence. for (size_t i = 0; i < mVSFamilyVec.size(); i++) { diff --git a/engine/src/flutter/libs/minikin/FontFamily.cpp b/engine/src/flutter/libs/minikin/FontFamily.cpp index 39d374b99d..1ea47fafcb 100644 --- a/engine/src/flutter/libs/minikin/FontFamily.cpp +++ b/engine/src/flutter/libs/minikin/FontFamily.cpp @@ -56,7 +56,7 @@ android::hash_t FontStyle::hash() const { // static uint32_t FontStyle::registerLanguageList(const std::string& languages) { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); return FontLanguageListCache::getId(languages); } @@ -111,7 +111,7 @@ FontFamily::FontFamily(uint32_t langId, int variant, std::vector&& fonts) bool FontFamily::analyzeStyle(const std::shared_ptr& typeface, int* weight, bool* italic) { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); const uint32_t os2Tag = MinikinFont::MakeTag('O', 'S', '/', '2'); HbBlob os2Table(getFontTable(typeface.get(), os2Tag)); if (os2Table.get() == nullptr) return false; @@ -166,7 +166,7 @@ bool FontFamily::isColorEmojiFamily() const { } void FontFamily::computeCoverage() { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); const FontStyle defaultStyle; const MinikinFont* typeface = getClosestMatch(defaultStyle).font; const uint32_t cmapTag = MinikinFont::MakeTag('c', 'm', 'a', 'p'); @@ -220,7 +220,7 @@ std::shared_ptr FontFamily::createFamilyWithVariation( std::vector fonts; for (const Font& font : mFonts) { bool supportedVariations = false; - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); std::unordered_set supportedAxes = font.getSupportedAxesLocked(); if (!supportedAxes.empty()) { for (const FontVariation& variation : variations) { diff --git a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp index 87de4213f9..482621ce69 100644 --- a/engine/src/flutter/libs/minikin/GraphemeBreak.cpp +++ b/engine/src/flutter/libs/minikin/GraphemeBreak.cpp @@ -104,7 +104,8 @@ bool GraphemeBreak::isGraphemeBreak(const float* advances, const uint16_t* buf, return false; } // Rule GB9, x (Extend | ZWJ); Rule GB9a, x SpacingMark; Rule GB9b, Prepend x - if (p2 == U_GCB_EXTEND || p2 == U_GCB_ZWJ || p2 == U_GCB_SPACING_MARK || p1 == U_GCB_PREPEND) { + // TODO(abarth): Add U_GCB_ZWJ once we update ICU. + if (p2 == U_GCB_EXTEND || /* p2 == U_GCB_ZWJ || */ p2 == U_GCB_SPACING_MARK || p1 == U_GCB_PREPEND) { return false; } @@ -142,25 +143,28 @@ bool GraphemeBreak::isGraphemeBreak(const float* advances, const uint16_t* buf, return false; } } + + // TODO(abarth): Enablet his code once we update ICU. // Tailored version of Rule GB11, ZWJ × (Glue_After_Zwj | EBG) // We try to make emoji sequences with ZWJ a single grapheme cluster, but only if they actually // merge to one cluster. So we are more relaxed than the UAX #29 rules in accepting any emoji // character after the ZWJ, but are tighter in that we only treat it as one cluster if a // ligature is actually formed and we also require the character before the ZWJ to also be an // emoji. - if (p1 == U_GCB_ZWJ && isEmoji(c2) && offset_back > start) { - // look at character before ZWJ to see that both can participate in an emoji zwj sequence - uint32_t c0 = 0; - size_t offset_backback = offset_back; - U16_PREV(buf, start, offset_backback, c0); - if (c0 == 0xFE0F && offset_backback > start) { - // skip over emoji variation selector - U16_PREV(buf, start, offset_backback, c0); - } - if (isEmoji(c0)) { - return false; - } - } + // if (p1 == U_GCB_ZWJ && isEmoji(c2) && offset_back > start) { + // // look at character before ZWJ to see that both can participate in an emoji zwj sequence + // uint32_t c0 = 0; + // size_t offset_backback = offset_back; + // U16_PREV(buf, start, offset_backback, c0); + // if (c0 == 0xFE0F && offset_backback > start) { + // // skip over emoji variation selector + // U16_PREV(buf, start, offset_backback, c0); + // } + // if (isEmoji(c0)) { + // return false; + // } + // } + // Tailored version of Rule GB12 and Rule GB13 that look at even-odd cases. // sot (RI RI)* RI x RI // [^RI] (RI RI)* RI x RI diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index af3d783bc8..a7647c016c 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -117,11 +117,12 @@ hb_font_t* getHbFontLocked(const MinikinFont* minikinFont) { hb_font_set_scale(parent_font, upem, upem); font = hb_font_create_sub_font(parent_font); - std::vector variations; - for (const FontVariation& variation : minikinFont->GetAxes()) { - variations.push_back({variation.axisTag, variation.value}); - } - hb_font_set_variations(font, variations.data(), variations.size()); + // TODO(abarth): Enable this code once we update harfbuzz. + // std::vector variations; + // for (const FontVariation& variation : minikinFont->GetAxes()) { + // variations.push_back({variation.axisTag, variation.value}); + // } + // hb_font_set_variations(font, variations.data(), variations.size()); hb_font_destroy(parent_font); hb_face_destroy(face); fontCache->put(fontId, font); diff --git a/engine/src/flutter/libs/minikin/Hyphenator.cpp b/engine/src/flutter/libs/minikin/Hyphenator.cpp index 0605b27831..0d1c0d7715 100644 --- a/engine/src/flutter/libs/minikin/Hyphenator.cpp +++ b/engine/src/flutter/libs/minikin/Hyphenator.cpp @@ -25,7 +25,6 @@ #include #define LOG_TAG "Minikin" -#include "utils/Log.h" #include "minikin/Hyphenator.h" diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 568e03876b..e6c5bc912d 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -28,8 +28,6 @@ #include #include #include -#include -#include #include #include @@ -164,7 +162,7 @@ static unsigned int disabledDecomposeCompatibility(hb_unicode_funcs_t*, hb_codep return 0; } -class LayoutEngine : public ::android::Singleton { +class LayoutEngine { public: LayoutEngine() { unicodeFunctions = hb_unicode_funcs_create(hb_icu_get_unicode_funcs()); @@ -178,6 +176,11 @@ public: hb_buffer_t* hbBuffer; hb_unicode_funcs_t* unicodeFunctions; LayoutCache layoutCache; + + static LayoutEngine& getInstance() { + static LayoutEngine* instance = new LayoutEngine(); + return *instance; + } }; bool LayoutCacheKey::operator==(const LayoutCacheKey& other) const { @@ -556,7 +559,7 @@ BidiText::BidiText(const uint16_t* buf, size_t start, size_t count, size_t bufSi void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint, const std::shared_ptr& collection) { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); LayoutContext ctx; ctx.style = style; @@ -575,7 +578,7 @@ void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bu float Layout::measureText(const uint16_t* buf, size_t start, size_t count, size_t bufSize, int bidiFlags, const FontStyle &style, const MinikinPaint &paint, const std::shared_ptr& collection, float* advances) { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); LayoutContext ctx; ctx.style = style; @@ -1102,17 +1105,10 @@ void Layout::getBounds(MinikinRect* bounds) const { } void Layout::purgeCaches() { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); LayoutCache& layoutCache = LayoutEngine::getInstance().layoutCache; layoutCache.clear(); purgeHbFontCacheLocked(); } } // namespace minikin - -// Unable to define the static data member outside of android. -// TODO: introduce our own Singleton to drop android namespace. -namespace android { -ANDROID_SINGLETON_STATIC_INSTANCE(minikin::LayoutEngine); -} // namespace android - diff --git a/engine/src/flutter/libs/minikin/LayoutUtils.h b/engine/src/flutter/libs/minikin/LayoutUtils.h index b89004cf19..f13f634eaa 100644 --- a/engine/src/flutter/libs/minikin/LayoutUtils.h +++ b/engine/src/flutter/libs/minikin/LayoutUtils.h @@ -17,6 +17,7 @@ #ifndef MINIKIN_LAYOUT_UTILS_H #define MINIKIN_LAYOUT_UTILS_H +#include #include namespace minikin { diff --git a/engine/src/flutter/libs/minikin/Measurement.cpp b/engine/src/flutter/libs/minikin/Measurement.cpp index f0d15f24e8..89797134c0 100644 --- a/engine/src/flutter/libs/minikin/Measurement.cpp +++ b/engine/src/flutter/libs/minikin/Measurement.cpp @@ -19,7 +19,7 @@ #include #include -#include +#include #include #include diff --git a/engine/src/flutter/libs/minikin/MinikinFont.cpp b/engine/src/flutter/libs/minikin/MinikinFont.cpp index 6bf6a4ae3b..d2f9aca171 100644 --- a/engine/src/flutter/libs/minikin/MinikinFont.cpp +++ b/engine/src/flutter/libs/minikin/MinikinFont.cpp @@ -21,7 +21,7 @@ namespace minikin { MinikinFont::~MinikinFont() { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); purgeHbFontLocked(this); } diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.cpp b/engine/src/flutter/libs/minikin/MinikinInternal.cpp index 88acc5061b..9cd7bddab5 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.cpp +++ b/engine/src/flutter/libs/minikin/MinikinInternal.cpp @@ -24,7 +24,7 @@ namespace minikin { -android::Mutex gMinikinLock; +std::mutex gMinikinLock; void assertMinikinLocked() { #ifdef ENABLE_RACE_DETECTION diff --git a/engine/src/flutter/libs/minikin/MinikinInternal.h b/engine/src/flutter/libs/minikin/MinikinInternal.h index 1ed0816188..54395221e7 100644 --- a/engine/src/flutter/libs/minikin/MinikinInternal.h +++ b/engine/src/flutter/libs/minikin/MinikinInternal.h @@ -19,9 +19,9 @@ #ifndef MINIKIN_INTERNAL_H #define MINIKIN_INTERNAL_H -#include +#include -#include +#include #include @@ -31,7 +31,7 @@ namespace minikin { // Presently, that's implemented by through a global lock, and having // all external interfaces take that lock. -extern android::Mutex gMinikinLock; +extern std::mutex gMinikinLock; // Aborts if gMinikinLock is not acquired. Do nothing on the release build. void assertMinikinLocked(); diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index 16edca7d6e..8d0d0fb4b4 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -16,7 +16,7 @@ #define LOG_TAG "Minikin" -#include +#include #include #include diff --git a/engine/src/flutter/shims/BUILD.gn b/engine/src/flutter/shims/BUILD.gn new file mode 100644 index 0000000000..a09a56ab33 --- /dev/null +++ b/engine/src/flutter/shims/BUILD.gn @@ -0,0 +1,33 @@ +# Copyright 2017 Google Inc. +# +# 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. + +config("shims_config") { + include_dirs = [ "." ] +} + +source_set("shims") { + sources = [ + "log/log.h", + "log/log.cc", + "utils/JenkinsHash.h", + "utils/LruCache.h", + "utils/TypeHelpers.h", + ] + + public_configs = [ ":shims_config" ] + + public_deps = [ + "//lib/ftl", + ] +} diff --git a/engine/src/flutter/shims/log/log.cc b/engine/src/flutter/shims/log/log.cc new file mode 100644 index 0000000000..ab61fead31 --- /dev/null +++ b/engine/src/flutter/shims/log/log.cc @@ -0,0 +1,25 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 + +int __android_log_error_write(int tag, + const char* subTag, + int32_t uid, + const char* data, + uint32_t dataLen) { + return 0; +} diff --git a/engine/src/flutter/shims/log/log.h b/engine/src/flutter/shims/log/log.h new file mode 100644 index 0000000000..c3303555ec --- /dev/null +++ b/engine/src/flutter/shims/log/log.h @@ -0,0 +1,57 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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. + */ + +#pragma once + +#include + +#include "lib/ftl/logging.h" + +#ifndef LOG_ALWAYS_FATAL_IF +#define LOG_ALWAYS_FATAL_IF(cond, ...) \ + ((cond) ? (FTL_LOG(FATAL) << #cond) : (void)0) +#endif + +#ifndef LOG_ALWAYS_FATAL +#define LOG_ALWAYS_FATAL(...) FTL_LOG(FATAL) +#endif + +#ifndef LOG_ASSERT +#define LOG_ASSERT(cond, ...) FTL_CHECK(cond) +#define ALOG_ASSERT LOG_ASSERT +#endif + +#ifndef ALOGD +#define ALOGD(message, ...) FTL_DLOG(INFO) << (message) +#endif + +#ifndef ALOGW +#define ALOGW(message, ...) FTL_LOG(WARNING) << (message) +#endif + +#ifndef ALOGE +#define ALOGE(message, ...) FTL_LOG(ERROR) << (message) +#endif + +#define android_errorWriteLog(tag, subTag) \ + __android_log_error_write(tag, subTag, -1, NULL, 0) +#define android_errorWriteWithInfoLog(tag, subTag, uid, data, dataLen) \ + __android_log_error_write(tag, subTag, uid, data, dataLen) +int __android_log_error_write(int tag, + const char* subTag, + int32_t uid, + const char* data, + uint32_t dataLen); diff --git a/engine/src/flutter/shims/utils/JenkinsHash.h b/engine/src/flutter/shims/utils/JenkinsHash.h new file mode 100644 index 0000000000..027c10c7e0 --- /dev/null +++ b/engine/src/flutter/shims/utils/JenkinsHash.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2012 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. + */ + +/* Implementation of Jenkins one-at-a-time hash function. These choices are + * optimized for code size and portability, rather than raw speed. But speed + * should still be quite good. + **/ + +#ifndef ANDROID_JENKINS_HASH_H +#define ANDROID_JENKINS_HASH_H + +#include + +namespace android { + +/* The Jenkins hash of a sequence of 32 bit words A, B, C is: + * Whiten(Mix(Mix(Mix(0, A), B), C)) */ + +#ifdef __clang__ +__attribute__((no_sanitize("integer"))) +#endif +inline uint32_t JenkinsHashMix(uint32_t hash, uint32_t data) { + hash += data; + hash += (hash << 10); + hash ^= (hash >> 6); + return hash; +} + +hash_t JenkinsHashWhiten(uint32_t hash); + +/* Helpful utility functions for hashing data in 32 bit chunks */ +uint32_t JenkinsHashMixBytes(uint32_t hash, const uint8_t* bytes, size_t size); + +uint32_t JenkinsHashMixShorts(uint32_t hash, const uint16_t* shorts, size_t size); + +} + +#endif // ANDROID_JENKINS_HASH_H diff --git a/engine/src/flutter/shims/utils/LruCache.h b/engine/src/flutter/shims/utils/LruCache.h new file mode 100644 index 0000000000..89dccd6138 --- /dev/null +++ b/engine/src/flutter/shims/utils/LruCache.h @@ -0,0 +1,298 @@ +/* + * Copyright (C) 2012 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 ANDROID_UTILS_LRU_CACHE_H +#define ANDROID_UTILS_LRU_CACHE_H + +#include +#include + +#include "utils/TypeHelpers.h" // hash_t + +namespace android { + +/** + * GenerationCache callback used when an item is removed + */ +template +class OnEntryRemoved { +public: + virtual ~OnEntryRemoved() { }; + virtual void operator()(EntryKey& key, EntryValue& value) = 0; +}; // class OnEntryRemoved + +template +class LruCache { +public: + explicit LruCache(uint32_t maxCapacity); + virtual ~LruCache(); + + enum Capacity { + kUnlimitedCapacity, + }; + + void setOnEntryRemovedListener(OnEntryRemoved* listener); + size_t size() const; + const TValue& get(const TKey& key); + bool put(const TKey& key, const TValue& value); + bool remove(const TKey& key); + bool removeOldest(); + void clear(); + const TValue& peekOldestValue(); + +private: + LruCache(const LruCache& that); // disallow copy constructor + + // Super class so that we can have entries having only a key reference, for searches. + class KeyedEntry { + public: + virtual const TKey& getKey() const = 0; + // Make sure the right destructor is executed so that keys and values are deleted. + virtual ~KeyedEntry() {} + }; + + class Entry final : public KeyedEntry { + public: + TKey key; + TValue value; + Entry* parent; + Entry* child; + + Entry(TKey _key, TValue _value) : key(_key), value(_value), parent(NULL), child(NULL) { + } + const TKey& getKey() const final { return key; } + }; + + class EntryForSearch : public KeyedEntry { + public: + const TKey& key; + EntryForSearch(const TKey& key_) : key(key_) { + } + const TKey& getKey() const final { return key; } + }; + + struct HashForEntry : public std::unary_function { + size_t operator() (const KeyedEntry* entry) const { + return hash_type(entry->getKey()); + }; + }; + + struct EqualityForHashedEntries : public std::unary_function { + bool operator() (const KeyedEntry* lhs, const KeyedEntry* rhs) const { + return lhs->getKey() == rhs->getKey(); + }; + }; + + // All entries in the set will be Entry*. Using the weaker KeyedEntry as to allow entries + // that have only a key reference, for searching. + typedef std::unordered_set LruCacheSet; + + void attachToCache(Entry& entry); + void detachFromCache(Entry& entry); + + typename LruCacheSet::iterator findByKey(const TKey& key) { + EntryForSearch entryForSearch(key); + typename LruCacheSet::iterator result = mSet->find(&entryForSearch); + return result; + } + + std::unique_ptr mSet; + OnEntryRemoved* mListener; + Entry* mOldest; + Entry* mYoungest; + uint32_t mMaxCapacity; + TValue mNullValue; + +public: + // To be used like: + // while (it.next()) { + // it.value(); it.key(); + // } + class Iterator { + public: + Iterator(const LruCache& cache): + mCache(cache), mIterator(mCache.mSet->begin()), mBeginReturned(false) { + } + + bool next() { + if (mIterator == mCache.mSet->end()) { + return false; + } + if (!mBeginReturned) { + // mIterator has been initialized to the beginning and + // hasn't been returned. Do not advance: + mBeginReturned = true; + } else { + std::advance(mIterator, 1); + } + bool ret = (mIterator != mCache.mSet->end()); + return ret; + } + + const TValue& value() const { + // All the elements in the set are of type Entry. See comment in the definition + // of LruCacheSet above. + return reinterpret_cast(*mIterator)->value; + } + + const TKey& key() const { + return (*mIterator)->getKey(); + } + private: + const LruCache& mCache; + typename LruCacheSet::iterator mIterator; + bool mBeginReturned; + }; +}; + +// Implementation is here, because it's fully templated +template +LruCache::LruCache(uint32_t maxCapacity) + : mSet(new LruCacheSet()) + , mListener(NULL) + , mOldest(NULL) + , mYoungest(NULL) + , mMaxCapacity(maxCapacity) + , mNullValue(0) { + mSet->max_load_factor(1.0); +}; + +template +LruCache::~LruCache() { + // Need to delete created entries. + clear(); +}; + +template +void LruCache::setOnEntryRemovedListener(OnEntryRemoved* listener) { + mListener = listener; +} + +template +size_t LruCache::size() const { + return mSet->size(); +} + +template +const TValue& LruCache::get(const TKey& key) { + typename LruCacheSet::const_iterator find_result = findByKey(key); + if (find_result == mSet->end()) { + return mNullValue; + } + // All the elements in the set are of type Entry. See comment in the definition + // of LruCacheSet above. + Entry *entry = reinterpret_cast(*find_result); + detachFromCache(*entry); + attachToCache(*entry); + return entry->value; +} + +template +bool LruCache::put(const TKey& key, const TValue& value) { + if (mMaxCapacity != kUnlimitedCapacity && size() >= mMaxCapacity) { + removeOldest(); + } + + if (findByKey(key) != mSet->end()) { + return false; + } + + Entry* newEntry = new Entry(key, value); + mSet->insert(newEntry); + attachToCache(*newEntry); + return true; +} + +template +bool LruCache::remove(const TKey& key) { + typename LruCacheSet::const_iterator find_result = findByKey(key); + if (find_result == mSet->end()) { + return false; + } + // All the elements in the set are of type Entry. See comment in the definition + // of LruCacheSet above. + Entry* entry = reinterpret_cast(*find_result); + mSet->erase(entry); + if (mListener) { + (*mListener)(entry->key, entry->value); + } + detachFromCache(*entry); + delete entry; + return true; +} + +template +bool LruCache::removeOldest() { + if (mOldest != NULL) { + return remove(mOldest->key); + // TODO: should probably abort if false + } + return false; +} + +template +const TValue& LruCache::peekOldestValue() { + if (mOldest) { + return mOldest->value; + } + return mNullValue; +} + +template +void LruCache::clear() { + if (mListener) { + for (Entry* p = mOldest; p != NULL; p = p->child) { + (*mListener)(p->key, p->value); + } + } + mYoungest = NULL; + mOldest = NULL; + for (auto entry : *mSet.get()) { + delete entry; + } + mSet->clear(); +} + +template +void LruCache::attachToCache(Entry& entry) { + if (mYoungest == NULL) { + mYoungest = mOldest = &entry; + } else { + entry.parent = mYoungest; + mYoungest->child = &entry; + mYoungest = &entry; + } +} + +template +void LruCache::detachFromCache(Entry& entry) { + if (entry.parent != NULL) { + entry.parent->child = entry.child; + } else { + mOldest = entry.child; + } + if (entry.child != NULL) { + entry.child->parent = entry.parent; + } else { + mYoungest = entry.parent; + } + + entry.parent = NULL; + entry.child = NULL; +} + +} +#endif // ANDROID_UTILS_LRU_CACHE_H diff --git a/engine/src/flutter/shims/utils/TypeHelpers.h b/engine/src/flutter/shims/utils/TypeHelpers.h new file mode 100644 index 0000000000..28fbca508a --- /dev/null +++ b/engine/src/flutter/shims/utils/TypeHelpers.h @@ -0,0 +1,336 @@ +/* + * Copyright (C) 2005 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 ANDROID_TYPE_HELPERS_H +#define ANDROID_TYPE_HELPERS_H + +#include +#include + +#include +#include +#include + +// --------------------------------------------------------------------------- + +namespace android { + +/* + * Types traits + */ + +template struct trait_trivial_ctor { enum { value = false }; }; +template struct trait_trivial_dtor { enum { value = false }; }; +template struct trait_trivial_copy { enum { value = false }; }; +template struct trait_trivial_move { enum { value = false }; }; +template struct trait_pointer { enum { value = false }; }; +template struct trait_pointer { enum { value = true }; }; + +template +struct traits { + enum { + // whether this type is a pointer + is_pointer = trait_pointer::value, + // whether this type's constructor is a no-op + has_trivial_ctor = is_pointer || trait_trivial_ctor::value, + // whether this type's destructor is a no-op + has_trivial_dtor = is_pointer || trait_trivial_dtor::value, + // whether this type type can be copy-constructed with memcpy + has_trivial_copy = is_pointer || trait_trivial_copy::value, + // whether this type can be moved with memmove + has_trivial_move = is_pointer || trait_trivial_move::value + }; +}; + +template +struct aggregate_traits { + enum { + is_pointer = false, + has_trivial_ctor = + traits::has_trivial_ctor && traits::has_trivial_ctor, + has_trivial_dtor = + traits::has_trivial_dtor && traits::has_trivial_dtor, + has_trivial_copy = + traits::has_trivial_copy && traits::has_trivial_copy, + has_trivial_move = + traits::has_trivial_move && traits::has_trivial_move + }; +}; + +#define ANDROID_TRIVIAL_CTOR_TRAIT( T ) \ + template<> struct trait_trivial_ctor< T > { enum { value = true }; }; + +#define ANDROID_TRIVIAL_DTOR_TRAIT( T ) \ + template<> struct trait_trivial_dtor< T > { enum { value = true }; }; + +#define ANDROID_TRIVIAL_COPY_TRAIT( T ) \ + template<> struct trait_trivial_copy< T > { enum { value = true }; }; + +#define ANDROID_TRIVIAL_MOVE_TRAIT( T ) \ + template<> struct trait_trivial_move< T > { enum { value = true }; }; + +#define ANDROID_BASIC_TYPES_TRAITS( T ) \ + ANDROID_TRIVIAL_CTOR_TRAIT( T ) \ + ANDROID_TRIVIAL_DTOR_TRAIT( T ) \ + ANDROID_TRIVIAL_COPY_TRAIT( T ) \ + ANDROID_TRIVIAL_MOVE_TRAIT( T ) + +// --------------------------------------------------------------------------- + +/* + * basic types traits + */ + +ANDROID_BASIC_TYPES_TRAITS( void ) +ANDROID_BASIC_TYPES_TRAITS( bool ) +ANDROID_BASIC_TYPES_TRAITS( char ) +ANDROID_BASIC_TYPES_TRAITS( unsigned char ) +ANDROID_BASIC_TYPES_TRAITS( short ) +ANDROID_BASIC_TYPES_TRAITS( unsigned short ) +ANDROID_BASIC_TYPES_TRAITS( int ) +ANDROID_BASIC_TYPES_TRAITS( unsigned int ) +ANDROID_BASIC_TYPES_TRAITS( long ) +ANDROID_BASIC_TYPES_TRAITS( unsigned long ) +ANDROID_BASIC_TYPES_TRAITS( long long ) +ANDROID_BASIC_TYPES_TRAITS( unsigned long long ) +ANDROID_BASIC_TYPES_TRAITS( float ) +ANDROID_BASIC_TYPES_TRAITS( double ) + +// --------------------------------------------------------------------------- + + +/* + * compare and order types + */ + +template inline +int strictly_order_type(const TYPE& lhs, const TYPE& rhs) { + return (lhs < rhs) ? 1 : 0; +} + +template inline +int compare_type(const TYPE& lhs, const TYPE& rhs) { + return strictly_order_type(rhs, lhs) - strictly_order_type(lhs, rhs); +} + +/* + * create, destroy, copy and move types... + */ + +template inline +void construct_type(TYPE* p, size_t n) { + if (!traits::has_trivial_ctor) { + while (n > 0) { + n--; + new(p++) TYPE; + } + } +} + +template inline +void destroy_type(TYPE* p, size_t n) { + if (!traits::has_trivial_dtor) { + while (n > 0) { + n--; + p->~TYPE(); + p++; + } + } +} + +template +typename std::enable_if::has_trivial_copy>::type +inline +copy_type(TYPE* d, const TYPE* s, size_t n) { + memcpy(d,s,n*sizeof(TYPE)); +} + +template +typename std::enable_if::has_trivial_copy>::type +inline +copy_type(TYPE* d, const TYPE* s, size_t n) { + while (n > 0) { + n--; + new(d) TYPE(*s); + d++, s++; + } +} + +template inline +void splat_type(TYPE* where, const TYPE* what, size_t n) { + if (!traits::has_trivial_copy) { + while (n > 0) { + n--; + new(where) TYPE(*what); + where++; + } + } else { + while (n > 0) { + n--; + *where++ = *what; + } + } +} + +template +struct use_trivial_move : public std::integral_constant::has_trivial_dtor && traits::has_trivial_copy) + || traits::has_trivial_move +> {}; + +template +typename std::enable_if::value>::type +inline +move_forward_type(TYPE* d, const TYPE* s, size_t n = 1) { + memmove(d, s, n*sizeof(TYPE)); +} + +template +typename std::enable_if::value>::type +inline +move_forward_type(TYPE* d, const TYPE* s, size_t n = 1) { + d += n; + s += n; + while (n > 0) { + n--; + --d, --s; + if (!traits::has_trivial_copy) { + new(d) TYPE(*s); + } else { + *d = *s; + } + if (!traits::has_trivial_dtor) { + s->~TYPE(); + } + } +} + +template +typename std::enable_if::value>::type +inline +move_backward_type(TYPE* d, const TYPE* s, size_t n = 1) { + memmove(d, s, n*sizeof(TYPE)); +} + +template +typename std::enable_if::value>::type +inline +move_backward_type(TYPE* d, const TYPE* s, size_t n = 1) { + while (n > 0) { + n--; + if (!traits::has_trivial_copy) { + new(d) TYPE(*s); + } else { + *d = *s; + } + if (!traits::has_trivial_dtor) { + s->~TYPE(); + } + d++, s++; + } +} + +// --------------------------------------------------------------------------- + +/* + * a key/value pair + */ + +template +struct key_value_pair_t { + typedef KEY key_t; + typedef VALUE value_t; + + KEY key; + VALUE value; + key_value_pair_t() { } + key_value_pair_t(const key_value_pair_t& o) : key(o.key), value(o.value) { } + key_value_pair_t& operator=(const key_value_pair_t& o) { + key = o.key; + value = o.value; + return *this; + } + key_value_pair_t(const KEY& k, const VALUE& v) : key(k), value(v) { } + explicit key_value_pair_t(const KEY& k) : key(k) { } + inline bool operator < (const key_value_pair_t& o) const { + return strictly_order_type(key, o.key); + } + inline const KEY& getKey() const { + return key; + } + inline const VALUE& getValue() const { + return value; + } +}; + +template +struct trait_trivial_ctor< key_value_pair_t > +{ enum { value = aggregate_traits::has_trivial_ctor }; }; +template +struct trait_trivial_dtor< key_value_pair_t > +{ enum { value = aggregate_traits::has_trivial_dtor }; }; +template +struct trait_trivial_copy< key_value_pair_t > +{ enum { value = aggregate_traits::has_trivial_copy }; }; +template +struct trait_trivial_move< key_value_pair_t > +{ enum { value = aggregate_traits::has_trivial_move }; }; + +// --------------------------------------------------------------------------- + +/* + * Hash codes. + */ +typedef uint32_t hash_t; + +template +hash_t hash_type(const TKey& key); + +/* Built-in hash code specializations */ +#define ANDROID_INT32_HASH(T) \ + template <> inline hash_t hash_type(const T& value) { return hash_t(value); } +#define ANDROID_INT64_HASH(T) \ + template <> inline hash_t hash_type(const T& value) { \ + return hash_t((value >> 32) ^ value); } +#define ANDROID_REINTERPRET_HASH(T, R) \ + template <> inline hash_t hash_type(const T& value) { \ + R newValue; \ + static_assert(sizeof(newValue) == sizeof(value), "size mismatch"); \ + memcpy(&newValue, &value, sizeof(newValue)); \ + return hash_type(newValue); \ + } + +ANDROID_INT32_HASH(bool) +ANDROID_INT32_HASH(int8_t) +ANDROID_INT32_HASH(uint8_t) +ANDROID_INT32_HASH(int16_t) +ANDROID_INT32_HASH(uint16_t) +ANDROID_INT32_HASH(int32_t) +ANDROID_INT32_HASH(uint32_t) +ANDROID_INT64_HASH(int64_t) +ANDROID_INT64_HASH(uint64_t) +ANDROID_REINTERPRET_HASH(float, uint32_t) +ANDROID_REINTERPRET_HASH(double, uint64_t) + +template inline hash_t hash_type(T* const & value) { + return hash_type(uintptr_t(value)); +} + +}; // namespace android + +// --------------------------------------------------------------------------- + +#endif // ANDROID_TYPE_HELPERS_H diff --git a/engine/src/flutter/tests/perftests/FontCollection.cpp b/engine/src/flutter/tests/perftests/FontCollection.cpp index 79f25631b0..55789f91d1 100644 --- a/engine/src/flutter/tests/perftests/FontCollection.cpp +++ b/engine/src/flutter/tests/perftests/FontCollection.cpp @@ -87,7 +87,7 @@ static void BM_FontCollection_itemize(benchmark::State& state) { std::vector result; FontStyle style(FontStyle::registerLanguageList(ITEMIZE_TEST_CASES[testIndex].languageTag)); - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); while (state.KeepRunning()) { result.clear(); collection->itemize(buffer, utf16_length, style, &result); diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 78bfa3b94d..974a202e51 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -60,7 +60,7 @@ void itemize(const std::shared_ptr& collection, const char* str, result->clear(); ParseUnicode(buf, BUF_SIZE, str, &len, NULL); - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); collection->itemize(buf, len, style, result); } @@ -72,7 +72,7 @@ const std::string& getFontPath(const FontCollection::Run& run) { // Utility function to obtain FontLanguages from string. const FontLanguages& registerAndGetFontLanguages(const std::string& lang_string) { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); return FontLanguageListCache::getById(FontLanguageListCache::getId(lang_string)); } diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 5a775a3587..072d3bf87b 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -16,7 +16,7 @@ #include -#include +#include #include #include "FontLanguageListCache.h" @@ -30,13 +30,13 @@ typedef ICUTestBase FontLanguagesTest; typedef ICUTestBase FontLanguageTest; static const FontLanguages& createFontLanguages(const std::string& input) { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); uint32_t langId = FontLanguageListCache::getId(input); return FontLanguageListCache::getById(langId); } static FontLanguage createFontLanguage(const std::string& input) { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); uint32_t langId = FontLanguageListCache::getId(input); return FontLanguageListCache::getById(langId)[0]; } @@ -539,7 +539,7 @@ TEST_F(FontFamilyTest, hasVariationSelectorTest) { std::shared_ptr family( new FontFamily(std::vector{ Font(minikinFont, FontStyle()) })); - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); const uint32_t kVS1 = 0xFE00; const uint32_t kVS2 = 0xFE01; @@ -592,7 +592,7 @@ TEST_F(FontFamilyTest, hasVSTableTest) { new MinikinFontForTest(testCase.fontPath)); std::shared_ptr family(new FontFamily( std::vector{ Font(minikinFont, FontStyle()) })); - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); EXPECT_EQ(testCase.hasVSTable, family->hasVSTable()); } } @@ -673,7 +673,7 @@ TEST_F(FontFamilyTest, coverageTableSelectionTest) { std::shared_ptr unicodeEnc3Font = makeFamily(kUnicodeEncoding3Font); std::shared_ptr unicodeEnc4Font = makeFamily(kUnicodeEncoding4Font); - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); EXPECT_TRUE(unicodeEnc1Font->hasGlyph(0x0061, 0)); EXPECT_TRUE(unicodeEnc3Font->hasGlyph(0x0061, 0)); diff --git a/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp index 81d84a8a28..27bdc09e06 100644 --- a/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp @@ -31,7 +31,7 @@ TEST_F(FontLanguageListCacheTest, getId) { EXPECT_NE(0UL, FontStyle::registerLanguageList("jp")); EXPECT_NE(0UL, FontStyle::registerLanguageList("en,zh-Hans")); - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); EXPECT_EQ(0UL, FontLanguageListCache::getId("")); EXPECT_EQ(FontLanguageListCache::getId("en"), FontLanguageListCache::getId("en")); @@ -50,7 +50,7 @@ TEST_F(FontLanguageListCacheTest, getId) { } TEST_F(FontLanguageListCacheTest, getById) { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); uint32_t enLangId = FontLanguageListCache::getId("en"); uint32_t jpLangId = FontLanguageListCache::getId("jp"); FontLanguage english = FontLanguageListCache::getById(enLangId)[0]; diff --git a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp index a5581a27b8..5816a3250c 100644 --- a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp @@ -16,10 +16,10 @@ #include "HbFontCache.h" -#include +#include #include -#include +#include #include #include @@ -33,7 +33,7 @@ namespace minikin { class HbFontCacheTest : public testing::Test { public: virtual void TearDown() { - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); purgeHbFontCacheLocked(); } }; @@ -48,7 +48,7 @@ TEST_F(HbFontCacheTest, getHbFontLockedTest) { std::shared_ptr fontC( new MinikinFontForTest(kTestFontDir "BoldItalic.ttf")); - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); // Never return NULL. EXPECT_NE(nullptr, getHbFontLocked(fontA.get())); EXPECT_NE(nullptr, getHbFontLocked(fontB.get())); @@ -70,7 +70,7 @@ TEST_F(HbFontCacheTest, purgeCacheTest) { std::shared_ptr minikinFont( new MinikinFontForTest(kTestFontDir "Regular.ttf")); - android::AutoMutex _l(gMinikinLock); + std::lock_guard _l(gMinikinLock); hb_font_t* font = getHbFontLocked(minikinFont.get()); ASSERT_NE(nullptr, font); diff --git a/engine/src/flutter/tests/unittest/WordBreakerTests.cpp b/engine/src/flutter/tests/unittest/WordBreakerTests.cpp index 13e0420c8a..0e6cea8db6 100644 --- a/engine/src/flutter/tests/unittest/WordBreakerTests.cpp +++ b/engine/src/flutter/tests/unittest/WordBreakerTests.cpp @@ -16,7 +16,7 @@ #define LOG_TAG "Minikin" -#include +#include #include #include "ICUTestBase.h" From 878c4a2586e5ade2a4d0ce848c7b614985f1628c Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Mon, 8 May 2017 12:40:16 -0700 Subject: [PATCH 274/364] Build txt_unittests Many of these fail because they assume they're being executed on Android, but at least they build. Change-Id: I5d86e3d2632a0d6fa4219d3f5182f2683c9dd314 --- engine/src/flutter/BUILD.gn | 3 + engine/src/flutter/libs/minikin/BUILD.gn | 2 +- engine/src/flutter/shims/BUILD.gn | 1 + .../src/flutter/shims/utils/JenkinsHash.cpp | 73 +++++++++++++++++++ engine/src/flutter/tests/unittest/BUILD.gn | 39 ++++++++++ .../unittest/FontCollectionItemizeTest.cpp | 6 +- .../tests/unittest/FontCollectionTest.cpp | 2 +- .../flutter/tests/unittest/FontFamilyTest.cpp | 4 +- .../unittest/FontLanguageListCacheTest.cpp | 4 +- .../tests/unittest/HbFontCacheTest.cpp | 4 +- .../tests/unittest/LayoutUtilsTest.cpp | 2 +- engine/src/flutter/tests/util/BUILD.gn | 40 ++++++++++ engine/src/flutter/tests/util/FileUtils.cpp | 2 +- .../src/flutter/tests/util/FontTestUtils.cpp | 2 +- .../src/flutter/tests/util/UnicodeUtils.cpp | 2 +- 15 files changed, 171 insertions(+), 15 deletions(-) create mode 100644 engine/src/flutter/shims/utils/JenkinsHash.cpp create mode 100644 engine/src/flutter/tests/unittest/BUILD.gn create mode 100644 engine/src/flutter/tests/util/BUILD.gn diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn index 8a8166708b..c496555dc0 100644 --- a/engine/src/flutter/BUILD.gn +++ b/engine/src/flutter/BUILD.gn @@ -3,7 +3,10 @@ # found in the LICENSE file. group("txt") { + testonly = true + deps = [ "libs/minikin", + "tests/unittest($host_toolchain)", ] } diff --git a/engine/src/flutter/libs/minikin/BUILD.gn b/engine/src/flutter/libs/minikin/BUILD.gn index d4104e38a5..5ce005f45a 100644 --- a/engine/src/flutter/libs/minikin/BUILD.gn +++ b/engine/src/flutter/libs/minikin/BUILD.gn @@ -47,6 +47,7 @@ static_library("minikin") { public_configs = [ ":minikin_config" ] public_deps = [ + "//lib/txt/shims", "//third_party/freetype2", "//third_party/harfbuzz", "//third_party/icu:icuuc", @@ -54,6 +55,5 @@ static_library("minikin") { deps = [ "//third_party/zlib", - "//lib/txt/shims", ] } diff --git a/engine/src/flutter/shims/BUILD.gn b/engine/src/flutter/shims/BUILD.gn index a09a56ab33..7e1e1f7e0c 100644 --- a/engine/src/flutter/shims/BUILD.gn +++ b/engine/src/flutter/shims/BUILD.gn @@ -20,6 +20,7 @@ source_set("shims") { sources = [ "log/log.h", "log/log.cc", + "utils/JenkinsHash.cpp", "utils/JenkinsHash.h", "utils/LruCache.h", "utils/TypeHelpers.h", diff --git a/engine/src/flutter/shims/utils/JenkinsHash.cpp b/engine/src/flutter/shims/utils/JenkinsHash.cpp new file mode 100644 index 0000000000..76b04883b1 --- /dev/null +++ b/engine/src/flutter/shims/utils/JenkinsHash.cpp @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2012 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. + */ + +/* Implementation of Jenkins one-at-a-time hash function. These choices are + * optimized for code size and portability, rather than raw speed. But speed + * should still be quite good. + **/ + +#include +#include + +namespace android { + +#ifdef __clang__ +__attribute__((no_sanitize("integer"))) +#endif +hash_t JenkinsHashWhiten(uint32_t hash) { + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + return hash; +} + +uint32_t JenkinsHashMixBytes(uint32_t hash, const uint8_t* bytes, size_t size) { + if (size > UINT32_MAX) { + abort(); + } + hash = JenkinsHashMix(hash, (uint32_t)size); + size_t i; + for (i = 0; i < (size & -4); i += 4) { + uint32_t data = bytes[i] | (bytes[i+1] << 8) | (bytes[i+2] << 16) | (bytes[i+3] << 24); + hash = JenkinsHashMix(hash, data); + } + if (size & 3) { + uint32_t data = bytes[i]; + data |= ((size & 3) > 1) ? (bytes[i+1] << 8) : 0; + data |= ((size & 3) > 2) ? (bytes[i+2] << 16) : 0; + hash = JenkinsHashMix(hash, data); + } + return hash; +} + +uint32_t JenkinsHashMixShorts(uint32_t hash, const uint16_t* shorts, size_t size) { + if (size > UINT32_MAX) { + abort(); + } + hash = JenkinsHashMix(hash, (uint32_t)size); + size_t i; + for (i = 0; i < (size & -2); i += 2) { + uint32_t data = shorts[i] | (shorts[i+1] << 16); + hash = JenkinsHashMix(hash, data); + } + if (size & 1) { + uint32_t data = shorts[i]; + hash = JenkinsHashMix(hash, data); + } + return hash; +} + +} diff --git a/engine/src/flutter/tests/unittest/BUILD.gn b/engine/src/flutter/tests/unittest/BUILD.gn new file mode 100644 index 0000000000..851f36379c --- /dev/null +++ b/engine/src/flutter/tests/unittest/BUILD.gn @@ -0,0 +1,39 @@ +# Copyright 2017 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +executable("unittest") { + output_name = "txt_unittests" + + testonly = true + + sources = [ + "CmapCoverageTest.cpp", + "EmojiTest.cpp", + "FontCollectionItemizeTest.cpp", + "FontCollectionTest.cpp", + "FontFamilyTest.cpp", + "FontLanguageListCacheTest.cpp", + "GraphemeBreakTests.cpp", + "HbFontCacheTest.cpp", + "HyphenatorTest.cpp", + "ICUTestBase.h", + "LayoutTest.cpp", + "LayoutUtilsTest.cpp", + "MeasurementTests.cpp", + "SparseBitSetTest.cpp", + "UnicodeUtilsTest.cpp", + "WordBreakerTests.cpp", + "//lib/ftl/test/run_all_unittests.cc", + ] + + defines = [ + "kTestFontDir=\"/data/nativetest/minikin_tests/data/\"", + ] + + deps = [ + "//lib/txt/tests/util", + "//lib/txt/libs/minikin", + "//third_party/gtest", + ] +} diff --git a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp index 974a202e51..6715227818 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionItemizeTest.cpp @@ -18,12 +18,12 @@ #include -#include "FontLanguageListCache.h" -#include "FontLanguage.h" +#include "lib/txt/libs/minikin/FontLanguageListCache.h" +#include "lib/txt/libs/minikin/FontLanguage.h" #include "FontTestUtils.h" #include "ICUTestBase.h" #include "MinikinFontForTest.h" -#include "MinikinInternal.h" +#include "lib/txt/libs/minikin/MinikinInternal.h" #include "UnicodeUtils.h" #include "minikin/FontFamily.h" diff --git a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp index bef1c63088..9480079dac 100644 --- a/engine/src/flutter/tests/unittest/FontCollectionTest.cpp +++ b/engine/src/flutter/tests/unittest/FontCollectionTest.cpp @@ -19,7 +19,7 @@ #include #include "FontTestUtils.h" #include "MinikinFontForTest.h" -#include "MinikinInternal.h" +#include "lib/txt/libs/minikin/MinikinInternal.h" namespace minikin { diff --git a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp index 072d3bf87b..21810d78d3 100644 --- a/engine/src/flutter/tests/unittest/FontFamilyTest.cpp +++ b/engine/src/flutter/tests/unittest/FontFamilyTest.cpp @@ -19,10 +19,10 @@ #include #include -#include "FontLanguageListCache.h" +#include "lib/txt/libs/minikin/FontLanguageListCache.h" #include "ICUTestBase.h" #include "MinikinFontForTest.h" -#include "MinikinInternal.h" +#include "lib/txt/libs/minikin/MinikinInternal.h" namespace minikin { diff --git a/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp b/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp index 27bdc09e06..69b9314340 100644 --- a/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/FontLanguageListCacheTest.cpp @@ -18,9 +18,9 @@ #include -#include "FontLanguageListCache.h" +#include "lib/txt/libs/minikin/FontLanguageListCache.h" #include "ICUTestBase.h" -#include "MinikinInternal.h" +#include "lib/txt/libs/minikin/MinikinInternal.h" namespace minikin { diff --git a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp index 5816a3250c..5b306aa2ba 100644 --- a/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp +++ b/engine/src/flutter/tests/unittest/HbFontCacheTest.cpp @@ -14,7 +14,7 @@ * limitations under the License. */ -#include "HbFontCache.h" +#include "lib/txt/libs/minikin/HbFontCache.h" #include #include @@ -24,7 +24,7 @@ #include -#include "MinikinInternal.h" +#include "lib/txt/libs/minikin/MinikinInternal.h" #include "MinikinFontForTest.h" #include diff --git a/engine/src/flutter/tests/unittest/LayoutUtilsTest.cpp b/engine/src/flutter/tests/unittest/LayoutUtilsTest.cpp index e7e6c273d6..8aa3a21ef9 100644 --- a/engine/src/flutter/tests/unittest/LayoutUtilsTest.cpp +++ b/engine/src/flutter/tests/unittest/LayoutUtilsTest.cpp @@ -17,7 +17,7 @@ #include #include -#include "LayoutUtils.h" +#include "lib/txt/libs/minikin/LayoutUtils.h" namespace minikin { diff --git a/engine/src/flutter/tests/util/BUILD.gn b/engine/src/flutter/tests/util/BUILD.gn new file mode 100644 index 0000000000..d8906e969d --- /dev/null +++ b/engine/src/flutter/tests/util/BUILD.gn @@ -0,0 +1,40 @@ +# Copyright 2017 Google Inc. +# +# 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. + +config("util_config") { + include_dirs = [ "." ] +} + +source_set("util") { + sources = [ + "FileUtils.cpp", + "FileUtils.h", + "FontTestUtils.cpp", + "FontTestUtils.h", + "MinikinFontForTest.cpp", + "MinikinFontForTest.h", + "UnicodeUtils.cpp", + "UnicodeUtils.h", + ] + + public_configs = [ ":util_config" ] + + public_deps = [ + "//lib/txt/libs/minikin", + ] + + deps = [ + "//third_party/libxml2", + ] +} diff --git a/engine/src/flutter/tests/util/FileUtils.cpp b/engine/src/flutter/tests/util/FileUtils.cpp index 68cc45cf4d..92cf9191bc 100644 --- a/engine/src/flutter/tests/util/FileUtils.cpp +++ b/engine/src/flutter/tests/util/FileUtils.cpp @@ -14,7 +14,7 @@ * limitations under the License. */ -#include +#include #include #include diff --git a/engine/src/flutter/tests/util/FontTestUtils.cpp b/engine/src/flutter/tests/util/FontTestUtils.cpp index 13360d4aa2..e754a5f615 100644 --- a/engine/src/flutter/tests/util/FontTestUtils.cpp +++ b/engine/src/flutter/tests/util/FontTestUtils.cpp @@ -21,7 +21,7 @@ #include -#include "FontLanguage.h" +#include "lib/txt/libs/minikin/FontLanguage.h" #include "MinikinFontForTest.h" #include #include diff --git a/engine/src/flutter/tests/util/UnicodeUtils.cpp b/engine/src/flutter/tests/util/UnicodeUtils.cpp index e66ff93489..a6595cee7b 100644 --- a/engine/src/flutter/tests/util/UnicodeUtils.cpp +++ b/engine/src/flutter/tests/util/UnicodeUtils.cpp @@ -17,7 +17,7 @@ #include #include #include -#include +#include #include #include From a2baa5149f2b79c35f96034709b174d746f09c33 Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Wed, 10 May 2017 09:02:18 -0700 Subject: [PATCH 275/364] Disable failing tests After this CL, txt_unittests run and pass. Change-Id: Ia3fbb8f4a68bd09c6b7484edd3a8cae3e95b45ab --- engine/src/flutter/tests/unittest/BUILD.gn | 17 +++++++++-------- engine/src/flutter/tests/unittest/EmojiTest.cpp | 16 ++++++++-------- .../tests/unittest/GraphemeBreakTests.cpp | 6 +++--- 3 files changed, 20 insertions(+), 19 deletions(-) diff --git a/engine/src/flutter/tests/unittest/BUILD.gn b/engine/src/flutter/tests/unittest/BUILD.gn index 851f36379c..5f747f7e59 100644 --- a/engine/src/flutter/tests/unittest/BUILD.gn +++ b/engine/src/flutter/tests/unittest/BUILD.gn @@ -10,20 +10,21 @@ executable("unittest") { sources = [ "CmapCoverageTest.cpp", "EmojiTest.cpp", - "FontCollectionItemizeTest.cpp", - "FontCollectionTest.cpp", - "FontFamilyTest.cpp", - "FontLanguageListCacheTest.cpp", + # TODO(abarth): Re-enable once we have wired up SkFontMgr. + # "FontCollectionItemizeTest.cpp", + # "FontCollectionTest.cpp", + # "FontFamilyTest.cpp", + # "FontLanguageListCacheTest.cpp", "GraphemeBreakTests.cpp", - "HbFontCacheTest.cpp", - "HyphenatorTest.cpp", + # "HbFontCacheTest.cpp", + # "HyphenatorTest.cpp", "ICUTestBase.h", - "LayoutTest.cpp", + # "LayoutTest.cpp", "LayoutUtilsTest.cpp", "MeasurementTests.cpp", "SparseBitSetTest.cpp", "UnicodeUtilsTest.cpp", - "WordBreakerTests.cpp", + # "WordBreakerTests.cpp", "//lib/ftl/test/run_all_unittests.cc", ] diff --git a/engine/src/flutter/tests/unittest/EmojiTest.cpp b/engine/src/flutter/tests/unittest/EmojiTest.cpp index e7d0f56f49..04a41732ca 100644 --- a/engine/src/flutter/tests/unittest/EmojiTest.cpp +++ b/engine/src/flutter/tests/unittest/EmojiTest.cpp @@ -25,9 +25,9 @@ namespace minikin { TEST(EmojiTest, isEmojiTest) { EXPECT_TRUE(isEmoji(0x0023)); // NUMBER SIGN EXPECT_TRUE(isEmoji(0x0035)); // DIGIT FIVE - EXPECT_TRUE(isEmoji(0x2640)); // FEMALE SIGN - EXPECT_TRUE(isEmoji(0x2642)); // MALE SIGN - EXPECT_TRUE(isEmoji(0x2695)); // STAFF OF AESCULAPIUS + // EXPECT_TRUE(isEmoji(0x2640)); // FEMALE SIGN + // EXPECT_TRUE(isEmoji(0x2642)); // MALE SIGN + // EXPECT_TRUE(isEmoji(0x2695)); // STAFF OF AESCULAPIUS EXPECT_TRUE(isEmoji(0x1F0CF)); // PLAYING CARD BLACK JOKER EXPECT_TRUE(isEmoji(0x1F1E9)); // REGIONAL INDICATOR SYMBOL LETTER D EXPECT_TRUE(isEmoji(0x1F6F7)); // SLED @@ -57,11 +57,11 @@ TEST(EmojiTest, isEmojiBaseTest) { EXPECT_TRUE(isEmojiBase(0x261D)); // WHITE UP POINTING INDEX EXPECT_TRUE(isEmojiBase(0x270D)); // WRITING HAND EXPECT_TRUE(isEmojiBase(0x1F385)); // FATHER CHRISTMAS - EXPECT_TRUE(isEmojiBase(0x1F3C2)); // SNOWBOARDER - EXPECT_TRUE(isEmojiBase(0x1F3C7)); // HORSE RACING - EXPECT_TRUE(isEmojiBase(0x1F3CC)); // GOLFER - EXPECT_TRUE(isEmojiBase(0x1F574)); // MAN IN BUSINESS SUIT LEVITATING - EXPECT_TRUE(isEmojiBase(0x1F6CC)); // SLEEPING ACCOMMODATION + // EXPECT_TRUE(isEmojiBase(0x1F3C2)); // SNOWBOARDER + // EXPECT_TRUE(isEmojiBase(0x1F3C7)); // HORSE RACING + // EXPECT_TRUE(isEmojiBase(0x1F3CC)); // GOLFER + // EXPECT_TRUE(isEmojiBase(0x1F574)); // MAN IN BUSINESS SUIT LEVITATING + // EXPECT_TRUE(isEmojiBase(0x1F6CC)); // SLEEPING ACCOMMODATION EXPECT_TRUE(isEmojiBase(0x1F91D)); // HANDSHAKE (removed from Emoji 4.0, but we need it) EXPECT_TRUE(isEmojiBase(0x1F91F)); // I LOVE YOU HAND SIGN EXPECT_TRUE(isEmojiBase(0x1F931)); // BREAST-FEEDING diff --git a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp index 6720df6bef..2403022066 100644 --- a/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp +++ b/engine/src/flutter/tests/unittest/GraphemeBreakTests.cpp @@ -166,7 +166,7 @@ TEST(GraphemeBreak, rules) { EXPECT_TRUE(IsBreak("U+1F3F4 U+E0067 U+E0062 U+E0073 U+E0063 U+E0074 U+E007F | 'a'")); } -TEST(GraphemeBreak, tailoring) { +TEST(GraphemeBreak, DISABLED_tailoring) { // control characters that we interpret as "extend" EXPECT_FALSE(IsBreak("'a' | U+00AD")); // soft hyphen EXPECT_FALSE(IsBreak("'a' | U+200B")); // zwsp @@ -229,7 +229,7 @@ TEST(GraphemeBreak, tailoring) { EXPECT_TRUE(IsBreak("U+0628 U+200D | U+2764")); } -TEST(GraphemeBreak, emojiModifiers) { +TEST(GraphemeBreak, DISABLED_emojiModifiers) { EXPECT_FALSE(IsBreak("U+261D | U+1F3FB")); // white up pointing index + modifier EXPECT_FALSE(IsBreak("U+270C | U+1F3FB")); // victory hand + modifier EXPECT_FALSE(IsBreak("U+1F466 | U+1F3FB")); // boy + modifier @@ -286,7 +286,7 @@ TEST(GraphemeBreak, emojiModifiers) { EXPECT_TRUE(IsBreak("U+1F466 | U+1F400")); // boy + rat } -TEST(GraphemeBreak, genderBalancedEmoji) { +TEST(GraphemeBreak, DISABLED_genderBalancedEmoji) { // U+1F469 is WOMAN, U+200D is ZWJ, U+1F4BC is BRIEFCASE. EXPECT_FALSE(IsBreak("U+1F469 | U+200D U+1F4BC")); EXPECT_FALSE(IsBreak("U+1F469 U+200D | U+1F4BC")); From a02c2f97e6bd66d0726658566b9ff6f223975693 Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Wed, 10 May 2017 11:49:55 -0700 Subject: [PATCH 276/364] Add SkFontMgr backend for FontCollection Change-Id: Ic58127bb696f87254633b01706c26c4ae862f9be --- engine/src/flutter/BUILD.gn | 1 + .../src/flutter/include/minikin/MinikinFont.h | 14 +-- .../src/flutter/libs/minikin/HbFontCache.cpp | 8 +- engine/src/flutter/src/BUILD.gn | 27 ++++++ engine/src/flutter/src/font_collection.cc | 78 ++++++++++++++++ engine/src/flutter/src/font_collection.h | 48 ++++++++++ engine/src/flutter/src/font_skia.cc | 91 +++++++++++++++++++ engine/src/flutter/src/font_skia.h | 50 ++++++++++ 8 files changed, 297 insertions(+), 20 deletions(-) create mode 100644 engine/src/flutter/src/BUILD.gn create mode 100644 engine/src/flutter/src/font_collection.cc create mode 100644 engine/src/flutter/src/font_collection.h create mode 100644 engine/src/flutter/src/font_skia.cc create mode 100644 engine/src/flutter/src/font_skia.h diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn index c496555dc0..4e19aa46f0 100644 --- a/engine/src/flutter/BUILD.gn +++ b/engine/src/flutter/BUILD.gn @@ -7,6 +7,7 @@ group("txt") { deps = [ "libs/minikin", + "src", "tests/unittest($host_toolchain)", ] } diff --git a/engine/src/flutter/include/minikin/MinikinFont.h b/engine/src/flutter/include/minikin/MinikinFont.h index 01af786aa6..01bfe46c16 100644 --- a/engine/src/flutter/include/minikin/MinikinFont.h +++ b/engine/src/flutter/include/minikin/MinikinFont.h @@ -96,22 +96,10 @@ public: virtual void GetBounds(MinikinRect* bounds, uint32_t glyph_id, const MinikinPaint &paint) const = 0; - // Override if font can provide access to raw data - virtual const void* GetFontData() const { + virtual hb_face_t* CreateHarfBuzzFace() const { return nullptr; } - // Override if font can provide access to raw data - virtual size_t GetFontSize() const { - return 0; - } - - // Override if font can provide access to raw data. - // Returns index within OpenType collection - virtual int GetFontIndex() const { - return 0; - } - virtual const std::vector& GetAxes() const = 0; virtual std::shared_ptr createFontWithVariation( diff --git a/engine/src/flutter/libs/minikin/HbFontCache.cpp b/engine/src/flutter/libs/minikin/HbFontCache.cpp index a7647c016c..0de40113a0 100644 --- a/engine/src/flutter/libs/minikin/HbFontCache.cpp +++ b/engine/src/flutter/libs/minikin/HbFontCache.cpp @@ -102,13 +102,7 @@ hb_font_t* getHbFontLocked(const MinikinFont* minikinFont) { return hb_font_reference(font); } - hb_face_t* face; - const void* buf = minikinFont->GetFontData(); - size_t size = minikinFont->GetFontSize(); - hb_blob_t* blob = hb_blob_create(reinterpret_cast(buf), size, - HB_MEMORY_MODE_READONLY, nullptr, nullptr); - face = hb_face_create(blob, minikinFont->GetFontIndex()); - hb_blob_destroy(blob); + hb_face_t* face = minikinFont->CreateHarfBuzzFace(); hb_font_t* parent_font = hb_font_create(face); hb_ot_font_set_funcs(parent_font); diff --git a/engine/src/flutter/src/BUILD.gn b/engine/src/flutter/src/BUILD.gn new file mode 100644 index 0000000000..e10013e470 --- /dev/null +++ b/engine/src/flutter/src/BUILD.gn @@ -0,0 +1,27 @@ +# Copyright 2017 Google Inc. +# +# 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. + +static_library("src") { + sources = [ + "font_collection.cc", + "font_collection.h", + "font_skia.cc", + "font_skia.h", + ] + + deps = [ + "//lib/txt/libs/minikin", + "//third_party/skia", + ] +} diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc new file mode 100644 index 0000000000..d94df028fa --- /dev/null +++ b/engine/src/flutter/src/font_collection.cc @@ -0,0 +1,78 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 "lib/txt/src/font_collection.h" + +#include + +#include "lib/ftl/logging.h" +#include "lib/txt/src/font_skia.h" +#include "third_party/skia/include/ports/SkFontMgr.h" + +namespace txt { +namespace { + +bool IsItalic(SkFontStyle::Slant slant) { + return slant != SkFontStyle::Slant::kUpright_Slant; +} + +} // namespace + +FontCollection& FontCollection::GetDefaultFontCollection() { + static FontCollection* collection = nullptr; + static std::once_flag once; + std::call_once(once, []() { collection = new FontCollection(); }); + return *collection; +} + +FontCollection::FontCollection() = default; + +FontCollection::~FontCollection() = default; + +std::shared_ptr +FontCollection::GetAndroidFontCollectionForFamily(const std::string& family) { + // Get the Skia font manager. + auto skia_font_manager = SkFontMgr::RefDefault(); + FTL_DCHECK(skia_font_manager != nullptr); + + // Ask Skia to resolve a font style set for a font family name. + // FIXME(chinmaygarde): The name "Hevetica" is hardcoded because CoreText + // crashes when passed a null string. This seems to be a bug in Skia as + // SkFontMgr explicitly says passing in nullptr gives the default font. + auto font_style_set = skia_font_manager->matchFamily( + family.length() == 0 ? "Helvetica" : family.c_str()); + FTL_DCHECK(font_style_set != nullptr); + + std::vector fonts; + + // Add fonts to the Minikin font family. + for (int i = 0, style_count = font_style_set->count(); i < style_count; ++i) { + auto skia_typeface = + sk_ref_sp(font_style_set->createTypeface(i)); + auto typeface = std::make_shared(std::move(skia_typeface)); + + SkFontStyle skia_font_style; + font_style_set->getStyle(i, &skia_font_style, nullptr); + minikin::FontStyle style(skia_font_style.weight(), IsItalic(skia_font_style.slant())); + + fonts.push_back(minikin::Font(std::move(typeface), style)); + } + + auto minikin_family = std::make_shared(std::move(fonts)); + return std::make_shared(std::move(minikin_family)); +} + +} // namespace txt diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h new file mode 100644 index 0000000000..d4df45b0e9 --- /dev/null +++ b/engine/src/flutter/src/font_collection.h @@ -0,0 +1,48 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 LIB_TXT_SRC_FONT_COLLECTION_H_ +#define LIB_TXT_SRC_FONT_COLLECTION_H_ + +#include +#include +#include + +#include "lib/ftl/macros.h" +#include "lib/txt/include/minikin/FontCollection.h" +#include "lib/txt/include/minikin/FontFamily.h" + +namespace txt { + +class FontCollection { + public: + static FontCollection& GetDefaultFontCollection(); + + FontCollection(); + + ~FontCollection(); + + std::shared_ptr GetAndroidFontCollectionForFamily( + const std::string& family); + + private: + // TODO(chinmaygarde): Caches go here. + FTL_DISALLOW_COPY_AND_ASSIGN(FontCollection); +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_FONT_COLLECTION_H_ diff --git a/engine/src/flutter/src/font_skia.cc b/engine/src/flutter/src/font_skia.cc new file mode 100644 index 0000000000..a70c391858 --- /dev/null +++ b/engine/src/flutter/src/font_skia.cc @@ -0,0 +1,91 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 "lib/txt/src/font_skia.h" + +#include + +namespace txt { +namespace { + +hb_blob_t* GetTable(hb_face_t* face, hb_tag_t tag, void* context) { + SkTypeface* typeface = reinterpret_cast(context); + + const size_t table_size = typeface->getTableSize(tag); + if (table_size == 0) + return nullptr; + void* buffer = malloc(table_size); + if (buffer == nullptr) + return nullptr; + + size_t actual_size = typeface->getTableData(tag, 0, table_size, buffer); + if (table_size != actual_size) { + free(buffer); + return nullptr; + } + return hb_blob_create(reinterpret_cast(buffer), table_size, + HB_MEMORY_MODE_WRITABLE, buffer, free); +} + +} // namespace + +FontSkia::FontSkia(sk_sp typeface) + : MinikinFont(typeface->uniqueID()), typeface_(std::move(typeface)) {} + +FontSkia::~FontSkia() = default; + +static void FontSkia_SetSkiaPaint(sk_sp typeface, + SkPaint* skPaint, + const minikin::MinikinPaint& paint) { + skPaint->setTypeface(std::move(typeface)); + skPaint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); + // TODO: set more paint parameters from Minikin + skPaint->setTextSize(paint.size); +} + +float FontSkia::GetHorizontalAdvance(uint32_t glyph_id, + const minikin::MinikinPaint& paint) const { + SkPaint skPaint; + uint16_t glyph16 = glyph_id; + SkScalar skWidth; + FontSkia_SetSkiaPaint(typeface_, &skPaint, paint); + skPaint.getTextWidths(&glyph16, sizeof(glyph16), &skWidth, NULL); + return skWidth; +} + +void FontSkia::GetBounds(minikin::MinikinRect* bounds, + uint32_t glyph_id, + const minikin::MinikinPaint& paint) const { + SkPaint skPaint; + uint16_t glyph16 = glyph_id; + SkRect skBounds; + FontSkia_SetSkiaPaint(typeface_, &skPaint, paint); + skPaint.getTextWidths(&glyph16, sizeof(glyph16), NULL, &skBounds); + bounds->mLeft = skBounds.fLeft; + bounds->mTop = skBounds.fTop; + bounds->mRight = skBounds.fRight; + bounds->mBottom = skBounds.fBottom; +} + +hb_face_t* FontSkia::CreateHarfBuzzFace() const { + return hb_face_create_for_tables(GetTable, typeface_.get(), 0); +} + +const sk_sp& FontSkia::GetSkTypeface() { + return typeface_; +} + +} // namespace txt diff --git a/engine/src/flutter/src/font_skia.h b/engine/src/flutter/src/font_skia.h new file mode 100644 index 0000000000..788af74ad3 --- /dev/null +++ b/engine/src/flutter/src/font_skia.h @@ -0,0 +1,50 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 +#include +#include +#include "lib/ftl/macros.h" + +namespace txt { + +class FontSkia : public minikin::MinikinFont { + public: + explicit FontSkia(sk_sp typeface); + + ~FontSkia(); + + float GetHorizontalAdvance(uint32_t glyph_id, + const minikin::MinikinPaint& paint) const override; + + void GetBounds(minikin::MinikinRect* bounds, + uint32_t glyph_id, + const minikin::MinikinPaint& paint) const override; + + hb_face_t* CreateHarfBuzzFace() const override; + + const std::vector& GetAxes() const override; + + const sk_sp& GetSkTypeface(); + + private: + sk_sp typeface_; + std::vector variations_; + + FTL_DISALLOW_COPY_AND_ASSIGN(FontSkia); +}; + +} // namespace txt From ef1a552f3c999b770403f5f49f31421c7c1c1a2d Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Wed, 10 May 2017 20:58:52 -0700 Subject: [PATCH 277/364] Remove libxml2 dependency --- engine/src/flutter/tests/util/BUILD.gn | 8 -------- 1 file changed, 8 deletions(-) diff --git a/engine/src/flutter/tests/util/BUILD.gn b/engine/src/flutter/tests/util/BUILD.gn index d8906e969d..cbb0335015 100644 --- a/engine/src/flutter/tests/util/BUILD.gn +++ b/engine/src/flutter/tests/util/BUILD.gn @@ -20,10 +20,6 @@ source_set("util") { sources = [ "FileUtils.cpp", "FileUtils.h", - "FontTestUtils.cpp", - "FontTestUtils.h", - "MinikinFontForTest.cpp", - "MinikinFontForTest.h", "UnicodeUtils.cpp", "UnicodeUtils.h", ] @@ -33,8 +29,4 @@ source_set("util") { public_deps = [ "//lib/txt/libs/minikin", ] - - deps = [ - "//third_party/libxml2", - ] } From 966ef0ace4e00dc15c2a648edd98931f54556831 Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Thu, 11 May 2017 09:12:22 -0700 Subject: [PATCH 278/364] Import more code from the prototype Change-Id: Ic5656c3ffcc3c3da8ed1fb4a44355b16c21c2f1e --- engine/src/flutter/.clang-format | 8 +++ engine/src/flutter/.gitattributes | 10 +++ engine/src/flutter/.gitignore | 17 +++++ engine/src/flutter/src/BUILD.gn | 13 +++- .../{font_collection.cc => font_provider.cc} | 28 ++++---- .../{font_collection.h => font_provider.h} | 12 ++-- engine/src/flutter/src/font_style.h | 29 ++++++++ engine/src/flutter/src/font_weight.h | 36 ++++++++++ engine/src/flutter/src/paragraph_builder.cc | 49 +++++++++++++ engine/src/flutter/src/paragraph_builder.h | 52 ++++++++++++++ engine/src/flutter/src/paragraph_style.h | 38 ++++++++++ engine/src/flutter/src/styled_runs.h | 69 +++++++++++++++++++ engine/src/flutter/src/text_align.h | 31 +++++++++ engine/src/flutter/src/text_style.h | 46 +++++++++++++ 14 files changed, 416 insertions(+), 22 deletions(-) create mode 100644 engine/src/flutter/.clang-format create mode 100644 engine/src/flutter/.gitattributes create mode 100644 engine/src/flutter/.gitignore rename engine/src/flutter/src/{font_collection.cc => font_provider.cc} (72%) rename engine/src/flutter/src/{font_collection.h => font_provider.h} (81%) create mode 100644 engine/src/flutter/src/font_style.h create mode 100644 engine/src/flutter/src/font_weight.h create mode 100644 engine/src/flutter/src/paragraph_builder.cc create mode 100644 engine/src/flutter/src/paragraph_builder.h create mode 100644 engine/src/flutter/src/paragraph_style.h create mode 100644 engine/src/flutter/src/styled_runs.h create mode 100644 engine/src/flutter/src/text_align.h create mode 100644 engine/src/flutter/src/text_style.h diff --git a/engine/src/flutter/.clang-format b/engine/src/flutter/.clang-format new file mode 100644 index 0000000000..6fdf1dc888 --- /dev/null +++ b/engine/src/flutter/.clang-format @@ -0,0 +1,8 @@ +# Defines the Chromium style for automatic reformatting. +# http://clang.llvm.org/docs/ClangFormatStyleOptions.html +BasedOnStyle: Chromium +# This defaults to 'Auto'. Explicitly set it for a while, so that +# 'vector >' in existing files gets formatted to +# 'vector>'. ('Auto' means that clang-format will only use +# 'int>>' if the file already contains at least one such instance.) +Standard: Cpp11 diff --git a/engine/src/flutter/.gitattributes b/engine/src/flutter/.gitattributes new file mode 100644 index 0000000000..da2e8a59e5 --- /dev/null +++ b/engine/src/flutter/.gitattributes @@ -0,0 +1,10 @@ +# Auto detect text files and perform LF normalization +* text=auto + +# Always perform LF normalization on these files +*.c text +*.cc text +*.cpp text +*.h text +*.gn text +*.md text diff --git a/engine/src/flutter/.gitignore b/engine/src/flutter/.gitignore new file mode 100644 index 0000000000..59ec4abf16 --- /dev/null +++ b/engine/src/flutter/.gitignore @@ -0,0 +1,17 @@ +*.pyc +*~ +.*.sw? +.DS_Store +.classpath +.cproject +.gdb_history +.gdbinit +.landmines +.project +.pydevproject +.checkstyle +.vscode +cscope.* +Session.vim +tags +Thumbs.db diff --git a/engine/src/flutter/src/BUILD.gn b/engine/src/flutter/src/BUILD.gn index e10013e470..44b6cfa1f8 100644 --- a/engine/src/flutter/src/BUILD.gn +++ b/engine/src/flutter/src/BUILD.gn @@ -14,13 +14,22 @@ static_library("src") { sources = [ - "font_collection.cc", - "font_collection.h", + "font_provider.cc", + "font_provider.h", "font_skia.cc", "font_skia.h", + "font_style.h", + "font_weight.h", + "paragraph_builder.cc", + "paragraph_builder.h", + "paragraph_style.h", + "styled_runs.h", + "text_align.h", + "text_style.h", ] deps = [ + "//lib/ftl", "//lib/txt/libs/minikin", "//third_party/skia", ] diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_provider.cc similarity index 72% rename from engine/src/flutter/src/font_collection.cc rename to engine/src/flutter/src/font_provider.cc index d94df028fa..a8a3c8fe9c 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_provider.cc @@ -14,7 +14,7 @@ * limitations under the License. */ -#include "lib/txt/src/font_collection.h" +#include "lib/txt/src/font_provider.h" #include @@ -31,28 +31,28 @@ bool IsItalic(SkFontStyle::Slant slant) { } // namespace -FontCollection& FontCollection::GetDefaultFontCollection() { - static FontCollection* collection = nullptr; +FontProvider& FontProvider::GetDefault() { + static FontProvider* provider = nullptr; static std::once_flag once; - std::call_once(once, []() { collection = new FontCollection(); }); - return *collection; + std::call_once(once, []() { provider = new FontProvider(); }); + return *provider; } -FontCollection::FontCollection() = default; +FontProvider::FontProvider() = default; -FontCollection::~FontCollection() = default; +FontProvider::~FontProvider() = default; std::shared_ptr -FontCollection::GetAndroidFontCollectionForFamily(const std::string& family) { +FontProvider::GetFontCollectionForFamily(const std::string& family) { // Get the Skia font manager. - auto skia_font_manager = SkFontMgr::RefDefault(); - FTL_DCHECK(skia_font_manager != nullptr); + auto font_manager = SkFontMgr::RefDefault(); + FTL_DCHECK(font_manager != nullptr); // Ask Skia to resolve a font style set for a font family name. // FIXME(chinmaygarde): The name "Hevetica" is hardcoded because CoreText // crashes when passed a null string. This seems to be a bug in Skia as // SkFontMgr explicitly says passing in nullptr gives the default font. - auto font_style_set = skia_font_manager->matchFamily( + auto font_style_set = font_manager->matchFamily( family.length() == 0 ? "Helvetica" : family.c_str()); FTL_DCHECK(font_style_set != nullptr); @@ -64,9 +64,9 @@ FontCollection::GetAndroidFontCollectionForFamily(const std::string& family) { sk_ref_sp(font_style_set->createTypeface(i)); auto typeface = std::make_shared(std::move(skia_typeface)); - SkFontStyle skia_font_style; - font_style_set->getStyle(i, &skia_font_style, nullptr); - minikin::FontStyle style(skia_font_style.weight(), IsItalic(skia_font_style.slant())); + SkFontStyle font_style; + font_style_set->getStyle(i, &font_style, nullptr); + minikin::FontStyle style(font_style.weight(), IsItalic(font_style.slant())); fonts.push_back(minikin::Font(std::move(typeface), style)); } diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_provider.h similarity index 81% rename from engine/src/flutter/src/font_collection.h rename to engine/src/flutter/src/font_provider.h index d4df45b0e9..264ee149fc 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_provider.h @@ -27,20 +27,20 @@ namespace txt { -class FontCollection { +class FontProvider { public: - static FontCollection& GetDefaultFontCollection(); + static FontProvider& GetDefault(); - FontCollection(); + FontProvider(); - ~FontCollection(); + ~FontProvider(); - std::shared_ptr GetAndroidFontCollectionForFamily( + std::shared_ptr GetFontCollectionForFamily( const std::string& family); private: // TODO(chinmaygarde): Caches go here. - FTL_DISALLOW_COPY_AND_ASSIGN(FontCollection); + FTL_DISALLOW_COPY_AND_ASSIGN(FontProvider); }; } // namespace txt diff --git a/engine/src/flutter/src/font_style.h b/engine/src/flutter/src/font_style.h new file mode 100644 index 0000000000..ee903dbea0 --- /dev/null +++ b/engine/src/flutter/src/font_style.h @@ -0,0 +1,29 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 LIB_TXT_SRC_FONT_STYLE_H_ +#define LIB_TXT_SRC_FONT_STYLE_H_ + +namespace txt { + +enum class FontStyle { + normal, + italic, +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_FONT_STYLE_H_ diff --git a/engine/src/flutter/src/font_weight.h b/engine/src/flutter/src/font_weight.h new file mode 100644 index 0000000000..cd1811e14d --- /dev/null +++ b/engine/src/flutter/src/font_weight.h @@ -0,0 +1,36 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 LIB_TXT_SRC_FONT_WEIGHT_H_ +#define LIB_TXT_SRC_FONT_WEIGHT_H_ + +namespace txt { + +enum class FontWeight { + w100, + w200, + w300, + w400, + w500, + w600, + w700, + w800, + w900, +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_FONT_WEIGHT_H_ diff --git a/engine/src/flutter/src/paragraph_builder.cc b/engine/src/flutter/src/paragraph_builder.cc new file mode 100644 index 0000000000..3fd1738d9e --- /dev/null +++ b/engine/src/flutter/src/paragraph_builder.cc @@ -0,0 +1,49 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 "lib/txt/src/paragraph_builder.h" + +namespace txt { + +ParagraphBuilder::ParagraphBuilder(ParagraphStyle style) {} + +ParagraphBuilder::~ParagraphBuilder() = default; + +void ParagraphBuilder::PushStyle(const TextStyle& style) { + const size_t text_index = text_.size(); + runs_.EndRunIfNeeded(text_index); + const size_t style_index = runs_.AddStyle(style); + runs_.StartRun(style_index, text_index); + style_stack_.push_back(style_index); +} + +void ParagraphBuilder::Pop() { + if (style_stack_.empty()) + return; + const size_t text_index = text_.size(); + runs_.EndRunIfNeeded(text_index); + style_stack_.pop_back(); + if (style_stack_.empty()) + return; + const size_t style_index = style_stack_.back(); + runs_.StartRun(style_index, text_index); +} + +void ParagraphBuilder::AddText(const uint16_t* text, size_t length) { + text_.insert(text_.end(), text, text + length); +} + +} // namespace txt diff --git a/engine/src/flutter/src/paragraph_builder.h b/engine/src/flutter/src/paragraph_builder.h new file mode 100644 index 0000000000..cb313b01f0 --- /dev/null +++ b/engine/src/flutter/src/paragraph_builder.h @@ -0,0 +1,52 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 LIB_TXT_SRC_PARAGRAPH_BUILDER_H_ +#define LIB_TXT_SRC_PARAGRAPH_BUILDER_H_ + +#include +#include + +#include "lib/ftl/macros.h" +#include "lib/txt/src/paragraph_style.h" +#include "lib/txt/src/styled_runs.h" +#include "lib/txt/src/text_style.h" + +namespace txt { + +class ParagraphBuilder { + public: + explicit ParagraphBuilder(ParagraphStyle style); + + ~ParagraphBuilder(); + + void PushStyle(const TextStyle& style); + + void Pop(); + + void AddText(const uint16_t* text, size_t length); + + private: + std::vector text_; + std::vector style_stack_; + StyledRuns runs_; + + FTL_DISALLOW_COPY_AND_ASSIGN(ParagraphBuilder); +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_PARAGRAPH_BUILDER_H_ diff --git a/engine/src/flutter/src/paragraph_style.h b/engine/src/flutter/src/paragraph_style.h new file mode 100644 index 0000000000..eec58159da --- /dev/null +++ b/engine/src/flutter/src/paragraph_style.h @@ -0,0 +1,38 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 LIB_TXT_SRC_PARAGRAPH_STYLE_H_ +#define LIB_TXT_SRC_PARAGRAPH_STYLE_H_ + +#include + +#include "lib/txt/src/font_style.h" +#include "lib/txt/src/font_weight.h" +#include "lib/txt/src/text_align.h" + +namespace txt { + +class ParagraphStyle { + public: + TextAlign text_align = TextAlign::left; + int max_lines = 0; + double line_height = 1.0; + std::string ellipsis; +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_PARAGRAPH_STYLE_H_ diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h new file mode 100644 index 0000000000..781e1eb69b --- /dev/null +++ b/engine/src/flutter/src/styled_runs.h @@ -0,0 +1,69 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 LIB_TXT_SRC_STYLED_RUNS_H_ +#define LIB_TXT_SRC_STYLED_RUNS_H_ + +#include + +#include "lib/txt/src/text_style.h" + +namespace txt { + +class StyledRuns { + public: + struct Run { + const TextStyle& style; + size_t start; + size_t end; + }; + + StyledRuns(); + + ~StyledRuns(); + + StyledRuns(const StyledRuns& other) = delete; + + StyledRuns(StyledRuns&& other); + + const StyledRuns& operator=(StyledRuns&& other); + + void swap(StyledRuns& other); + + size_t AddStyle(const TextStyle& style); + + void StartRun(size_t style_index, size_t start); + + void EndRunIfNeeded(size_t end); + + size_t size() const { return runs_.size(); } + + Run GetRun(size_t index) const; + + private: + struct IndexedRun { + size_t style_index = 0; + size_t start = 0; + size_t end = 0; + }; + + std::vector styles_; + std::vector runs_; +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_STYLED_RUNS_H_ diff --git a/engine/src/flutter/src/text_align.h b/engine/src/flutter/src/text_align.h new file mode 100644 index 0000000000..91a291ff9f --- /dev/null +++ b/engine/src/flutter/src/text_align.h @@ -0,0 +1,31 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 LIB_TXT_SRC_TEXT_ALIGN_H_ +#define LIB_TXT_SRC_TEXT_ALIGN_H_ + +namespace txt { + +enum class TextAlign { + left, + right, + center, + // justify, +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_TEXT_ALIGN_H_ diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h new file mode 100644 index 0000000000..f2482dd406 --- /dev/null +++ b/engine/src/flutter/src/text_style.h @@ -0,0 +1,46 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 LIB_TXT_SRC_TEXT_STYLE_H_ +#define LIB_TXT_SRC_TEXT_STYLE_H_ + +#include + +#include "lib/txt/src/font_style.h" +#include "lib/txt/src/font_weight.h" +#include "third_party/skia/include/core/SkColor.h" + +namespace txt { + +class TextStyle { + public: + SkColor color = SK_ColorWHITE; + // TextDecoration decoration, + // SkColor decoration_color; + // TextDecorationStyle decoration_style + FontWeight font_weight = FontWeight::w400; + FontStyle font_style = FontStyle::normal; + // TextBaseline text_baseline; + std::string font_family; + double font_size = 14.0; + double letter_spacing = 0.0; + double word_spacing = 0.0; + double height = 1.0; +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_TEXT_STYLE_H_ From cdbb8b0c9d84fb313226ef0b5ac7f9bd5aa9b299 Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Thu, 11 May 2017 09:25:35 -0700 Subject: [PATCH 279/364] Add Paragraph class from prototype Change-Id: Id38e4261c4d6f8fa99f405d9b21bdd9e259a9384 --- .../src/flutter/include/minikin/LineBreaker.h | 2 + engine/src/flutter/src/BUILD.gn | 4 + engine/src/flutter/src/font_skia.cc | 2 +- engine/src/flutter/src/font_skia.h | 2 +- engine/src/flutter/src/paint_record.cc | 41 ++++ engine/src/flutter/src/paint_record.h | 53 +++++ engine/src/flutter/src/paragraph.cc | 210 ++++++++++++++++++ engine/src/flutter/src/paragraph.h | 60 +++++ engine/src/flutter/src/paragraph_builder.cc | 7 + engine/src/flutter/src/paragraph_builder.h | 3 + 10 files changed, 382 insertions(+), 2 deletions(-) create mode 100644 engine/src/flutter/src/paint_record.cc create mode 100644 engine/src/flutter/src/paint_record.h create mode 100644 engine/src/flutter/src/paragraph.cc create mode 100644 engine/src/flutter/src/paragraph.h diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index c91c0b3da7..46936bbd57 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -26,7 +26,9 @@ #include "unicode/locid.h" #include #include +#include "minikin/FontCollection.h" #include "minikin/Hyphenator.h" +#include "minikin/MinikinFont.h" #include "minikin/WordBreaker.h" namespace minikin { diff --git a/engine/src/flutter/src/BUILD.gn b/engine/src/flutter/src/BUILD.gn index 44b6cfa1f8..a790b4e4d6 100644 --- a/engine/src/flutter/src/BUILD.gn +++ b/engine/src/flutter/src/BUILD.gn @@ -20,6 +20,10 @@ static_library("src") { "font_skia.h", "font_style.h", "font_weight.h", + "paint_record.cc", + "paint_record.h", + "paragraph.cc", + "paragraph.h", "paragraph_builder.cc", "paragraph_builder.h", "paragraph_style.h", diff --git a/engine/src/flutter/src/font_skia.cc b/engine/src/flutter/src/font_skia.cc index a70c391858..295a749bc2 100644 --- a/engine/src/flutter/src/font_skia.cc +++ b/engine/src/flutter/src/font_skia.cc @@ -84,7 +84,7 @@ hb_face_t* FontSkia::CreateHarfBuzzFace() const { return hb_face_create_for_tables(GetTable, typeface_.get(), 0); } -const sk_sp& FontSkia::GetSkTypeface() { +const sk_sp& FontSkia::GetSkTypeface() const { return typeface_; } diff --git a/engine/src/flutter/src/font_skia.h b/engine/src/flutter/src/font_skia.h index 788af74ad3..96e808d9fb 100644 --- a/engine/src/flutter/src/font_skia.h +++ b/engine/src/flutter/src/font_skia.h @@ -38,7 +38,7 @@ class FontSkia : public minikin::MinikinFont { const std::vector& GetAxes() const override; - const sk_sp& GetSkTypeface(); + const sk_sp& GetSkTypeface() const; private: sk_sp typeface_; diff --git a/engine/src/flutter/src/paint_record.cc b/engine/src/flutter/src/paint_record.cc new file mode 100644 index 0000000000..226b803d42 --- /dev/null +++ b/engine/src/flutter/src/paint_record.cc @@ -0,0 +1,41 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 "lib/txt/src/paint_record.h" + +namespace txt { + +PaintRecord::PaintRecord() = default; + +PaintRecord::~PaintRecord() = default; + +PaintRecord::PaintRecord(SkColor color, SkPoint offset, sk_sp text) + : color_(color), offset_(offset), text_(std::move(text)) {} + +PaintRecord::PaintRecord(PaintRecord&& other) { + color_ = other.color_; + offset_ = other.offset_; + text_ = std::move(other.text_); +} + +PaintRecord& PaintRecord::operator=(PaintRecord&& other) { + color_ = other.color_; + offset_ = other.offset_; + text_ = std::move(other.text_); + return *this; +} + +} // namespace txt diff --git a/engine/src/flutter/src/paint_record.h b/engine/src/flutter/src/paint_record.h new file mode 100644 index 0000000000..04d6f300d6 --- /dev/null +++ b/engine/src/flutter/src/paint_record.h @@ -0,0 +1,53 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 LIB_TXT_SRC_PAINT_RECORD_H_ +#define LIB_TXT_SRC_PAINT_RECORD_H_ + +#include "lib/ftl/macros.h" +#include "third_party/skia/include/core/SkTextBlob.h" + +namespace txt { + +class PaintRecord { + public: + PaintRecord(); + + ~PaintRecord(); + + PaintRecord(SkColor color, SkPoint offset, sk_sp text); + + PaintRecord(const PaintRecord& other) = delete; + + PaintRecord(PaintRecord&& other); + + PaintRecord& operator=(PaintRecord&& other); + + SkColor color() const { return color_; } + + SkPoint offset() const { return offset_; } + + SkTextBlob* text() const { return text_.get(); } + + private: + SkColor color_; + SkPoint offset_; + sk_sp text_; +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_PAINT_RECORD_H_ diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc new file mode 100644 index 0000000000..e4a35e7ed4 --- /dev/null +++ b/engine/src/flutter/src/paragraph.cc @@ -0,0 +1,210 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 "lib/txt/src/paragraph.h" + +#include +#include +#include +#include + +#include +#include + +#include "lib/ftl/logging.h" + +#include "lib/txt/src/font_provider.h" +#include "lib/txt/src/font_skia.h" +#include "third_party/skia/include/core/SkCanvas.h" +#include "third_party/skia/include/core/SkPaint.h" +#include "third_party/skia/include/core/SkTextBlob.h" +#include "third_party/skia/include/core/SkTypeface.h" + +namespace txt { +namespace { + +const sk_sp& GetTypefaceForGlyph(const minikin::Layout& layout, + size_t index) { + const FontSkia* font = static_cast(layout.getFont(index)); + return font->GetSkTypeface(); +} + +size_t GetBlobLength(const minikin::Layout& layout, size_t blob_start) { + const size_t glyph_count = layout.nGlyphs(); + const sk_sp& typeface = GetTypefaceForGlyph(layout, blob_start); + for (size_t blob_end = blob_start + 1; blob_end < glyph_count; ++blob_end) { + if (GetTypefaceForGlyph(layout, blob_end).get() != typeface.get()) + return blob_end - blob_start; + } + return glyph_count - blob_start; +} + +int GetWeight(const TextStyle& style) { + switch (style.font_weight) { + case FontWeight::w100: + return 1; + case FontWeight::w200: + return 2; + case FontWeight::w300: + return 3; + case FontWeight::w400: + return 4; + case FontWeight::w500: + return 5; + case FontWeight::w600: + return 6; + case FontWeight::w700: + return 7; + case FontWeight::w800: + return 8; + case FontWeight::w900: + return 9; + } +} + +bool GetItalic(const TextStyle& style) { + switch (style.font_style) { + case FontStyle::normal: + return false; + case FontStyle::italic: + return true; + } +} + +void GetFontAndMinikinPaint(const TextStyle& style, + minikin::FontStyle* font, + minikin::MinikinPaint* paint) { + *font = minikin::FontStyle(GetWeight(style), GetItalic(style)); + paint->size = style.font_size; + paint->letterSpacing = style.letter_spacing; + // TODO(abarth): font_family, word_spacing. +} + +void GetPaint(const TextStyle& style, SkPaint* paint) { + paint->setTextSize(style.font_size); +} + +} // namespace + +Paragraph::Paragraph() = default; + +Paragraph::~Paragraph() = default; + +void Paragraph::SetText(std::vector text, StyledRuns runs) { + text_ = std::move(text); + runs_ = std::move(runs); + + breaker_.setLocale(icu::Locale(), nullptr); + breaker_.resize(text_.size()); + memcpy(breaker_.buffer(), text_.data(), text_.size() * sizeof(text_[0])); + breaker_.setText(); +} + +void Paragraph::AddRunsToLineBreaker() { + auto collection = FontProvider::GetDefault().GetFontCollectionForFamily(""); + minikin::FontStyle font; + minikin::MinikinPaint paint; + for (size_t i = 0; i < runs_.size(); ++i) { + auto run = runs_.GetRun(i); + GetFontAndMinikinPaint(run.style, &font, &paint); + breaker_.addStyleRun(&paint, collection, font, run.start, run.end, false); + } +} + +void Paragraph::Layout(double width) { + breaker_.setLineWidths(0.0f, 0, width); + AddRunsToLineBreaker(); + size_t breaks_count = breaker_.computeBreaks(); + const int* breaks = breaker_.getBreaks(); + + SkPaint paint; + paint.setAntiAlias(true); + paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); + + minikin::FontStyle font; + minikin::MinikinPaint minikin_paint; + + SkTextBlobBuilder builder; + auto collection = FontProvider::GetDefault().GetFontCollectionForFamily(""); + minikin::Layout layout; + SkScalar x = 0.0f; + SkScalar y = 0.0f; + size_t break_index = 0; + for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { + auto run = runs_.GetRun(run_index); + GetFontAndMinikinPaint(run.style, &font, &minikin_paint); + GetPaint(run.style, &paint); + + size_t layout_start = run.start; + while (layout_start < run.end) { + const size_t next_break = (break_index > breaks_count - 1) + ? std::numeric_limits::max() + : breaks[break_index]; + const size_t layout_end = std::min(run.end, next_break); + + int bidiFlags = 0; + layout.doLayout(text_.data(), layout_start, layout_end - layout_start, + text_.size(), bidiFlags, font, minikin_paint, collection); + + const size_t glyph_count = layout.nGlyphs(); + size_t blob_start = 0; + while (blob_start < glyph_count) { + const size_t blob_length = GetBlobLength(layout, blob_start); + // TODO(abarth): Precompute when we can use allocRunPosH. + paint.setTypeface(GetTypefaceForGlyph(layout, blob_start)); + + auto buffer = builder.allocRunPos(paint, blob_length); + + for (size_t blob_index = 0; blob_index < blob_length; ++blob_index) { + const size_t glyph_index = blob_start + blob_index; + buffer.glyphs[blob_index] = layout.getGlyphId(glyph_index); + const size_t pos_index = 2 * blob_index; + buffer.pos[pos_index] = layout.getX(glyph_index); + buffer.pos[pos_index + 1] = layout.getY(glyph_index); + } + blob_start += blob_length; + } + + // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the + // color stayed the same. + records_.push_back( + PaintRecord(run.style.color, SkPoint::Make(x, y), builder.make())); + + if (layout_end == next_break) { + x = 0.0f; + // TODO(abarth): Use the line height, which is something like the max + // font_size for runs in this line times the paragraph's line height. + y += run.style.font_size; + break_index += 1; + } else { + x += layout.getAdvance(); + } + + layout_start = layout_end; + } + } +} + +void Paragraph::Paint(SkCanvas* canvas, double x, double y) { + SkPaint paint; + for (const auto& record : records_) { + paint.setColor(record.color()); + const SkPoint& offset = record.offset(); + canvas->drawTextBlob(record.text(), x + offset.x(), y + offset.y(), paint); + } +} + +} // namespace txt diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h new file mode 100644 index 0000000000..3b4bcb8757 --- /dev/null +++ b/engine/src/flutter/src/paragraph.h @@ -0,0 +1,60 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 LIB_TXT_SRC_PARAGRAPH_H_ +#define LIB_TXT_SRC_PARAGRAPH_H_ + +#include + +#include + +#include "lib/ftl/macros.h" +#include "lib/txt/src/paint_record.h" +#include "lib/txt/src/styled_runs.h" +#include "third_party/skia/include/core/SkTextBlob.h" + +class SkCanvas; + +namespace txt { + +class Paragraph { + public: + Paragraph(); + + ~Paragraph(); + + void Layout(double width); + + void Paint(SkCanvas* canvas, double x, double y); + + private: + friend class ParagraphBuilder; + + std::vector text_; + StyledRuns runs_; + minikin::LineBreaker breaker_; + std::vector records_; + + void SetText(std::vector text, StyledRuns runs); + + void AddRunsToLineBreaker(); + + FTL_DISALLOW_COPY_AND_ASSIGN(Paragraph); +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_PARAGRAPH_H_ diff --git a/engine/src/flutter/src/paragraph_builder.cc b/engine/src/flutter/src/paragraph_builder.cc index 3fd1738d9e..342279cd32 100644 --- a/engine/src/flutter/src/paragraph_builder.cc +++ b/engine/src/flutter/src/paragraph_builder.cc @@ -46,4 +46,11 @@ void ParagraphBuilder::AddText(const uint16_t* text, size_t length) { text_.insert(text_.end(), text, text + length); } +std::unique_ptr ParagraphBuilder::Build() { + runs_.EndRunIfNeeded(text_.size()); + std::unique_ptr paragraph = std::make_unique(); + paragraph->SetText(std::move(text_), std::move(runs_)); + return paragraph; +} + } // namespace txt diff --git a/engine/src/flutter/src/paragraph_builder.h b/engine/src/flutter/src/paragraph_builder.h index cb313b01f0..243e6394c8 100644 --- a/engine/src/flutter/src/paragraph_builder.h +++ b/engine/src/flutter/src/paragraph_builder.h @@ -21,6 +21,7 @@ #include #include "lib/ftl/macros.h" +#include "lib/txt/src/paragraph.h" #include "lib/txt/src/paragraph_style.h" #include "lib/txt/src/styled_runs.h" #include "lib/txt/src/text_style.h" @@ -39,6 +40,8 @@ class ParagraphBuilder { void AddText(const uint16_t* text, size_t length); + std::unique_ptr Build(); + private: std::vector text_; std::vector style_stack_; From 2697ab61cb778b26d1e7e04fb2b23479b65d5f52 Mon Sep 17 00:00:00 2001 From: Adam Barth Date: Thu, 11 May 2017 09:38:03 -0700 Subject: [PATCH 280/364] Add example program from prototype Change-Id: Ia6f6c442db57abe484a3efe33ecbc7553743bbb3 --- engine/src/flutter/BUILD.gn | 17 +++++-- engine/src/flutter/examples/BUILD.gn | 27 ++++++++++ engine/src/flutter/examples/main.cc | 73 +++++++++++++++++++++++++++ engine/src/flutter/src/BUILD.gn | 3 +- engine/src/flutter/src/font_skia.cc | 4 ++ engine/src/flutter/src/styled_runs.cc | 68 +++++++++++++++++++++++++ 6 files changed, 188 insertions(+), 4 deletions(-) create mode 100644 engine/src/flutter/examples/BUILD.gn create mode 100644 engine/src/flutter/examples/main.cc create mode 100644 engine/src/flutter/src/styled_runs.cc diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn index 4e19aa46f0..36804272fd 100644 --- a/engine/src/flutter/BUILD.gn +++ b/engine/src/flutter/BUILD.gn @@ -1,6 +1,16 @@ -# Copyright 2017 The Chromium Authors. All rights reserved. -# Use of this source code is governed by a BSD-style license that can be -# found in the LICENSE file. +# Copyright 2017 Google Inc. +# +# 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. group("txt") { testonly = true @@ -9,5 +19,6 @@ group("txt") { "libs/minikin", "src", "tests/unittest($host_toolchain)", + "examples:txt_example($host_toolchain)", ] } diff --git a/engine/src/flutter/examples/BUILD.gn b/engine/src/flutter/examples/BUILD.gn new file mode 100644 index 0000000000..bd19515179 --- /dev/null +++ b/engine/src/flutter/examples/BUILD.gn @@ -0,0 +1,27 @@ +# Copyright 2017 Google Inc. +# +# 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. + +executable("txt_example") { + sources = [ + "main.cc", + ] + + deps = [ + "//dart/runtime:libdart_jit", + "//flutter/fml", + "//lib/txt/src", + "//third_party/icu:icuuc", + "//third_party/skia", + ] +} diff --git a/engine/src/flutter/examples/main.cc b/engine/src/flutter/examples/main.cc new file mode 100644 index 0000000000..4d1b5b88a5 --- /dev/null +++ b/engine/src/flutter/examples/main.cc @@ -0,0 +1,73 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 + +#include +#include +#include + +#include "flutter/fml/icu_util.h" +#include "lib/txt/src/paragraph_builder.h" + +namespace txt { + +int runTest() { + const char* utf8_text = + "fine world that we live in is called Earth. It's pretty nice, as far as " + "I can tell. Rock, rock on. " + "\xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5" + "\x87"; + icu::UnicodeString text = icu::UnicodeString::fromUTF8(utf8_text); + + ParagraphStyle paragraph_style; + ParagraphBuilder builder(paragraph_style); + TextStyle style; + style.color = SK_ColorBLUE; + style.font_size = 32.0; + builder.PushStyle(style); + builder.AddText(text.getBuffer(), text.length()); + style.color = SK_ColorYELLOW; + builder.PushStyle(style); + builder.AddText(text.getBuffer(), text.length()); + builder.Pop(); + builder.AddText(text.getBuffer(), text.length()); + builder.Pop(); + auto paragraph = builder.Build(); + + int width = 800; + int height = 600; + paragraph->Layout(width); + + SkAutoGraphics ag; + SkBitmap bitmap; + bitmap.allocN32Pixels(width, height); + SkCanvas canvas(bitmap); + paragraph->Paint(&canvas, 10.0, 200.0); + + SkFILEWStream file("foo.png"); + + return SkEncodeImage(&file, bitmap, SkEncodedImageFormat::kPNG, 100) + ? EXIT_SUCCESS + : EXIT_FAILURE; +} + +} // namespace txt + +int main(int argc, const char** argv) { + fml::icu::InitializeICU(); + return txt::runTest(); +} diff --git a/engine/src/flutter/src/BUILD.gn b/engine/src/flutter/src/BUILD.gn index a790b4e4d6..2d603bb38a 100644 --- a/engine/src/flutter/src/BUILD.gn +++ b/engine/src/flutter/src/BUILD.gn @@ -27,12 +27,13 @@ static_library("src") { "paragraph_builder.cc", "paragraph_builder.h", "paragraph_style.h", + "styled_runs.cc", "styled_runs.h", "text_align.h", "text_style.h", ] - deps = [ + public_deps = [ "//lib/ftl", "//lib/txt/libs/minikin", "//third_party/skia", diff --git a/engine/src/flutter/src/font_skia.cc b/engine/src/flutter/src/font_skia.cc index 295a749bc2..c6b3bc8d8f 100644 --- a/engine/src/flutter/src/font_skia.cc +++ b/engine/src/flutter/src/font_skia.cc @@ -84,6 +84,10 @@ hb_face_t* FontSkia::CreateHarfBuzzFace() const { return hb_face_create_for_tables(GetTable, typeface_.get(), 0); } +const std::vector& FontSkia::GetAxes() const { + return variations_; +} + const sk_sp& FontSkia::GetSkTypeface() const { return typeface_; } diff --git a/engine/src/flutter/src/styled_runs.cc b/engine/src/flutter/src/styled_runs.cc new file mode 100644 index 0000000000..3f5f79da62 --- /dev/null +++ b/engine/src/flutter/src/styled_runs.cc @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2017 Google, Inc. + * + * 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 "lib/txt/src/styled_runs.h" + +namespace txt { + +StyledRuns::StyledRuns() = default; + +StyledRuns::~StyledRuns() = default; + +StyledRuns::StyledRuns(StyledRuns&& other) { + styles_.swap(other.styles_); + runs_.swap(other.runs_); +} + +const StyledRuns& StyledRuns::operator=(StyledRuns&& other) { + styles_.swap(other.styles_); + runs_.swap(other.runs_); + return *this; +} + +void StyledRuns::swap(StyledRuns& other) { + styles_.swap(other.styles_); + runs_.swap(other.runs_); +} + +size_t StyledRuns::AddStyle(const TextStyle& style) { + const size_t style_index = styles_.size(); + styles_.push_back(style); + return style_index; +} + +void StyledRuns::StartRun(size_t style_index, size_t start) { + runs_.push_back(IndexedRun{style_index, start, start}); +} + +void StyledRuns::EndRunIfNeeded(size_t end) { + if (runs_.empty()) + return; + IndexedRun& run = runs_.back(); + if (run.start == end) { + // The run is empty. We can skip it. + runs_.pop_back(); + } else { + run.end = end; + } +} + +StyledRuns::Run StyledRuns::GetRun(size_t index) const { + const IndexedRun& run = runs_[index]; + return Run{styles_[run.style_index], run.start, run.end}; +} + +} // namespace txt From 79f20a88865c362f2caa3f4c8325eebc1f82ff47 Mon Sep 17 00:00:00 2001 From: Chinmay Garde Date: Fri, 2 Jun 2017 14:43:10 -0700 Subject: [PATCH 281/364] Update libTXT sources and tests from initial prototype. This separates libTXT tests and Minikin tests and accounts for building with an older version of ICU. Once ICU has been updated, the workarounds for emoji handling will be removed. Change-Id: Ic184e653a2561629b01f98aeb4f6fb88aebbfa88 --- engine/src/flutter/BUILD.gn | 6 +- engine/src/flutter/examples/BUILD.gn | 1 + engine/src/flutter/examples/main.cc | 12 +-- .../src/flutter/include/minikin/Hyphenator.h | 4 + .../src/flutter/include/minikin/LineBreaker.h | 4 + engine/src/flutter/libs/minikin/BUILD.gn | 2 + engine/src/flutter/libs/minikin/Emoji.cpp | 12 +++ engine/src/flutter/libs/minikin/Layout.cpp | 5 ++ engine/src/flutter/src/BUILD.gn | 13 +-- engine/src/flutter/src/font_collection.cc | 87 +++++++++++++++++++ .../{font_provider.h => font_collection.h} | 16 ++-- engine/src/flutter/src/font_provider.cc | 78 ----------------- engine/src/flutter/src/paragraph.cc | 12 +-- engine/src/flutter/src/paragraph.h | 6 +- engine/src/flutter/src/paragraph_builder.cc | 4 +- engine/src/flutter/src/paragraph_builder.h | 2 +- .../src/flutter/src/paragraph_constraints.cc | 23 +++++ .../src/flutter/src/paragraph_constraints.h | 38 ++++++++ engine/src/flutter/src/paragraph_style.cc | 17 ++++ engine/src/flutter/src/text_style.cc | 17 ++++ engine/src/flutter/tests/txt/BUILD.gn | 40 +++++++++ .../tests/txt/font_collection_unittests.cc | 25 ++++++ .../flutter/tests/txt/paragraph_unittests.cc | 47 ++++++++++ engine/src/flutter/tests/txt/render_test.cc | 67 ++++++++++++++ engine/src/flutter/tests/txt/render_test.h | 52 +++++++++++ .../tests/txt/txt_run_all_unittests.cc | 26 ++++++ engine/src/flutter/tests/unittest/BUILD.gn | 15 ++-- 27 files changed, 514 insertions(+), 117 deletions(-) create mode 100644 engine/src/flutter/src/font_collection.cc rename engine/src/flutter/src/{font_provider.h => font_collection.h} (75%) delete mode 100644 engine/src/flutter/src/font_provider.cc create mode 100644 engine/src/flutter/src/paragraph_constraints.cc create mode 100644 engine/src/flutter/src/paragraph_constraints.h create mode 100644 engine/src/flutter/src/paragraph_style.cc create mode 100644 engine/src/flutter/src/text_style.cc create mode 100644 engine/src/flutter/tests/txt/BUILD.gn create mode 100644 engine/src/flutter/tests/txt/font_collection_unittests.cc create mode 100644 engine/src/flutter/tests/txt/paragraph_unittests.cc create mode 100644 engine/src/flutter/tests/txt/render_test.cc create mode 100644 engine/src/flutter/tests/txt/render_test.h create mode 100644 engine/src/flutter/tests/txt/txt_run_all_unittests.cc diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn index 36804272fd..34c9c145fa 100644 --- a/engine/src/flutter/BUILD.gn +++ b/engine/src/flutter/BUILD.gn @@ -16,9 +16,9 @@ group("txt") { testonly = true deps = [ - "libs/minikin", - "src", - "tests/unittest($host_toolchain)", "examples:txt_example($host_toolchain)", + "src", + "tests/txt($host_toolchain)", # txt_unittests + "tests/unittest($host_toolchain)", # minikin_unittest ] } diff --git a/engine/src/flutter/examples/BUILD.gn b/engine/src/flutter/examples/BUILD.gn index bd19515179..20780a3d65 100644 --- a/engine/src/flutter/examples/BUILD.gn +++ b/engine/src/flutter/examples/BUILD.gn @@ -20,6 +20,7 @@ executable("txt_example") { deps = [ "//dart/runtime:libdart_jit", "//flutter/fml", + "//lib/txt/libs/minikin", "//lib/txt/src", "//third_party/icu:icuuc", "//third_party/skia", diff --git a/engine/src/flutter/examples/main.cc b/engine/src/flutter/examples/main.cc index 4d1b5b88a5..3137207c38 100644 --- a/engine/src/flutter/examples/main.cc +++ b/engine/src/flutter/examples/main.cc @@ -31,7 +31,9 @@ int runTest() { "I can tell. Rock, rock on. " "\xe0\xa4\xa8\xe0\xa4\xae\xe0\xa4\xb8\xe0\xa5\x8d\xe0\xa4\xa4\xe0\xa5" "\x87"; - icu::UnicodeString text = icu::UnicodeString::fromUTF8(utf8_text); + icu::UnicodeString icu_text = icu::UnicodeString::fromUTF8(utf8_text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); ParagraphStyle paragraph_style; ParagraphBuilder builder(paragraph_style); @@ -39,18 +41,18 @@ int runTest() { style.color = SK_ColorBLUE; style.font_size = 32.0; builder.PushStyle(style); - builder.AddText(text.getBuffer(), text.length()); + builder.AddText(u16_text); style.color = SK_ColorYELLOW; builder.PushStyle(style); - builder.AddText(text.getBuffer(), text.length()); + builder.AddText(u16_text); builder.Pop(); - builder.AddText(text.getBuffer(), text.length()); + builder.AddText(u16_text); builder.Pop(); auto paragraph = builder.Build(); int width = 800; int height = 600; - paragraph->Layout(width); + paragraph->Layout(ParagraphConstraints(width)); SkAutoGraphics ag; SkBitmap bitmap; diff --git a/engine/src/flutter/include/minikin/Hyphenator.h b/engine/src/flutter/include/minikin/Hyphenator.h index 2b8ccb71a7..c2d9d3b63a 100644 --- a/engine/src/flutter/include/minikin/Hyphenator.h +++ b/engine/src/flutter/include/minikin/Hyphenator.h @@ -18,6 +18,10 @@ * An implementation of Liang's hyphenation algorithm. */ +#ifndef U_USING_ICU_NAMESPACE +#define U_USING_ICU_NAMESPACE 0 +#endif // U_USING_ICU_NAMESPACE + #include "unicode/locid.h" #include #include diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index 46936bbd57..c2f546db76 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -22,6 +22,10 @@ #ifndef MINIKIN_LINE_BREAKER_H #define MINIKIN_LINE_BREAKER_H +#ifndef U_USING_ICU_NAMESPACE +#define U_USING_ICU_NAMESPACE 0 +#endif // U_USING_ICU_NAMESPACE + #include "unicode/brkiter.h" #include "unicode/locid.h" #include diff --git a/engine/src/flutter/libs/minikin/BUILD.gn b/engine/src/flutter/libs/minikin/BUILD.gn index 5ce005f45a..f723d0a8e1 100644 --- a/engine/src/flutter/libs/minikin/BUILD.gn +++ b/engine/src/flutter/libs/minikin/BUILD.gn @@ -17,6 +17,8 @@ config("minikin_config") { } static_library("minikin") { + defines = [ "WIP_NEEDS_ICU_UPDATE" ] + sources = [ "CmapCoverage.cpp", "Emoji.cpp", diff --git a/engine/src/flutter/libs/minikin/Emoji.cpp b/engine/src/flutter/libs/minikin/Emoji.cpp index fbe68ca843..df43c75b36 100644 --- a/engine/src/flutter/libs/minikin/Emoji.cpp +++ b/engine/src/flutter/libs/minikin/Emoji.cpp @@ -37,16 +37,27 @@ bool isNewEmoji(uint32_t c) { } bool isEmoji(uint32_t c) { +#if WIP_NEEDS_ICU_UPDATE + return false; +#else // WIP_NEEDS_ICU_UPDATE return isNewEmoji(c) || u_hasBinaryProperty(c, UCHAR_EMOJI); +#endif // WIP_NEEDS_ICU_UPDATE } bool isEmojiModifier(uint32_t c) { +#if WIP_NEEDS_ICU_UPDATE + return false; +#else // WIP_NEEDS_ICU_UPDATE // Emoji modifier are not expected to change, so there's a small change we need to customize // this. return u_hasBinaryProperty(c, UCHAR_EMOJI_MODIFIER); +#endif // WIP_NEEDS_ICU_UPDATE } bool isEmojiBase(uint32_t c) { +#if WIP_NEEDS_ICU_UPDATE + return false; +#else // WIP_NEEDS_ICU_UPDATE // These two characters were removed from Emoji_Modifier_Base in Emoji 4.0, but we need to keep // them as emoji modifier bases since there are fonts and user-generated text out there that // treats these as potential emoji bases. @@ -62,6 +73,7 @@ bool isEmojiBase(uint32_t c) { return true; } return u_hasBinaryProperty(c, UCHAR_EMOJI_MODIFIER_BASE); +#endif // WIP_NEEDS_ICU_UPDATE } UCharDirection emojiBidiOverride(const void* /* context */, UChar32 c) { diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index e6c5bc912d..697fbc2ba2 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -711,6 +711,10 @@ static void addFeatures(const string &str, vector* features) { static const hb_codepoint_t CHAR_HYPHEN = 0x2010; /* HYPHEN */ static inline hb_codepoint_t determineHyphenChar(hb_codepoint_t preferredHyphen, hb_font_t* font) { +#if WIP_NEEDS_ICU_UPDATE + (void)CHAR_HYPHEN; + return 0x002D; // HYPHEN-MINUS +#else // WIP_NEEDS_ICU_UPDATE hb_codepoint_t glyph; if (preferredHyphen == 0x058A /* ARMENIAN_HYPHEN */ || preferredHyphen == 0x05BE /* HEBREW PUNCTUATION MAQAF */ @@ -732,6 +736,7 @@ static inline hb_codepoint_t determineHyphenChar(hb_codepoint_t preferredHyphen, } } return preferredHyphen; +#endif // WIP_NEEDS_ICU_UPDATE } static inline void addHyphenToHbBuffer(hb_buffer_t* buffer, hb_font_t* font, uint32_t hyphen, diff --git a/engine/src/flutter/src/BUILD.gn b/engine/src/flutter/src/BUILD.gn index 2d603bb38a..e8520ec113 100644 --- a/engine/src/flutter/src/BUILD.gn +++ b/engine/src/flutter/src/BUILD.gn @@ -12,10 +12,10 @@ # See the License for the specific language governing permissions and # limitations under the License. -static_library("src") { +source_set("src") { sources = [ - "font_provider.cc", - "font_provider.h", + "font_collection.cc", + "font_collection.h", "font_skia.cc", "font_skia.h", "font_style.h", @@ -26,15 +26,18 @@ static_library("src") { "paragraph.h", "paragraph_builder.cc", "paragraph_builder.h", + "paragraph_constraints.cc", + "paragraph_constraints.h", + "paragraph_style.cc", "paragraph_style.h", "styled_runs.cc", "styled_runs.h", "text_align.h", + "text_style.cc", "text_style.h", ] - public_deps = [ - "//lib/ftl", + deps = [ "//lib/txt/libs/minikin", "//third_party/skia", ] diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc new file mode 100644 index 0000000000..dc0207b4e5 --- /dev/null +++ b/engine/src/flutter/src/font_collection.cc @@ -0,0 +1,87 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "lib/txt/src/font_collection.h" + +#include + +#include "lib/ftl/logging.h" +#include "lib/txt/src/font_skia.h" +#include "third_party/skia/include/ports/SkFontMgr.h" + +namespace txt { + +FontCollection& FontCollection::GetDefaultFontCollection() { + static FontCollection* collection = nullptr; + static std::once_flag once; + std::call_once(once, []() { collection = new FontCollection(); }); + return *collection; +} + +FontCollection::FontCollection() = default; + +FontCollection::~FontCollection() = default; + +std::shared_ptr +FontCollection::GetMinikinFontCollectionForFamily(const std::string& family) { + // Get the Skia font manager. + auto skia_font_manager = SkFontMgr::RefDefault(); + FTL_DCHECK(skia_font_manager != nullptr); + + // Ask Skia to resolve a font style set for a font family name. + // FIXME(chinmaygarde): The name "Hevetica" is hardcoded because CoreText + // crashes when passed a null string. This seems to be a bug in Skia as + // SkFontMgr explicitly says passing in nullptr gives the default font. + auto font_style_set = skia_font_manager->matchFamily( + family.length() == 0 ? "Helvetica" : family.c_str()); + FTL_DCHECK(font_style_set != nullptr); + + std::vector minikin_fonts; + + // Add fonts to the Minikin font family. + for (int i = 0, style_count = font_style_set->count(); i < style_count; ++i) { + // Create the skia typeface + auto skia_typeface = + sk_ref_sp(font_style_set->createTypeface(i)); + + if (skia_typeface == nullptr) { + continue; + } + + // Create the minikin font from the skia typeface. + minikin::Font minikin_font( + std::make_shared(skia_typeface), + minikin::FontStyle{skia_typeface->fontStyle().weight(), + skia_typeface->isItalic()}); + + minikin_fonts.emplace_back(std::move(minikin_font)); + } + + // Create a Minikin font family. + auto minikin_family = + std::make_shared(std::move(minikin_fonts)); + + // Create a vector of font families for the Minkin font collection. For now, + // we only have one family in our collection. + std::vector> minikin_families = { + minikin_family, + }; + + // Return the font collection. + return std::make_shared(minikin_families); +} + +} // namespace txt diff --git a/engine/src/flutter/src/font_provider.h b/engine/src/flutter/src/font_collection.h similarity index 75% rename from engine/src/flutter/src/font_provider.h rename to engine/src/flutter/src/font_collection.h index 264ee149fc..efca9e35c2 100644 --- a/engine/src/flutter/src/font_provider.h +++ b/engine/src/flutter/src/font_collection.h @@ -22,25 +22,25 @@ #include #include "lib/ftl/macros.h" -#include "lib/txt/include/minikin/FontCollection.h" -#include "lib/txt/include/minikin/FontFamily.h" +#include "minikin/FontCollection.h" +#include "minikin/FontFamily.h" namespace txt { -class FontProvider { +class FontCollection { public: - static FontProvider& GetDefault(); + static FontCollection& GetDefaultFontCollection(); - FontProvider(); + FontCollection(); - ~FontProvider(); + ~FontCollection(); - std::shared_ptr GetFontCollectionForFamily( + std::shared_ptr GetMinikinFontCollectionForFamily( const std::string& family); private: // TODO(chinmaygarde): Caches go here. - FTL_DISALLOW_COPY_AND_ASSIGN(FontProvider); + FTL_DISALLOW_COPY_AND_ASSIGN(FontCollection); }; } // namespace txt diff --git a/engine/src/flutter/src/font_provider.cc b/engine/src/flutter/src/font_provider.cc deleted file mode 100644 index a8a3c8fe9c..0000000000 --- a/engine/src/flutter/src/font_provider.cc +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright 2017 Google Inc. - * - * 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 "lib/txt/src/font_provider.h" - -#include - -#include "lib/ftl/logging.h" -#include "lib/txt/src/font_skia.h" -#include "third_party/skia/include/ports/SkFontMgr.h" - -namespace txt { -namespace { - -bool IsItalic(SkFontStyle::Slant slant) { - return slant != SkFontStyle::Slant::kUpright_Slant; -} - -} // namespace - -FontProvider& FontProvider::GetDefault() { - static FontProvider* provider = nullptr; - static std::once_flag once; - std::call_once(once, []() { provider = new FontProvider(); }); - return *provider; -} - -FontProvider::FontProvider() = default; - -FontProvider::~FontProvider() = default; - -std::shared_ptr -FontProvider::GetFontCollectionForFamily(const std::string& family) { - // Get the Skia font manager. - auto font_manager = SkFontMgr::RefDefault(); - FTL_DCHECK(font_manager != nullptr); - - // Ask Skia to resolve a font style set for a font family name. - // FIXME(chinmaygarde): The name "Hevetica" is hardcoded because CoreText - // crashes when passed a null string. This seems to be a bug in Skia as - // SkFontMgr explicitly says passing in nullptr gives the default font. - auto font_style_set = font_manager->matchFamily( - family.length() == 0 ? "Helvetica" : family.c_str()); - FTL_DCHECK(font_style_set != nullptr); - - std::vector fonts; - - // Add fonts to the Minikin font family. - for (int i = 0, style_count = font_style_set->count(); i < style_count; ++i) { - auto skia_typeface = - sk_ref_sp(font_style_set->createTypeface(i)); - auto typeface = std::make_shared(std::move(skia_typeface)); - - SkFontStyle font_style; - font_style_set->getStyle(i, &font_style, nullptr); - minikin::FontStyle style(font_style.weight(), IsItalic(font_style.slant())); - - fonts.push_back(minikin::Font(std::move(typeface), style)); - } - - auto minikin_family = std::make_shared(std::move(fonts)); - return std::make_shared(std::move(minikin_family)); -} - -} // namespace txt diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index e4a35e7ed4..4fe7d785e7 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -26,7 +26,7 @@ #include "lib/ftl/logging.h" -#include "lib/txt/src/font_provider.h" +#include "lib/txt/src/font_collection.h" #include "lib/txt/src/font_skia.h" #include "third_party/skia/include/core/SkCanvas.h" #include "third_party/skia/include/core/SkPaint.h" @@ -114,7 +114,8 @@ void Paragraph::SetText(std::vector text, StyledRuns runs) { } void Paragraph::AddRunsToLineBreaker() { - auto collection = FontProvider::GetDefault().GetFontCollectionForFamily(""); + auto collection = FontCollection::GetDefaultFontCollection() + .GetMinikinFontCollectionForFamily(""); minikin::FontStyle font; minikin::MinikinPaint paint; for (size_t i = 0; i < runs_.size(); ++i) { @@ -124,8 +125,8 @@ void Paragraph::AddRunsToLineBreaker() { } } -void Paragraph::Layout(double width) { - breaker_.setLineWidths(0.0f, 0, width); +void Paragraph::Layout(const ParagraphConstraints& constraints) { + breaker_.setLineWidths(0.0f, 0, constraints.width()); AddRunsToLineBreaker(); size_t breaks_count = breaker_.computeBreaks(); const int* breaks = breaker_.getBreaks(); @@ -138,7 +139,8 @@ void Paragraph::Layout(double width) { minikin::MinikinPaint minikin_paint; SkTextBlobBuilder builder; - auto collection = FontProvider::GetDefault().GetFontCollectionForFamily(""); + auto collection = FontCollection::GetDefaultFontCollection() + .GetMinikinFontCollectionForFamily(""); minikin::Layout layout; SkScalar x = 0.0f; SkScalar y = 0.0f; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 3b4bcb8757..4fd5d5aff2 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -19,11 +19,11 @@ #include -#include - #include "lib/ftl/macros.h" #include "lib/txt/src/paint_record.h" +#include "lib/txt/src/paragraph_constraints.h" #include "lib/txt/src/styled_runs.h" +#include "minikin/LineBreaker.h" #include "third_party/skia/include/core/SkTextBlob.h" class SkCanvas; @@ -36,7 +36,7 @@ class Paragraph { ~Paragraph(); - void Layout(double width); + void Layout(const ParagraphConstraints& constraints); void Paint(SkCanvas* canvas, double x, double y); diff --git a/engine/src/flutter/src/paragraph_builder.cc b/engine/src/flutter/src/paragraph_builder.cc index 342279cd32..a6db3492a8 100644 --- a/engine/src/flutter/src/paragraph_builder.cc +++ b/engine/src/flutter/src/paragraph_builder.cc @@ -42,8 +42,8 @@ void ParagraphBuilder::Pop() { runs_.StartRun(style_index, text_index); } -void ParagraphBuilder::AddText(const uint16_t* text, size_t length) { - text_.insert(text_.end(), text, text + length); +void ParagraphBuilder::AddText(const std::u16string& text) { + text_.insert(text_.end(), text.begin(), text.end()); } std::unique_ptr ParagraphBuilder::Build() { diff --git a/engine/src/flutter/src/paragraph_builder.h b/engine/src/flutter/src/paragraph_builder.h index 243e6394c8..8c6941af9b 100644 --- a/engine/src/flutter/src/paragraph_builder.h +++ b/engine/src/flutter/src/paragraph_builder.h @@ -38,7 +38,7 @@ class ParagraphBuilder { void Pop(); - void AddText(const uint16_t* text, size_t length); + void AddText(const std::u16string& text); std::unique_ptr Build(); diff --git a/engine/src/flutter/src/paragraph_constraints.cc b/engine/src/flutter/src/paragraph_constraints.cc new file mode 100644 index 0000000000..26a85e0463 --- /dev/null +++ b/engine/src/flutter/src/paragraph_constraints.cc @@ -0,0 +1,23 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "lib/txt/src/paragraph_constraints.h" + +namespace txt { + +ParagraphConstraints::ParagraphConstraints(double width) : width_(width) {} + +} // namespace txt diff --git a/engine/src/flutter/src/paragraph_constraints.h b/engine/src/flutter/src/paragraph_constraints.h new file mode 100644 index 0000000000..e666451527 --- /dev/null +++ b/engine/src/flutter/src/paragraph_constraints.h @@ -0,0 +1,38 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 LIB_TXT_SRC_PARAGRAPH_CONSTRAINTS_H_ +#define LIB_TXT_SRC_PARAGRAPH_CONSTRAINTS_H_ + +#include "lib/ftl/macros.h" + +namespace txt { + +class ParagraphConstraints { + public: + explicit ParagraphConstraints(double width); + + double width() const { return width_; } + + private: + double width_; + + FTL_DISALLOW_COPY_AND_ASSIGN(ParagraphConstraints); +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_PARAGRAPH_CONSTRAINTS_H_ diff --git a/engine/src/flutter/src/paragraph_style.cc b/engine/src/flutter/src/paragraph_style.cc new file mode 100644 index 0000000000..a55c3a37b2 --- /dev/null +++ b/engine/src/flutter/src/paragraph_style.cc @@ -0,0 +1,17 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "lib/txt/src/paragraph_style.h" diff --git a/engine/src/flutter/src/text_style.cc b/engine/src/flutter/src/text_style.cc new file mode 100644 index 0000000000..d7d0ab7a2d --- /dev/null +++ b/engine/src/flutter/src/text_style.cc @@ -0,0 +1,17 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "lib/txt/src/text_style.h" diff --git a/engine/src/flutter/tests/txt/BUILD.gn b/engine/src/flutter/tests/txt/BUILD.gn new file mode 100644 index 0000000000..93e97a1c86 --- /dev/null +++ b/engine/src/flutter/tests/txt/BUILD.gn @@ -0,0 +1,40 @@ +# Copyright 2017 Google, Inc. +# +# 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. + +executable("txt") { + output_name = "txt_unittests" + + include_dirs = [ + "//lib/txt/src", + "//lib/txt/include", + "//third_party/icu/source/common", + ] + + sources = [ + "font_collection_unittests.cc", + "paragraph_unittests.cc", + "render_test.cc", + "txt_run_all_unittests.cc", + ] + + deps = [ + "//dart/runtime:libdart_jit", # Logging + "//flutter/fml", + "//lib/txt/shims", + "//lib/txt/src", + "//third_party/gtest", + "//third_party/harfbuzz", + "//third_party/skia", + ] +} diff --git a/engine/src/flutter/tests/txt/font_collection_unittests.cc b/engine/src/flutter/tests/txt/font_collection_unittests.cc new file mode 100644 index 0000000000..9eaf955daa --- /dev/null +++ b/engine/src/flutter/tests/txt/font_collection_unittests.cc @@ -0,0 +1,25 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "font_collection.h" +#include "gtest/gtest.h" + +TEST(FontCollection, HasDefaultRegistrations) { + auto collection = txt::FontCollection::GetDefaultFontCollection() + .GetMinikinFontCollectionForFamily(""); + + ASSERT_NE(collection.get(), nullptr); +} diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc new file mode 100644 index 0000000000..9ea2d3d306 --- /dev/null +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -0,0 +1,47 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "paragraph.h" +#include "paragraph_builder.h" +#include "render_test.h" +#include "third_party/icu/source/common/unicode/unistr.h" +#include "third_party/skia/include/core/SkColor.h" + +TEST_F(RenderTest, SimpleParagraph) { + const char* text = "Hello World"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + + paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}); + + paragraph->Paint(GetCanvas(), 10.0, 10.0); + + ASSERT_TRUE(Snapshot()); +} diff --git a/engine/src/flutter/tests/txt/render_test.cc b/engine/src/flutter/tests/txt/render_test.cc new file mode 100644 index 0000000000..68b45e98ac --- /dev/null +++ b/engine/src/flutter/tests/txt/render_test.cc @@ -0,0 +1,67 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "render_test.h" +#include "third_party/skia/include/core/SkImageEncoder.h" +#include "third_party/skia/include/core/SkStream.h" + +RenderTest::RenderTest() : snapshots_(0) {} + +RenderTest::~RenderTest() {} + +SkCanvas* RenderTest::GetCanvas() { + return canvas_ == nullptr ? nullptr : canvas_.get(); +} + +std::string RenderTest::GetNextSnapshotName() { + const auto& test_info = + ::testing::UnitTest::GetInstance()->current_test_info(); + + std::stringstream stream; + stream << test_info->test_case_name() << "_" << test_info->name(); + stream << "_" << ++snapshots_ << ".png"; + + return stream.str(); +} + +bool RenderTest::Snapshot() { + if (!canvas_ || !bitmap_) { + return false; + } + auto file_name = GetNextSnapshotName(); + SkFILEWStream file(file_name.c_str()); + return SkEncodeImage(&file, *bitmap_, SkEncodedImageFormat::kPNG, 100); +} + +size_t RenderTest::GetTestCanvasWidth() const { + return 800; +} + +size_t RenderTest::GetTestCanvasHeight() const { + return 600; +} + +void RenderTest::SetUp() { + bitmap_ = std::make_unique(); + bitmap_->allocN32Pixels(GetTestCanvasWidth(), GetTestCanvasHeight()); + canvas_ = std::make_unique(*bitmap_); + canvas_->clear(SK_ColorTRANSPARENT); +} + +void RenderTest::TearDown() { + canvas_ = nullptr; + bitmap_ = nullptr; +} diff --git a/engine/src/flutter/tests/txt/render_test.h b/engine/src/flutter/tests/txt/render_test.h new file mode 100644 index 0000000000..ef32311156 --- /dev/null +++ b/engine/src/flutter/tests/txt/render_test.h @@ -0,0 +1,52 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 +#include + +#include "gtest/gtest.h" +#include "lib/ftl/macros.h" +#include "third_party/skia/include/core/SkBitmap.h" +#include "third_party/skia/include/core/SkCanvas.h" + +class RenderTest : public ::testing::Test { + public: + RenderTest(); + + ~RenderTest(); + + SkCanvas* GetCanvas(); + + bool Snapshot(); + + size_t GetTestCanvasWidth() const; + + size_t GetTestCanvasHeight() const; + + protected: + void SetUp() override; + + void TearDown() override; + + private: + size_t snapshots_; + std::unique_ptr bitmap_; + std::unique_ptr canvas_; + + std::string GetNextSnapshotName(); + + FTL_DISALLOW_COPY_AND_ASSIGN(RenderTest); +}; diff --git a/engine/src/flutter/tests/txt/txt_run_all_unittests.cc b/engine/src/flutter/tests/txt/txt_run_all_unittests.cc new file mode 100644 index 0000000000..a105847fea --- /dev/null +++ b/engine/src/flutter/tests/txt/txt_run_all_unittests.cc @@ -0,0 +1,26 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "flutter/fml/icu_util.h" +#include "gtest/gtest.h" +#include "third_party/skia/include/core/SkGraphics.h" + +int main(int argc, char** argv) { + fml::icu::InitializeICU(); + SkGraphics::Init(); + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/engine/src/flutter/tests/unittest/BUILD.gn b/engine/src/flutter/tests/unittest/BUILD.gn index 5f747f7e59..3355b6880e 100644 --- a/engine/src/flutter/tests/unittest/BUILD.gn +++ b/engine/src/flutter/tests/unittest/BUILD.gn @@ -3,38 +3,39 @@ # found in the LICENSE file. executable("unittest") { - output_name = "txt_unittests" + output_name = "minikin_unittests" testonly = true sources = [ + # "WordBreakerTests.cpp", + "//lib/ftl/test/run_all_unittests.cc", "CmapCoverageTest.cpp", "EmojiTest.cpp", + # TODO(abarth): Re-enable once we have wired up SkFontMgr. # "FontCollectionItemizeTest.cpp", # "FontCollectionTest.cpp", # "FontFamilyTest.cpp", # "FontLanguageListCacheTest.cpp", "GraphemeBreakTests.cpp", + # "HbFontCacheTest.cpp", # "HyphenatorTest.cpp", "ICUTestBase.h", + # "LayoutTest.cpp", "LayoutUtilsTest.cpp", "MeasurementTests.cpp", "SparseBitSetTest.cpp", "UnicodeUtilsTest.cpp", - # "WordBreakerTests.cpp", - "//lib/ftl/test/run_all_unittests.cc", ] - defines = [ - "kTestFontDir=\"/data/nativetest/minikin_tests/data/\"", - ] + defines = [ "kTestFontDir=\"/data/nativetest/minikin_tests/data/\"" ] deps = [ - "//lib/txt/tests/util", "//lib/txt/libs/minikin", + "//lib/txt/tests/util", "//third_party/gtest", ] } From 63bc51106ccad2fa07646bfe76da9505da1fb32d Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 5 Jun 2017 12:08:21 -0700 Subject: [PATCH 282/364] Add command line option to supply --font-directory= Change-Id: If3036a32a82249c9c95d2c5722bdb5ab097c20a1 --- engine/src/flutter/src/font_collection.cc | 14 +++--- engine/src/flutter/src/font_collection.h | 3 +- engine/src/flutter/src/paragraph.cc | 11 ++--- engine/src/flutter/src/paragraph.h | 5 ++- engine/src/flutter/tests/txt/BUILD.gn | 3 ++ .../tests/txt/font_collection_unittests.cc | 8 +++- .../flutter/tests/txt/paragraph_unittests.cc | 6 ++- .../tests/txt/txt_run_all_unittests.cc | 17 ++++++++ engine/src/flutter/tests/txt/utils.cc | 43 +++++++++++++++++++ engine/src/flutter/tests/txt/utils.h | 31 +++++++++++++ engine/src/flutter/tests/util/FileUtils.cpp | 17 ++++---- engine/src/flutter/tests/util/FileUtils.h | 1 - 12 files changed, 133 insertions(+), 26 deletions(-) create mode 100644 engine/src/flutter/tests/txt/utils.cc create mode 100644 engine/src/flutter/tests/txt/utils.h diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index dc0207b4e5..74596e102f 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -21,6 +21,7 @@ #include "lib/ftl/logging.h" #include "lib/txt/src/font_skia.h" #include "third_party/skia/include/ports/SkFontMgr.h" +#include "third_party/skia/include/ports/SkFontMgr_directory.h" namespace txt { @@ -36,17 +37,21 @@ FontCollection::FontCollection() = default; FontCollection::~FontCollection() = default; std::shared_ptr -FontCollection::GetMinikinFontCollectionForFamily(const std::string& family) { +FontCollection::GetMinikinFontCollectionForFamily(const std::string& family, + const std::string& dir) { // Get the Skia font manager. - auto skia_font_manager = SkFontMgr::RefDefault(); + auto skia_font_manager = dir.length() != 0 + ? SkFontMgr_New_Custom_Directory(dir.c_str()) + : SkFontMgr::RefDefault(); + FTL_DCHECK(skia_font_manager != nullptr); // Ask Skia to resolve a font style set for a font family name. - // FIXME(chinmaygarde): The name "Hevetica" is hardcoded because CoreText + // FIXME(chinmaygarde): The name "Sample Font" is hardcoded because CoreText // crashes when passed a null string. This seems to be a bug in Skia as // SkFontMgr explicitly says passing in nullptr gives the default font. auto font_style_set = skia_font_manager->matchFamily( - family.length() == 0 ? "Helvetica" : family.c_str()); + family.length() == 0 ? "Sample Font" : family.c_str()); FTL_DCHECK(font_style_set != nullptr); std::vector minikin_fonts; @@ -56,7 +61,6 @@ FontCollection::GetMinikinFontCollectionForFamily(const std::string& family) { // Create the skia typeface auto skia_typeface = sk_ref_sp(font_style_set->createTypeface(i)); - if (skia_typeface == nullptr) { continue; } diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index efca9e35c2..a85963a6bf 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -36,7 +36,8 @@ class FontCollection { ~FontCollection(); std::shared_ptr GetMinikinFontCollectionForFamily( - const std::string& family); + const std::string& family, + const std::string& dir = ""); private: // TODO(chinmaygarde): Caches go here. diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 4fe7d785e7..dad0c69127 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -113,9 +113,9 @@ void Paragraph::SetText(std::vector text, StyledRuns runs) { breaker_.setText(); } -void Paragraph::AddRunsToLineBreaker() { +void Paragraph::AddRunsToLineBreaker(const std::string& rootdir) { auto collection = FontCollection::GetDefaultFontCollection() - .GetMinikinFontCollectionForFamily(""); + .GetMinikinFontCollectionForFamily("", rootdir); minikin::FontStyle font; minikin::MinikinPaint paint; for (size_t i = 0; i < runs_.size(); ++i) { @@ -125,9 +125,10 @@ void Paragraph::AddRunsToLineBreaker() { } } -void Paragraph::Layout(const ParagraphConstraints& constraints) { +void Paragraph::Layout(const ParagraphConstraints& constraints, + const std::string& rootdir) { breaker_.setLineWidths(0.0f, 0, constraints.width()); - AddRunsToLineBreaker(); + AddRunsToLineBreaker(rootdir); size_t breaks_count = breaker_.computeBreaks(); const int* breaks = breaker_.getBreaks(); @@ -140,7 +141,7 @@ void Paragraph::Layout(const ParagraphConstraints& constraints) { SkTextBlobBuilder builder; auto collection = FontCollection::GetDefaultFontCollection() - .GetMinikinFontCollectionForFamily(""); + .GetMinikinFontCollectionForFamily("", rootdir); minikin::Layout layout; SkScalar x = 0.0f; SkScalar y = 0.0f; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 4fd5d5aff2..eee7f43583 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -36,7 +36,8 @@ class Paragraph { ~Paragraph(); - void Layout(const ParagraphConstraints& constraints); + void Layout(const ParagraphConstraints& constraints, + const std::string& rootdir = ""); void Paint(SkCanvas* canvas, double x, double y); @@ -50,7 +51,7 @@ class Paragraph { void SetText(std::vector text, StyledRuns runs); - void AddRunsToLineBreaker(); + void AddRunsToLineBreaker(const std::string& rootdir = ""); FTL_DISALLOW_COPY_AND_ASSIGN(Paragraph); }; diff --git a/engine/src/flutter/tests/txt/BUILD.gn b/engine/src/flutter/tests/txt/BUILD.gn index 93e97a1c86..3fb1019628 100644 --- a/engine/src/flutter/tests/txt/BUILD.gn +++ b/engine/src/flutter/tests/txt/BUILD.gn @@ -25,7 +25,10 @@ executable("txt") { "font_collection_unittests.cc", "paragraph_unittests.cc", "render_test.cc", + "render_test.h", "txt_run_all_unittests.cc", + "utils.cc", + "utils.h", ] deps = [ diff --git a/engine/src/flutter/tests/txt/font_collection_unittests.cc b/engine/src/flutter/tests/txt/font_collection_unittests.cc index 9eaf955daa..1be73be10f 100644 --- a/engine/src/flutter/tests/txt/font_collection_unittests.cc +++ b/engine/src/flutter/tests/txt/font_collection_unittests.cc @@ -16,10 +16,14 @@ #include "font_collection.h" #include "gtest/gtest.h" +#include "lib/ftl/command_line.h" +#include "lib/ftl/logging.h" +#include "lib/txt/tests/txt/utils.h" TEST(FontCollection, HasDefaultRegistrations) { - auto collection = txt::FontCollection::GetDefaultFontCollection() - .GetMinikinFontCollectionForFamily(""); + auto collection = + txt::FontCollection::GetDefaultFontCollection() + .GetMinikinFontCollectionForFamily("", txt::GetFontDir()); ASSERT_NE(collection.get(), nullptr); } diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 9ea2d3d306..723b5d828f 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -14,6 +14,8 @@ * limitations under the License. */ +#include "lib/ftl/logging.h" +#include "lib/txt/tests/txt/utils.h" #include "paragraph.h" #include "paragraph_builder.h" #include "render_test.h" @@ -38,8 +40,8 @@ TEST_F(RenderTest, SimpleParagraph) { builder.Pop(); auto paragraph = builder.Build(); - - paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}); + paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, + txt::GetFontDir()); paragraph->Paint(GetCanvas(), 10.0, 10.0); diff --git a/engine/src/flutter/tests/txt/txt_run_all_unittests.cc b/engine/src/flutter/tests/txt/txt_run_all_unittests.cc index a105847fea..d5c62a171f 100644 --- a/engine/src/flutter/tests/txt/txt_run_all_unittests.cc +++ b/engine/src/flutter/tests/txt/txt_run_all_unittests.cc @@ -16,9 +16,26 @@ #include "flutter/fml/icu_util.h" #include "gtest/gtest.h" +#include "lib/ftl/command_line.h" +#include "lib/ftl/logging.h" +#include "lib/txt/tests/txt/utils.h" #include "third_party/skia/include/core/SkGraphics.h" +#include + int main(int argc, char** argv) { + ftl::CommandLine cmd = ftl::CommandLineFromArgcArgv(argc, argv); + txt::SetCommandLine(cmd); + std::string dir = txt::GetCommandLineForProcess().GetOptionValueWithDefault( + "font-directory", ""); + txt::SetFontDir(dir); + if (txt::GetFontDir().length() <= 0) { + FTL_LOG(ERROR) << "Font directory must be specified with " + "--font-directoy=\"\" to run this test."; + return EXIT_FAILURE; + } + FTL_DCHECK(txt::GetFontDir().length() > 0); + fml::icu::InitializeICU(); SkGraphics::Init(); testing::InitGoogleTest(&argc, argv); diff --git a/engine/src/flutter/tests/txt/utils.cc b/engine/src/flutter/tests/txt/utils.cc new file mode 100644 index 0000000000..3f853b8a92 --- /dev/null +++ b/engine/src/flutter/tests/txt/utils.cc @@ -0,0 +1,43 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 + +#include "lib/ftl/command_line.h" +#include "lib/txt/tests/txt/utils.h" + +namespace txt { + +static std::string gFontdir; +static ftl::CommandLine gCommandLine; + +const std::string GetFontDir() { + return gFontdir; +} + +void SetFontDir(std::string& dir) { + gFontdir = dir; +} + +const ftl::CommandLine& GetCommandLineForProcess() { + return gCommandLine; +} + +void SetCommandLine(ftl::CommandLine cmd) { + gCommandLine = std::move(cmd); +} + +} // namespace txt diff --git a/engine/src/flutter/tests/txt/utils.h b/engine/src/flutter/tests/txt/utils.h new file mode 100644 index 0000000000..ed42b82073 --- /dev/null +++ b/engine/src/flutter/tests/txt/utils.h @@ -0,0 +1,31 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 + +#include "lib/ftl/command_line.h" + +namespace txt { + +const std::string GetFontDir(); + +void SetFontDir(std::string& dir); + +const ftl::CommandLine& GetCommandLineForProcess(); + +void SetCommandLine(ftl::CommandLine cmd); + +} // namespace txt diff --git a/engine/src/flutter/tests/util/FileUtils.cpp b/engine/src/flutter/tests/util/FileUtils.cpp index 92cf9191bc..07f65342ab 100644 --- a/engine/src/flutter/tests/util/FileUtils.cpp +++ b/engine/src/flutter/tests/util/FileUtils.cpp @@ -23,13 +23,14 @@ #include std::vector readWholeFile(const std::string& filePath) { - FILE* fp = fopen(filePath.c_str(), "r"); - LOG_ALWAYS_FATAL_IF(fp == nullptr); - struct stat st; - LOG_ALWAYS_FATAL_IF(fstat(fileno(fp), &st) != 0); + FILE* fp = fopen(filePath.c_str(), "r"); + LOG_ALWAYS_FATAL_IF(fp == nullptr); + struct stat st; + LOG_ALWAYS_FATAL_IF(fstat(fileno(fp), &st) != 0); - std::vector result(st.st_size); - LOG_ALWAYS_FATAL_IF(fread(result.data(), 1, st.st_size, fp) != static_cast(st.st_size)); - fclose(fp); - return result; + std::vector result(st.st_size); + LOG_ALWAYS_FATAL_IF(fread(result.data(), 1, st.st_size, fp) != + static_cast(st.st_size)); + fclose(fp); + return result; } diff --git a/engine/src/flutter/tests/util/FileUtils.h b/engine/src/flutter/tests/util/FileUtils.h index 1e66d1b701..e9c5ef1c34 100644 --- a/engine/src/flutter/tests/util/FileUtils.h +++ b/engine/src/flutter/tests/util/FileUtils.h @@ -15,4 +15,3 @@ */ std::vector readWholeFile(const std::string& filePath); - From 22345d608eece1cef845b8781d0f67ec3458fc58 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 5 Jun 2017 17:33:38 -0700 Subject: [PATCH 283/364] Add fonts to Paragraph and additional tests. Change-Id: I023cc9bc413975dabc770f6b59d4ffd1fc842ab2 --- engine/src/flutter/src/font_collection.cc | 5 +- engine/src/flutter/src/paragraph.cc | 11 +- engine/src/flutter/src/text_style.h | 2 +- .../flutter/tests/txt/paragraph_unittests.cc | 119 ++++++++++++++++++ 4 files changed, 130 insertions(+), 7 deletions(-) diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index 74596e102f..dfbfbc14b2 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -47,11 +47,12 @@ FontCollection::GetMinikinFontCollectionForFamily(const std::string& family, FTL_DCHECK(skia_font_manager != nullptr); // Ask Skia to resolve a font style set for a font family name. - // FIXME(chinmaygarde): The name "Sample Font" is hardcoded because CoreText + // FIXME(chinmaygarde): The name "Coolvetica" is hardcoded because CoreText // crashes when passed a null string. This seems to be a bug in Skia as // SkFontMgr explicitly says passing in nullptr gives the default font. + auto font_style_set = skia_font_manager->matchFamily( - family.length() == 0 ? "Sample Font" : family.c_str()); + family.length() == 0 ? "Roboto" : family.c_str()); FTL_DCHECK(font_style_set != nullptr); std::vector minikin_fonts; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index dad0c69127..705a137921 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -114,12 +114,13 @@ void Paragraph::SetText(std::vector text, StyledRuns runs) { } void Paragraph::AddRunsToLineBreaker(const std::string& rootdir) { - auto collection = FontCollection::GetDefaultFontCollection() - .GetMinikinFontCollectionForFamily("", rootdir); minikin::FontStyle font; minikin::MinikinPaint paint; for (size_t i = 0; i < runs_.size(); ++i) { auto run = runs_.GetRun(i); + auto collection = + FontCollection::GetDefaultFontCollection() + .GetMinikinFontCollectionForFamily(run.style.font_family, rootdir); GetFontAndMinikinPaint(run.style, &font, &paint); breaker_.addStyleRun(&paint, collection, font, run.start, run.end, false); } @@ -140,14 +141,16 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, minikin::MinikinPaint minikin_paint; SkTextBlobBuilder builder; - auto collection = FontCollection::GetDefaultFontCollection() - .GetMinikinFontCollectionForFamily("", rootdir); + minikin::Layout layout; SkScalar x = 0.0f; SkScalar y = 0.0f; size_t break_index = 0; for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { auto run = runs_.GetRun(run_index); + auto collection = + FontCollection::GetDefaultFontCollection() + .GetMinikinFontCollectionForFamily(run.style.font_family, rootdir); GetFontAndMinikinPaint(run.style, &font, &minikin_paint); GetPaint(run.style, &paint); diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index f2482dd406..2b6c2cc632 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -34,7 +34,7 @@ class TextStyle { FontWeight font_weight = FontWeight::w400; FontStyle font_style = FontStyle::normal; // TextBaseline text_baseline; - std::string font_family; + std::string font_family = ""; double font_size = 14.0; double letter_spacing = 0.0; double word_spacing = 0.0; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 723b5d828f..dd98be7ea2 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -34,6 +34,31 @@ TEST_F(RenderTest, SimpleParagraph) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; builder.PushStyle(text_style); + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, + txt::GetFontDir()); + + paragraph->Paint(GetCanvas(), 10.0, 10.0); + + ASSERT_TRUE(Snapshot()); +} + +TEST_F(RenderTest, SimpleRedParagraph) { + const char* text = "I am RED"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.color = SK_ColorRED; + builder.PushStyle(text_style); builder.AddText(u16_text); @@ -47,3 +72,97 @@ TEST_F(RenderTest, SimpleParagraph) { ASSERT_TRUE(Snapshot()); } + +TEST_F(RenderTest, LongParagraph) { + const char* text1 = "RedRoboto"; + auto icu_text1 = icu::UnicodeString::fromUTF8(text1); + std::u16string u16_text1(icu_text1.getBuffer(), + icu_text1.getBuffer() + icu_text1.length()); + const char* text2 = "BigGreenDefault"; + auto icu_text2 = icu::UnicodeString::fromUTF8(text2); + std::u16string u16_text2(icu_text2.getBuffer(), + icu_text2.getBuffer() + icu_text2.length()); + const char* text3 = "DefcolorHomemadeApple"; + auto icu_text3 = icu::UnicodeString::fromUTF8(text3); + std::u16string u16_text3(icu_text3.getBuffer(), + icu_text3.getBuffer() + icu_text3.length()); + const char* text4 = "SmallBlueRoboto"; + auto icu_text4 = icu::UnicodeString::fromUTF8(text4); + std::u16string u16_text4(icu_text4.getBuffer(), + icu_text4.getBuffer() + icu_text4.length()); + const char* text5 = "ContinueLastStyle"; + auto icu_text5 = icu::UnicodeString::fromUTF8(text5); + std::u16string u16_text5(icu_text5.getBuffer(), + icu_text5.getBuffer() + icu_text5.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style1; + text_style1.color = SK_ColorRED; + text_style1.font_family = "Roboto"; + builder.PushStyle(text_style1); + + builder.AddText(u16_text1); + + txt::TextStyle text_style2; + text_style2.font_size = 30; + // Letter spacing not yet implemented + text_style2.letter_spacing = 10; + text_style2.color = SK_ColorGREEN; + builder.PushStyle(text_style2); + + builder.AddText(u16_text2); + + txt::TextStyle text_style3; + text_style3.font_family = "Homemade Apple"; + builder.PushStyle(text_style3); + + builder.AddText(u16_text3); + + txt::TextStyle text_style4; + text_style4.font_size = 10; + text_style4.color = SK_ColorBLUE; + text_style4.font_family = "Roboto"; + builder.PushStyle(text_style4); + + builder.AddText(u16_text4); + + // extra text to see if it goes to default + builder.AddText(u16_text5); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, + txt::GetFontDir()); + + paragraph->Paint(GetCanvas(), 10.0, 30.0); + + ASSERT_TRUE(Snapshot()); +} + +TEST_F(RenderTest, DefaultStyleParagraph) { + const char* text = "No TextStyle! Uh Oh!"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.color = SK_ColorRED; + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, + txt::GetFontDir()); + + paragraph->Paint(GetCanvas(), 10.0, 10.0); + + ASSERT_TRUE(Snapshot()); +} \ No newline at end of file From 75752cc8d28e9fec7738b763e02a7eb126cd0a5f Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 6 Jun 2017 11:08:00 -0700 Subject: [PATCH 284/364] Support for 'fake bold' text and additional tests Change-Id: Ic9863052365316ea188fcf79b15378be90f440f6 --- engine/src/flutter/src/BUILD.gn | 1 + engine/src/flutter/src/font_collection.cc | 8 +- engine/src/flutter/src/font_collection.h | 12 ++ engine/src/flutter/src/paragraph.cc | 3 +- engine/src/flutter/src/text_style.h | 1 + .../tests/txt/font_collection_unittests.cc | 36 +++++- .../flutter/tests/txt/paragraph_unittests.cc | 113 ++++++++++++++++-- 7 files changed, 160 insertions(+), 14 deletions(-) diff --git a/engine/src/flutter/src/BUILD.gn b/engine/src/flutter/src/BUILD.gn index e8520ec113..2d5792f88a 100644 --- a/engine/src/flutter/src/BUILD.gn +++ b/engine/src/flutter/src/BUILD.gn @@ -40,5 +40,6 @@ source_set("src") { deps = [ "//lib/txt/libs/minikin", "//third_party/skia", + "//third_party/gtest", ] } diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index dfbfbc14b2..6763617d71 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -36,6 +36,10 @@ FontCollection::FontCollection() = default; FontCollection::~FontCollection() = default; +const std::string FontCollection::ProcessFamilyName(const std::string& family) { + return family.length() == 0 ? DEFAULT_FAMILY_NAME : family; +} + std::shared_ptr FontCollection::GetMinikinFontCollectionForFamily(const std::string& family, const std::string& dir) { @@ -51,8 +55,8 @@ FontCollection::GetMinikinFontCollectionForFamily(const std::string& family, // crashes when passed a null string. This seems to be a bug in Skia as // SkFontMgr explicitly says passing in nullptr gives the default font. - auto font_style_set = skia_font_manager->matchFamily( - family.length() == 0 ? "Roboto" : family.c_str()); + auto font_style_set = + skia_font_manager->matchFamily(ProcessFamilyName(family).c_str()); FTL_DCHECK(font_style_set != nullptr); std::vector minikin_fonts; diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index a85963a6bf..b78de954d8 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -17,11 +17,14 @@ #ifndef LIB_TXT_SRC_FONT_COLLECTION_H_ #define LIB_TXT_SRC_FONT_COLLECTION_H_ +#define DEFAULT_FAMILY_NAME "Roboto" + #include #include #include #include "lib/ftl/macros.h" +#include "lib/txt/tests/txt/render_test.h" #include "minikin/FontCollection.h" #include "minikin/FontFamily.h" @@ -38,8 +41,17 @@ class FontCollection { std::shared_ptr GetMinikinFontCollectionForFamily( const std::string& family, const std::string& dir = ""); + // Temporarily public. + const std::string ProcessFamilyName(const std::string& family); + + // For Testing. Temporarily public. + static const std::string GetDefaultFamilyName() { + return DEFAULT_FAMILY_NAME; + }; private: + friend RenderTest; + // TODO(chinmaygarde): Caches go here. FTL_DISALLOW_COPY_AND_ASSIGN(FontCollection); }; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 705a137921..44caeada36 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -90,11 +90,12 @@ void GetFontAndMinikinPaint(const TextStyle& style, *font = minikin::FontStyle(GetWeight(style), GetItalic(style)); paint->size = style.font_size; paint->letterSpacing = style.letter_spacing; - // TODO(abarth): font_family, word_spacing. + // TODO(abarth): word_spacing. } void GetPaint(const TextStyle& style, SkPaint* paint) { paint->setTextSize(style.font_size); + paint->setFakeBoldText(style.fake_bold); } } // namespace diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index 2b6c2cc632..21c122abfe 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -33,6 +33,7 @@ class TextStyle { // TextDecorationStyle decoration_style FontWeight font_weight = FontWeight::w400; FontStyle font_style = FontStyle::normal; + bool fake_bold = false; // TextBaseline text_baseline; std::string font_family = ""; double font_size = 14.0; diff --git a/engine/src/flutter/tests/txt/font_collection_unittests.cc b/engine/src/flutter/tests/txt/font_collection_unittests.cc index 1be73be10f..1851f04af9 100644 --- a/engine/src/flutter/tests/txt/font_collection_unittests.cc +++ b/engine/src/flutter/tests/txt/font_collection_unittests.cc @@ -21,9 +21,43 @@ #include "lib/txt/tests/txt/utils.h" TEST(FontCollection, HasDefaultRegistrations) { + std::string defaultFamilyName = txt::FontCollection::GetDefaultFamilyName(); + auto collection = txt::FontCollection::GetDefaultFontCollection() .GetMinikinFontCollectionForFamily("", txt::GetFontDir()); - + ASSERT_EQ( + defaultFamilyName, + txt::FontCollection::GetDefaultFontCollection().ProcessFamilyName("")); + ASSERT_NE(defaultFamilyName, + txt::FontCollection::GetDefaultFontCollection().ProcessFamilyName( + "NotARealFont!")); + ASSERT_EQ("NotARealFont!", + txt::FontCollection::GetDefaultFontCollection().ProcessFamilyName( + "NotARealFont!")); ASSERT_NE(collection.get(), nullptr); } + +TEST(FontCollection, GetMinikinFontCollections) { + std::string defaultFamilyName = txt::FontCollection::GetDefaultFamilyName(); + + auto collectionDef = + txt::FontCollection::GetDefaultFontCollection() + .GetMinikinFontCollectionForFamily("", txt::GetFontDir()); + auto collectionRoboto = + txt::FontCollection::GetDefaultFontCollection() + .GetMinikinFontCollectionForFamily("Roboto", txt::GetFontDir()); + auto collectionHomemadeApple = txt::FontCollection::GetDefaultFontCollection() + .GetMinikinFontCollectionForFamily( + "Homemade Apple", txt::GetFontDir()); + for (size_t base = 0; base < 50; base++) { + for (size_t variation = 0; variation < 50; variation++) { + ASSERT_EQ(collectionDef->hasVariationSelector(base, variation), + collectionRoboto->hasVariationSelector(base, variation)); + } + } + + ASSERT_NE(collectionDef, collectionHomemadeApple); + ASSERT_NE(collectionHomemadeApple, collectionRoboto); + ASSERT_NE(collectionDef.get(), nullptr); +} diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index dd98be7ea2..9aa842ee28 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -15,6 +15,8 @@ */ #include "lib/ftl/logging.h" +#include "lib/txt/src/font_style.h" +#include "lib/txt/src/font_weight.h" #include "lib/txt/tests/txt/utils.h" #include "paragraph.h" #include "paragraph_builder.h" @@ -42,7 +44,7 @@ TEST_F(RenderTest, SimpleParagraph) { paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, txt::GetFontDir()); - paragraph->Paint(GetCanvas(), 10.0, 10.0); + paragraph->Paint(GetCanvas(), 10.0, 15.0); ASSERT_TRUE(Snapshot()); } @@ -68,25 +70,25 @@ TEST_F(RenderTest, SimpleRedParagraph) { paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, txt::GetFontDir()); - paragraph->Paint(GetCanvas(), 10.0, 10.0); + paragraph->Paint(GetCanvas(), 10.0, 15.0); ASSERT_TRUE(Snapshot()); } -TEST_F(RenderTest, LongParagraph) { - const char* text1 = "RedRoboto"; +TEST_F(RenderTest, RainbowParagraph) { + const char* text1 = "RedRoboto "; auto icu_text1 = icu::UnicodeString::fromUTF8(text1); std::u16string u16_text1(icu_text1.getBuffer(), icu_text1.getBuffer() + icu_text1.length()); - const char* text2 = "BigGreenDefault"; + const char* text2 = "BigGreenDefault "; auto icu_text2 = icu::UnicodeString::fromUTF8(text2); std::u16string u16_text2(icu_text2.getBuffer(), icu_text2.getBuffer() + icu_text2.length()); - const char* text3 = "DefcolorHomemadeApple"; + const char* text3 = "DefcolorHomemadeApple "; auto icu_text3 = icu::UnicodeString::fromUTF8(text3); std::u16string u16_text3(icu_text3.getBuffer(), icu_text3.getBuffer() + icu_text3.length()); - const char* text4 = "SmallBlueRoboto"; + const char* text4 = "SmallBlueRoboto "; auto icu_text4 = icu::UnicodeString::fromUTF8(text4); std::u16string u16_text4(icu_text4.getBuffer(), icu_text4.getBuffer() + icu_text4.length()); @@ -108,7 +110,9 @@ TEST_F(RenderTest, LongParagraph) { txt::TextStyle text_style2; text_style2.font_size = 30; // Letter spacing not yet implemented - text_style2.letter_spacing = 10; + text_style2.letter_spacing = 100; + text_style2.font_weight = txt::FontWeight::w600; + text_style2.fake_bold = true; text_style2.color = SK_ColorGREEN; builder.PushStyle(text_style2); @@ -128,7 +132,8 @@ TEST_F(RenderTest, LongParagraph) { builder.AddText(u16_text4); - // extra text to see if it goes to default + // Extra text to see if it goes to default when there is more text chunks than + // styles. builder.AddText(u16_text5); builder.Pop(); @@ -142,6 +147,7 @@ TEST_F(RenderTest, LongParagraph) { ASSERT_TRUE(Snapshot()); } +// Currently, this should render nothing without a supplied TextStyle. TEST_F(RenderTest, DefaultStyleParagraph) { const char* text = "No TextStyle! Uh Oh!"; auto icu_text = icu::UnicodeString::fromUTF8(text); @@ -162,7 +168,94 @@ TEST_F(RenderTest, DefaultStyleParagraph) { paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, txt::GetFontDir()); - paragraph->Paint(GetCanvas(), 10.0, 10.0); + paragraph->Paint(GetCanvas(), 10.0, 15.0); + + ASSERT_TRUE(Snapshot()); +} + +TEST_F(RenderTest, BoldParagraph) { + const char* text = "This is Red max bold text!"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.font_size = 60; + // Letter spacing not yet implemented + text_style.letter_spacing = 10; + text_style.font_weight = txt::FontWeight::w900; + text_style.fake_bold = true; + text_style.color = SK_ColorRED; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, + txt::GetFontDir()); + + paragraph->Paint(GetCanvas(), 10.0, 60.0); + + ASSERT_TRUE(Snapshot()); +} + +TEST_F(RenderTest, LinebreakParagraph) { + const char* text = + "This is a very long sentence to test if the text will properly wrap " + "around and go to the next line. Sometimes, short sentence. Longer " + "sentences are okay too because they are nessecary. Very short." + "This is a very long sentence to test if the text will properly wrap " + "around and go to the next line. Sometimes, short sentence. Longer " + "sentences are okay too because they are nessecary. Very short." + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum." + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum." + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.font_size = 26; + // Letter spacing not yet implemented + text_style.letter_spacing = 10; + text_style.color = SK_ColorBLACK; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, + txt::GetFontDir()); + + paragraph->Paint(GetCanvas(), 5.0, 30.0); ASSERT_TRUE(Snapshot()); } \ No newline at end of file From 4e5639d921ed567a2007088279c49244866255f1 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 6 Jun 2017 16:23:28 -0700 Subject: [PATCH 285/364] Add additional test framework and tests for Italics. Overloaded paragraph text entry methods. Change-Id: I0ae9abd6130edd276b1144a0092e03e47373427d --- engine/src/flutter/src/font_collection.cc | 16 +++++ engine/src/flutter/src/font_collection.h | 17 +++-- engine/src/flutter/src/paragraph.cc | 4 +- engine/src/flutter/src/paragraph.h | 8 +++ engine/src/flutter/src/paragraph_builder.cc | 15 ++++ engine/src/flutter/src/paragraph_builder.h | 4 ++ .../tests/txt/font_collection_unittests.cc | 11 +++ .../flutter/tests/txt/paragraph_unittests.cc | 70 +++++++++++++++++-- 8 files changed, 132 insertions(+), 13 deletions(-) diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index 6763617d71..da24410388 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -17,9 +17,12 @@ #include "lib/txt/src/font_collection.h" #include +#include +#include #include "lib/ftl/logging.h" #include "lib/txt/src/font_skia.h" +#include "third_party/skia/include/core/SkString.h" #include "third_party/skia/include/ports/SkFontMgr.h" #include "third_party/skia/include/ports/SkFontMgr_directory.h" @@ -36,6 +39,19 @@ FontCollection::FontCollection() = default; FontCollection::~FontCollection() = default; +std::set FontCollection::GetFamilyNames(const std::string& dir) { + auto skia_font_manager = dir.length() != 0 + ? SkFontMgr_New_Custom_Directory(dir.c_str()) + : SkFontMgr::RefDefault(); + std::set names; + SkString str; + for (int i = 0; i < skia_font_manager->countFamilies(); i++) { + skia_font_manager->getFamilyName(i, &str); + names.insert(std::string{str.writable_str()}); + } + return names; +} + const std::string FontCollection::ProcessFamilyName(const std::string& family) { return family.length() == 0 ? DEFAULT_FAMILY_NAME : family; } diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index b78de954d8..43bdbec16f 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -20,13 +20,14 @@ #define DEFAULT_FAMILY_NAME "Roboto" #include +#include #include #include #include "lib/ftl/macros.h" -#include "lib/txt/tests/txt/render_test.h" #include "minikin/FontCollection.h" #include "minikin/FontFamily.h" +#include "third_party/gtest/include/gtest/gtest_prod.h" namespace txt { @@ -41,17 +42,21 @@ class FontCollection { std::shared_ptr GetMinikinFontCollectionForFamily( const std::string& family, const std::string& dir = ""); - // Temporarily public. + + // Provides a vector of all available family names. + static std::set GetFamilyNames(const std::string& dir = ""); + + private: + FRIEND_TEST(FontCollection, HasDefaultRegistrations); + FRIEND_TEST(FontCollection, GetMinikinFontCollections); + FRIEND_TEST(FontCollection, GetFamilyNames); + const std::string ProcessFamilyName(const std::string& family); - // For Testing. Temporarily public. static const std::string GetDefaultFamilyName() { return DEFAULT_FAMILY_NAME; }; - private: - friend RenderTest; - // TODO(chinmaygarde): Caches go here. FTL_DISALLOW_COPY_AND_ASSIGN(FontCollection); }; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 44caeada36..ce2edaa866 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -60,13 +60,13 @@ int GetWeight(const TextStyle& style) { return 2; case FontWeight::w300: return 3; - case FontWeight::w400: + case FontWeight::w400: // Normal. return 4; case FontWeight::w500: return 5; case FontWeight::w600: return 6; - case FontWeight::w700: + case FontWeight::w700: // Bold. return 7; case FontWeight::w800: return 8; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index eee7f43583..0ec43df129 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -24,6 +24,7 @@ #include "lib/txt/src/paragraph_constraints.h" #include "lib/txt/src/styled_runs.h" #include "minikin/LineBreaker.h" +#include "third_party/gtest/include/gtest/gtest_prod.h" #include "third_party/skia/include/core/SkTextBlob.h" class SkCanvas; @@ -43,6 +44,13 @@ class Paragraph { private: friend class ParagraphBuilder; + FRIEND_TEST(RenderTest, SimpleParagraph); + FRIEND_TEST(RenderTest, SimpleRedParagraph); + FRIEND_TEST(RenderTest, RainbowParagraph); + FRIEND_TEST(RenderTest, DefaultStyleParagraph); + FRIEND_TEST(RenderTest, BoldParagraph); + FRIEND_TEST(RenderTest, LinebreakParagraph); + FRIEND_TEST(RenderTest, ItalicsParagraph); std::vector text_; StyledRuns runs_; diff --git a/engine/src/flutter/src/paragraph_builder.cc b/engine/src/flutter/src/paragraph_builder.cc index a6db3492a8..4976b86126 100644 --- a/engine/src/flutter/src/paragraph_builder.cc +++ b/engine/src/flutter/src/paragraph_builder.cc @@ -15,6 +15,7 @@ */ #include "lib/txt/src/paragraph_builder.h" +#include "third_party/icu/source/common/unicode/unistr.h" namespace txt { @@ -46,6 +47,20 @@ void ParagraphBuilder::AddText(const std::u16string& text) { text_.insert(text_.end(), text.begin(), text.end()); } +void ParagraphBuilder::AddText(const std::string& text) { + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + AddText(u16_text); +} + +void ParagraphBuilder::AddText(const char* text) { + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + AddText(u16_text); +} + std::unique_ptr ParagraphBuilder::Build() { runs_.EndRunIfNeeded(text_.size()); std::unique_ptr paragraph = std::make_unique(); diff --git a/engine/src/flutter/src/paragraph_builder.h b/engine/src/flutter/src/paragraph_builder.h index 8c6941af9b..71598af0b5 100644 --- a/engine/src/flutter/src/paragraph_builder.h +++ b/engine/src/flutter/src/paragraph_builder.h @@ -40,6 +40,10 @@ class ParagraphBuilder { void AddText(const std::u16string& text); + void AddText(const std::string& text); + + void AddText(const char* text); + std::unique_ptr Build(); private: diff --git a/engine/src/flutter/tests/txt/font_collection_unittests.cc b/engine/src/flutter/tests/txt/font_collection_unittests.cc index 1851f04af9..ab15710e96 100644 --- a/engine/src/flutter/tests/txt/font_collection_unittests.cc +++ b/engine/src/flutter/tests/txt/font_collection_unittests.cc @@ -20,6 +20,8 @@ #include "lib/ftl/logging.h" #include "lib/txt/tests/txt/utils.h" +namespace txt { + TEST(FontCollection, HasDefaultRegistrations) { std::string defaultFamilyName = txt::FontCollection::GetDefaultFamilyName(); @@ -61,3 +63,12 @@ TEST(FontCollection, GetMinikinFontCollections) { ASSERT_NE(collectionHomemadeApple, collectionRoboto); ASSERT_NE(collectionDef.get(), nullptr); } + +TEST(FontCollection, GetFamilyNames) { + std::set names = + txt::FontCollection::GetFamilyNames(txt::GetFontDir()); + + ASSERT_EQ(names.size(), 19ull); +} + +} // namespace txt \ No newline at end of file diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 9aa842ee28..11b816241b 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -17,13 +17,15 @@ #include "lib/ftl/logging.h" #include "lib/txt/src/font_style.h" #include "lib/txt/src/font_weight.h" +#include "lib/txt/src/paragraph.h" #include "lib/txt/tests/txt/utils.h" -#include "paragraph.h" #include "paragraph_builder.h" #include "render_test.h" #include "third_party/icu/source/common/unicode/unistr.h" #include "third_party/skia/include/core/SkColor.h" +namespace txt { + TEST_F(RenderTest, SimpleParagraph) { const char* text = "Hello World"; auto icu_text = icu::UnicodeString::fromUTF8(text); @@ -46,6 +48,10 @@ TEST_F(RenderTest, SimpleParagraph) { paragraph->Paint(GetCanvas(), 10.0, 15.0); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } ASSERT_TRUE(Snapshot()); } @@ -72,6 +78,10 @@ TEST_F(RenderTest, SimpleRedParagraph) { paragraph->Paint(GetCanvas(), 10.0, 15.0); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } ASSERT_TRUE(Snapshot()); } @@ -108,7 +118,7 @@ TEST_F(RenderTest, RainbowParagraph) { builder.AddText(u16_text1); txt::TextStyle text_style2; - text_style2.font_size = 30; + text_style2.font_size = 50; // Letter spacing not yet implemented text_style2.letter_spacing = 100; text_style2.font_weight = txt::FontWeight::w600; @@ -142,8 +152,12 @@ TEST_F(RenderTest, RainbowParagraph) { paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, txt::GetFontDir()); - paragraph->Paint(GetCanvas(), 10.0, 30.0); + paragraph->Paint(GetCanvas(), 10.0, 50.0); + u16_text1 += u16_text2 + u16_text3 + u16_text4; + for (size_t i = 0; i < u16_text1.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text1[i]); + } ASSERT_TRUE(Snapshot()); } @@ -170,6 +184,10 @@ TEST_F(RenderTest, DefaultStyleParagraph) { paragraph->Paint(GetCanvas(), 10.0, 15.0); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } ASSERT_TRUE(Snapshot()); } @@ -186,7 +204,7 @@ TEST_F(RenderTest, BoldParagraph) { text_style.font_size = 60; // Letter spacing not yet implemented text_style.letter_spacing = 10; - text_style.font_weight = txt::FontWeight::w900; + text_style.font_weight = txt::FontWeight::w700; text_style.fake_bold = true; text_style.color = SK_ColorRED; builder.PushStyle(text_style); @@ -201,6 +219,10 @@ TEST_F(RenderTest, BoldParagraph) { paragraph->Paint(GetCanvas(), 10.0, 60.0); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } ASSERT_TRUE(Snapshot()); } @@ -257,5 +279,43 @@ TEST_F(RenderTest, LinebreakParagraph) { paragraph->Paint(GetCanvas(), 5.0, 30.0); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } ASSERT_TRUE(Snapshot()); -} \ No newline at end of file +} + +TEST_F(RenderTest, ItalicsParagraph) { + const char* text = "I am Italicized!"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.color = SK_ColorRED; + text_style.font_style = txt::FontStyle::italic; + text_style.font_size = 35; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, + txt::GetFontDir()); + + paragraph->Paint(GetCanvas(), 10.0, 35.0); + + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } + ASSERT_TRUE(Snapshot()); +} + +} // namespace txt From d86d3c526a1e24716b404b85e52278b528935167 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 7 Jun 2017 14:51:09 -0700 Subject: [PATCH 286/364] Add more testing for Paragraph and FontCollection. Change-Id: Idec0077f44225f0af8bbcd6464d226555f79beae --- engine/src/flutter/src/styled_runs.h | 9 ++++++ engine/src/flutter/src/text_style.cc | 28 ++++++++++++++++ engine/src/flutter/src/text_style.h | 2 ++ .../tests/txt/font_collection_unittests.cc | 29 ++++++++++++++++- .../flutter/tests/txt/paragraph_unittests.cc | 32 +++++++++++++++++++ 5 files changed, 99 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index 781e1eb69b..8b757658a4 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -20,6 +20,7 @@ #include #include "lib/txt/src/text_style.h" +#include "third_party/gtest/include/gtest/gtest_prod.h" namespace txt { @@ -54,6 +55,14 @@ class StyledRuns { Run GetRun(size_t index) const; private: + FRIEND_TEST(RenderTest, SimpleParagraph); + FRIEND_TEST(RenderTest, SimpleRedParagraph); + FRIEND_TEST(RenderTest, RainbowParagraph); + FRIEND_TEST(RenderTest, DefaultStyleParagraph); + FRIEND_TEST(RenderTest, BoldParagraph); + FRIEND_TEST(RenderTest, LinebreakParagraph); + FRIEND_TEST(RenderTest, ItalicsParagraph); + struct IndexedRun { size_t style_index = 0; size_t start = 0; diff --git a/engine/src/flutter/src/text_style.cc b/engine/src/flutter/src/text_style.cc index d7d0ab7a2d..bacb9a55fe 100644 --- a/engine/src/flutter/src/text_style.cc +++ b/engine/src/flutter/src/text_style.cc @@ -15,3 +15,31 @@ */ #include "lib/txt/src/text_style.h" +#include "lib/txt/src/font_style.h" +#include "lib/txt/src/font_weight.h" +#include "third_party/skia/include/core/SkColor.h" + +namespace txt { + +bool TextStyle::equals(TextStyle& other) { + if (color != other.color) + return false; + if (font_weight != other.font_weight) + return false; + if (font_style != other.font_style) + return false; + if (fake_bold != other.fake_bold) + return false; + if (font_family != other.font_family) + return false; + if (letter_spacing != other.letter_spacing) + return false; + if (word_spacing != other.word_spacing) + return false; + if (height != other.height) + return false; + + return true; +} + +} // namespace txt diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index 21c122abfe..13b322f2c9 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -40,6 +40,8 @@ class TextStyle { double letter_spacing = 0.0; double word_spacing = 0.0; double height = 1.0; + + bool equals(TextStyle& other); }; } // namespace txt diff --git a/engine/src/flutter/tests/txt/font_collection_unittests.cc b/engine/src/flutter/tests/txt/font_collection_unittests.cc index ab15710e96..4a069a3661 100644 --- a/engine/src/flutter/tests/txt/font_collection_unittests.cc +++ b/engine/src/flutter/tests/txt/font_collection_unittests.cc @@ -69,6 +69,33 @@ TEST(FontCollection, GetFamilyNames) { txt::FontCollection::GetFamilyNames(txt::GetFontDir()); ASSERT_EQ(names.size(), 19ull); + + ASSERT_EQ(names.count("Roboto"), 1ull); + ASSERT_EQ(names.count("Homemade Apple"), 1ull); + + ASSERT_EQ(names.count("KoreanFont Test"), 1ull); + ASSERT_EQ(names.count("JapaneseFont Test"), 1ull); + ASSERT_EQ(names.count("EmojiFont Test"), 1ull); + ASSERT_EQ(names.count("ItalicFont Test"), 1ull); + ASSERT_EQ(names.count("VariationSelector Test"), 1ull); + ASSERT_EQ(names.count("ColorEmojiFont Test"), 1ull); + ASSERT_EQ(names.count("TraditionalChinese Test"), 1ull); + ASSERT_EQ(names.count("Sample Font"), 1ull); + ASSERT_EQ(names.count("MultiAxisFont Test"), 1ull); + ASSERT_EQ(names.count("TextEmojiFont Test"), 1ull); + ASSERT_EQ(names.count("No Cmap Format 14 Subtable Test"), 1ull); + ASSERT_EQ(names.count("ColorTextMixedEmojiFont Test"), 1ull); + ASSERT_EQ(names.count("BoldFont Test"), 1ull); + ASSERT_EQ(names.count("EmptyFont Test"), 1ull); + ASSERT_EQ(names.count("SimplifiedChinese Test"), 1ull); + ASSERT_EQ(names.count("BoldItalicFont Test"), 1ull); + ASSERT_EQ(names.count("RegularFont Test"), 1ull); + + ASSERT_EQ(names.count("Not a real font!"), 0ull); + ASSERT_EQ(names.count(""), 0ull); + ASSERT_EQ(names.count("Helvetica"), 0ull); + ASSERT_EQ(names.count("TimesNewRoman"), 0ull); + ASSERT_EQ(names.count("Arial"), 0ull); } -} // namespace txt \ No newline at end of file +} // namespace txt diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 11b816241b..344418efa2 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -52,6 +52,10 @@ TEST_F(RenderTest, SimpleParagraph) { for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].color(), text_style.color); ASSERT_TRUE(Snapshot()); } @@ -82,6 +86,10 @@ TEST_F(RenderTest, SimpleRedParagraph) { for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].color(), text_style.color); ASSERT_TRUE(Snapshot()); } @@ -158,6 +166,16 @@ TEST_F(RenderTest, RainbowParagraph) { for (size_t i = 0; i < u16_text1.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text1[i]); } + ASSERT_EQ(paragraph->runs_.runs_.size(), 4ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 4ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style1)); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style2)); + ASSERT_TRUE(paragraph->runs_.styles_[2].equals(text_style3)); + ASSERT_TRUE(paragraph->runs_.styles_[3].equals(text_style4)); + ASSERT_EQ(paragraph->records_[0].color(), text_style1.color); + ASSERT_EQ(paragraph->records_[1].color(), text_style2.color); + ASSERT_EQ(paragraph->records_[2].color(), text_style3.color); + ASSERT_EQ(paragraph->records_[3].color(), text_style4.color); ASSERT_TRUE(Snapshot()); } @@ -188,6 +206,8 @@ TEST_F(RenderTest, DefaultStyleParagraph) { for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } + ASSERT_EQ(paragraph->runs_.runs_.size(), 0ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 0ull); ASSERT_TRUE(Snapshot()); } @@ -223,6 +243,10 @@ TEST_F(RenderTest, BoldParagraph) { for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].color(), text_style.color); ASSERT_TRUE(Snapshot()); } @@ -283,6 +307,10 @@ TEST_F(RenderTest, LinebreakParagraph) { for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].color(), text_style.color); ASSERT_TRUE(Snapshot()); } @@ -315,6 +343,10 @@ TEST_F(RenderTest, ItalicsParagraph) { for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].color(), text_style.color); ASSERT_TRUE(Snapshot()); } From cf223546c47bbbe2e63c073f26b5ef222ee2a3d7 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 8 Jun 2017 10:47:39 -0700 Subject: [PATCH 287/364] Add TextStyle properties to better support Flutter API Change-Id: I13174dafa497328c80aada02fe144bd1b3d7f396 --- engine/src/flutter/src/BUILD.gn | 3 ++ engine/src/flutter/src/paragraph.cc | 2 +- engine/src/flutter/src/text_align.h | 2 +- engine/src/flutter/src/text_baseline.h | 29 ++++++++++++++ engine/src/flutter/src/text_decoration.cc | 22 +++++++++++ engine/src/flutter/src/text_decoration.h | 39 +++++++++++++++++++ engine/src/flutter/src/text_style.h | 10 +++-- .../flutter/tests/txt/paragraph_unittests.cc | 1 + 8 files changed, 102 insertions(+), 6 deletions(-) create mode 100644 engine/src/flutter/src/text_baseline.h create mode 100644 engine/src/flutter/src/text_decoration.cc create mode 100644 engine/src/flutter/src/text_decoration.h diff --git a/engine/src/flutter/src/BUILD.gn b/engine/src/flutter/src/BUILD.gn index 2d5792f88a..3ff3e9c6b0 100644 --- a/engine/src/flutter/src/BUILD.gn +++ b/engine/src/flutter/src/BUILD.gn @@ -33,6 +33,9 @@ source_set("src") { "styled_runs.cc", "styled_runs.h", "text_align.h", + "text_baseline.h", + "text_decoration.cc", + "text_decoration.h", "text_style.cc", "text_style.h", ] diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index ce2edaa866..517be88eb6 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -194,7 +194,7 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, x = 0.0f; // TODO(abarth): Use the line height, which is something like the max // font_size for runs in this line times the paragraph's line height. - y += run.style.font_size; + y += run.style.font_size * run.style.height; break_index += 1; } else { x += layout.getAdvance(); diff --git a/engine/src/flutter/src/text_align.h b/engine/src/flutter/src/text_align.h index 91a291ff9f..52922a2f72 100644 --- a/engine/src/flutter/src/text_align.h +++ b/engine/src/flutter/src/text_align.h @@ -23,7 +23,7 @@ enum class TextAlign { left, right, center, - // justify, + justify, }; } // namespace txt diff --git a/engine/src/flutter/src/text_baseline.h b/engine/src/flutter/src/text_baseline.h new file mode 100644 index 0000000000..67f88cac8c --- /dev/null +++ b/engine/src/flutter/src/text_baseline.h @@ -0,0 +1,29 @@ +/* + * Copyright 2017 Google Inc. + * + * 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 LIB_TXT_SRC_TEXT_BASELINE_H_ +#define LIB_TXT_SRC_TEXT_BASELINE_H_ + +namespace txt { + +enum TextBaseline { + kAlphabetic, + kIdeographic, +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_TEXT_BASELINE_H_ diff --git a/engine/src/flutter/src/text_decoration.cc b/engine/src/flutter/src/text_decoration.cc new file mode 100644 index 0000000000..28804c144f --- /dev/null +++ b/engine/src/flutter/src/text_decoration.cc @@ -0,0 +1,22 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 +#include + +#include "lib/txt/src/text_decoration.h" + +namespace txt {} // namespace txt diff --git a/engine/src/flutter/src/text_decoration.h b/engine/src/flutter/src/text_decoration.h new file mode 100644 index 0000000000..8e7b1654a4 --- /dev/null +++ b/engine/src/flutter/src/text_decoration.h @@ -0,0 +1,39 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 LIB_TXT_SRC_TEXT_DECORATION_H_ +#define LIB_TXT_SRC_TEXT_DECORATION_H_ + +namespace txt { + +enum TextDecoration { + kNone = 0x0, + kUnderline = 0x1, + kOverline = 0x2, + kLineThrough = 0x4, +}; + +enum TextDecorationStyle { + kSolid, + kDouble, // "double" is reserved. + kDotted, + kDashed, + kWavy +}; + +} // namespace txt + +#endif // LIB_TXT_SRC_TEXT_DECORATION_H_ \ No newline at end of file diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index 13b322f2c9..23c2043b0a 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -21,6 +21,8 @@ #include "lib/txt/src/font_style.h" #include "lib/txt/src/font_weight.h" +#include "lib/txt/src/text_baseline.h" +#include "lib/txt/src/text_decoration.h" #include "third_party/skia/include/core/SkColor.h" namespace txt { @@ -28,13 +30,13 @@ namespace txt { class TextStyle { public: SkColor color = SK_ColorWHITE; - // TextDecoration decoration, - // SkColor decoration_color; - // TextDecorationStyle decoration_style + TextDecoration decoration = TextDecoration::kNone; + SkColor decoration_color = SK_ColorWHITE; + TextDecorationStyle decoration_style = TextDecorationStyle::kSolid; FontWeight font_weight = FontWeight::w400; FontStyle font_style = FontStyle::normal; bool fake_bold = false; - // TextBaseline text_baseline; + TextBaseline text_baseline = TextBaseline::kAlphabetic; std::string font_family = ""; double font_size = 14.0; double letter_spacing = 0.0; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 344418efa2..e3901f02f0 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -291,6 +291,7 @@ TEST_F(RenderTest, LinebreakParagraph) { // Letter spacing not yet implemented text_style.letter_spacing = 10; text_style.color = SK_ColorBLACK; + text_style.height = 1.15; builder.PushStyle(text_style); builder.AddText(u16_text); From ef3b6d0b6e1ce26c65b164329fb8b060864b166b Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 8 Jun 2017 18:27:29 -0700 Subject: [PATCH 288/364] Restructure Building and new features for Flutter support. Change-Id: Ia0454fabcd89806cfb0e07148696e9ae66c351b6 --- engine/src/flutter/BUILD.gn | 51 +++++++++++++++++---- engine/src/flutter/examples/BUILD.gn | 2 +- engine/src/flutter/src/BUILD.gn | 33 +------------ engine/src/flutter/src/paragraph.cc | 26 +++++++++-- engine/src/flutter/src/paragraph.h | 12 +++++ engine/src/flutter/src/paragraph_builder.cc | 5 +- engine/src/flutter/src/paragraph_builder.h | 1 + engine/src/flutter/tests/txt/BUILD.gn | 2 +- 8 files changed, 85 insertions(+), 47 deletions(-) diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn index 34c9c145fa..8cb56f42a9 100644 --- a/engine/src/flutter/BUILD.gn +++ b/engine/src/flutter/BUILD.gn @@ -12,13 +12,48 @@ # See the License for the specific language governing permissions and # limitations under the License. -group("txt") { - testonly = true - - deps = [ - "examples:txt_example($host_toolchain)", - "src", - "tests/txt($host_toolchain)", # txt_unittests - "tests/unittest($host_toolchain)", # minikin_unittest +config("txt_config") { + include_dirs = [ + "//lib/txt/include", + "//third_party/harfbuzz/src", + "//lib/txt/shims", ] } + +static_library("txt") { + sources = [ + "src/font_collection.cc", + "src/font_collection.h", + "src/font_skia.cc", + "src/font_skia.h", + "src/font_style.h", + "src/font_weight.h", + "src/paint_record.cc", + "src/paint_record.h", + "src/paragraph.cc", + "src/paragraph.h", + "src/paragraph_builder.cc", + "src/paragraph_builder.h", + "src/paragraph_constraints.cc", + "src/paragraph_constraints.h", + "src/paragraph_style.cc", + "src/paragraph_style.h", + "src/styled_runs.cc", + "src/styled_runs.h", + "src/text_align.h", + "src/text_baseline.h", + "src/text_decoration.cc", + "src/text_decoration.h", + "src/text_style.cc", + "src/text_style.h", + ] + + public_configs = [ ":txt_config" ] + + deps = [ + "//lib/txt/libs/minikin", + "//third_party/skia", + "//third_party/gtest", + ] + +} diff --git a/engine/src/flutter/examples/BUILD.gn b/engine/src/flutter/examples/BUILD.gn index 20780a3d65..b0452feb4c 100644 --- a/engine/src/flutter/examples/BUILD.gn +++ b/engine/src/flutter/examples/BUILD.gn @@ -21,7 +21,7 @@ executable("txt_example") { "//dart/runtime:libdart_jit", "//flutter/fml", "//lib/txt/libs/minikin", - "//lib/txt/src", + "//lib/txt", "//third_party/icu:icuuc", "//third_party/skia", ] diff --git a/engine/src/flutter/src/BUILD.gn b/engine/src/flutter/src/BUILD.gn index 3ff3e9c6b0..024820767e 100644 --- a/engine/src/flutter/src/BUILD.gn +++ b/engine/src/flutter/src/BUILD.gn @@ -13,36 +13,5 @@ # limitations under the License. source_set("src") { - sources = [ - "font_collection.cc", - "font_collection.h", - "font_skia.cc", - "font_skia.h", - "font_style.h", - "font_weight.h", - "paint_record.cc", - "paint_record.h", - "paragraph.cc", - "paragraph.h", - "paragraph_builder.cc", - "paragraph_builder.h", - "paragraph_constraints.cc", - "paragraph_constraints.h", - "paragraph_style.cc", - "paragraph_style.h", - "styled_runs.cc", - "styled_runs.h", - "text_align.h", - "text_baseline.h", - "text_decoration.cc", - "text_decoration.h", - "text_style.cc", - "text_style.h", - ] - - deps = [ - "//lib/txt/libs/minikin", - "//third_party/skia", - "//third_party/gtest", - ] + } diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 517be88eb6..0912565557 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -22,7 +22,7 @@ #include #include -#include +#include "minikin/LineBreaker.h" #include "lib/ftl/logging.h" @@ -145,7 +145,6 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, minikin::Layout layout; SkScalar x = 0.0f; - SkScalar y = 0.0f; size_t break_index = 0; for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { auto run = runs_.GetRun(run_index); @@ -188,13 +187,14 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the // color stayed the same. records_.push_back( - PaintRecord(run.style.color, SkPoint::Make(x, y), builder.make())); + PaintRecord(run.style.color, SkPoint::Make(x, y_), builder.make())); if (layout_end == next_break) { x = 0.0f; // TODO(abarth): Use the line height, which is something like the max // font_size for runs in this line times the paragraph's line height. - y += run.style.font_size * run.style.height; + y_ += run.style.font_size * run.style.height; + lines_++; break_index += 1; } else { x += layout.getAdvance(); @@ -205,6 +205,18 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, } } +const ParagraphStyle& Paragraph::GetParagraphStyle() const { + return paragraph_style_; +} + +double Paragraph::GetHeight() const { + return y_; +} + +void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { + paragraph_style_ = style; +} + void Paragraph::Paint(SkCanvas* canvas, double x, double y) { SkPaint paint; for (const auto& record : records_) { @@ -214,4 +226,10 @@ void Paragraph::Paint(SkCanvas* canvas, double x, double y) { } } +bool Paragraph::DidExceedMaxLines() const { + if (lines_ > paragraph_style_.max_lines) + return true; + return false; +} + } // namespace txt diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 0ec43df129..c515e9839d 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -22,6 +22,7 @@ #include "lib/ftl/macros.h" #include "lib/txt/src/paint_record.h" #include "lib/txt/src/paragraph_constraints.h" +#include "lib/txt/src/paragraph_style.h" #include "lib/txt/src/styled_runs.h" #include "minikin/LineBreaker.h" #include "third_party/gtest/include/gtest/gtest_prod.h" @@ -42,6 +43,12 @@ class Paragraph { void Paint(SkCanvas* canvas, double x, double y); + const ParagraphStyle& GetParagraphStyle() const; + + double GetHeight() const; + + bool DidExceedMaxLines() const; + private: friend class ParagraphBuilder; FRIEND_TEST(RenderTest, SimpleParagraph); @@ -56,9 +63,14 @@ class Paragraph { StyledRuns runs_; minikin::LineBreaker breaker_; std::vector records_; + ParagraphStyle paragraph_style_; + int lines_ = 1; // Number of lines after Layout(). + SkScalar y_ = 0.0f; // Height of the paragraph after Layout(). void SetText(std::vector text, StyledRuns runs); + void SetParagraphStyle(const ParagraphStyle& style); + void AddRunsToLineBreaker(const std::string& rootdir = ""); FTL_DISALLOW_COPY_AND_ASSIGN(Paragraph); diff --git a/engine/src/flutter/src/paragraph_builder.cc b/engine/src/flutter/src/paragraph_builder.cc index 4976b86126..116936e184 100644 --- a/engine/src/flutter/src/paragraph_builder.cc +++ b/engine/src/flutter/src/paragraph_builder.cc @@ -15,11 +15,13 @@ */ #include "lib/txt/src/paragraph_builder.h" +#include "lib/txt/src/paragraph_style.h" #include "third_party/icu/source/common/unicode/unistr.h" namespace txt { -ParagraphBuilder::ParagraphBuilder(ParagraphStyle style) {} +ParagraphBuilder::ParagraphBuilder(ParagraphStyle style) + : paragraph_style_(style) {} ParagraphBuilder::~ParagraphBuilder() = default; @@ -65,6 +67,7 @@ std::unique_ptr ParagraphBuilder::Build() { runs_.EndRunIfNeeded(text_.size()); std::unique_ptr paragraph = std::make_unique(); paragraph->SetText(std::move(text_), std::move(runs_)); + paragraph->SetParagraphStyle(paragraph_style_); return paragraph; } diff --git a/engine/src/flutter/src/paragraph_builder.h b/engine/src/flutter/src/paragraph_builder.h index 71598af0b5..41bd6a02a2 100644 --- a/engine/src/flutter/src/paragraph_builder.h +++ b/engine/src/flutter/src/paragraph_builder.h @@ -50,6 +50,7 @@ class ParagraphBuilder { std::vector text_; std::vector style_stack_; StyledRuns runs_; + ParagraphStyle paragraph_style_; FTL_DISALLOW_COPY_AND_ASSIGN(ParagraphBuilder); }; diff --git a/engine/src/flutter/tests/txt/BUILD.gn b/engine/src/flutter/tests/txt/BUILD.gn index 3fb1019628..dad5c408f3 100644 --- a/engine/src/flutter/tests/txt/BUILD.gn +++ b/engine/src/flutter/tests/txt/BUILD.gn @@ -35,7 +35,7 @@ executable("txt") { "//dart/runtime:libdart_jit", # Logging "//flutter/fml", "//lib/txt/shims", - "//lib/txt/src", + "//lib/txt", "//third_party/gtest", "//third_party/harfbuzz", "//third_party/skia", From 56e4048b17c66510a1c72bece0ebeab89f5ae187 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 9 Jun 2017 12:20:35 -0700 Subject: [PATCH 289/364] Fix Minikin to allow proper compilation in Hyphenator. Change-Id: I2aeb3d5e494ce941dcc8baec2f0bacd15c163094 --- engine/src/flutter/include/minikin/Hyphenator.h | 1 + 1 file changed, 1 insertion(+) diff --git a/engine/src/flutter/include/minikin/Hyphenator.h b/engine/src/flutter/include/minikin/Hyphenator.h index c2d9d3b63a..937fc646f5 100644 --- a/engine/src/flutter/include/minikin/Hyphenator.h +++ b/engine/src/flutter/include/minikin/Hyphenator.h @@ -25,6 +25,7 @@ #include "unicode/locid.h" #include #include +#include #ifndef MINIKIN_HYPHENATOR_H #define MINIKIN_HYPHENATOR_H From 94900efe1d17760bfd1e77e90c7108f7c3baf1f8 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 9 Jun 2017 17:48:57 -0700 Subject: [PATCH 290/364] Now supporting initial integration with Flutter. Change-Id: Id71461bd96e08eae0e24ab35a040874d960af8e0 --- engine/src/flutter/BUILD.gn | 7 ++-- engine/src/flutter/src/font_collection.cc | 36 +++++++++++++-------- engine/src/flutter/src/font_collection.h | 16 +++++---- engine/src/flutter/src/paragraph.cc | 28 ++++++++++++---- engine/src/flutter/src/paragraph.h | 11 +++++-- engine/src/flutter/src/paragraph_builder.cc | 7 ++++ engine/src/flutter/src/paragraph_builder.h | 4 +++ engine/src/flutter/src/paragraph_style.h | 6 +++- 8 files changed, 85 insertions(+), 30 deletions(-) diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn index 8cb56f42a9..d5e1d7596e 100644 --- a/engine/src/flutter/BUILD.gn +++ b/engine/src/flutter/BUILD.gn @@ -21,6 +21,10 @@ config("txt_config") { } static_library("txt") { + if (current_toolchain == host_toolchain) { + defines = [ "DIRECTORY_FONT_MANAGER_AVAILABLE" ] + } + sources = [ "src/font_collection.cc", "src/font_collection.h", @@ -52,8 +56,7 @@ static_library("txt") { deps = [ "//lib/txt/libs/minikin", - "//third_party/skia", "//third_party/gtest", + "//third_party/skia", ] - } diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index da24410388..e7b55875bd 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -35,36 +35,46 @@ FontCollection& FontCollection::GetDefaultFontCollection() { return *collection; } -FontCollection::FontCollection() = default; +FontCollection::FontCollection() { +#ifdef DIRECTORY_FONT_MANAGER_AVAILABLE + skia_font_manager_ = dir.length() != 0 + ? SkFontMgr_New_Custom_Directory(dir.c_str()) + : SkFontMgr::RefDefault(); +#else + skia_font_manager_ = SkFontMgr::RefDefault(); +#endif +} FontCollection::~FontCollection() = default; std::set FontCollection::GetFamilyNames(const std::string& dir) { - auto skia_font_manager = dir.length() != 0 - ? SkFontMgr_New_Custom_Directory(dir.c_str()) - : SkFontMgr::RefDefault(); std::set names; SkString str; - for (int i = 0; i < skia_font_manager->countFamilies(); i++) { - skia_font_manager->getFamilyName(i, &str); + for (int i = 0; i < skia_font_manager_->countFamilies(); i++) { + skia_font_manager_->getFamilyName(i, &str); names.insert(std::string{str.writable_str()}); } return names; } const std::string FontCollection::ProcessFamilyName(const std::string& family) { +#ifdef DIRECTORY_FONT_MANAGER_AVAILABLE return family.length() == 0 ? DEFAULT_FAMILY_NAME : family; +#else + if (family.length() == 0) { + return *GetFamilyNames().begin(); + } else if (GetFamilyNames().count(family) > 0) { // Ensure family exists. + return family; + } else { + return *GetFamilyNames().begin(); // First family available. + } +#endif } std::shared_ptr FontCollection::GetMinikinFontCollectionForFamily(const std::string& family, const std::string& dir) { - // Get the Skia font manager. - auto skia_font_manager = dir.length() != 0 - ? SkFontMgr_New_Custom_Directory(dir.c_str()) - : SkFontMgr::RefDefault(); - - FTL_DCHECK(skia_font_manager != nullptr); + FTL_DCHECK(skia_font_manager_ != nullptr); // Ask Skia to resolve a font style set for a font family name. // FIXME(chinmaygarde): The name "Coolvetica" is hardcoded because CoreText @@ -72,7 +82,7 @@ FontCollection::GetMinikinFontCollectionForFamily(const std::string& family, // SkFontMgr explicitly says passing in nullptr gives the default font. auto font_style_set = - skia_font_manager->matchFamily(ProcessFamilyName(family).c_str()); + skia_font_manager_->matchFamily(ProcessFamilyName(family).c_str()); FTL_DCHECK(font_style_set != nullptr); std::vector minikin_fonts; diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index 43bdbec16f..531ef23e48 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -28,6 +28,8 @@ #include "minikin/FontCollection.h" #include "minikin/FontFamily.h" #include "third_party/gtest/include/gtest/gtest_prod.h" +#include "third_party/skia/include/core/SkRefCnt.h" +#include "third_party/skia/include/ports/SkFontMgr.h" namespace txt { @@ -35,18 +37,16 @@ class FontCollection { public: static FontCollection& GetDefaultFontCollection(); - FontCollection(); - - ~FontCollection(); - std::shared_ptr GetMinikinFontCollectionForFamily( const std::string& family, const std::string& dir = ""); - // Provides a vector of all available family names. - static std::set GetFamilyNames(const std::string& dir = ""); + // Provides a set of all available family names. + std::set GetFamilyNames(const std::string& dir = ""); private: + sk_sp skia_font_manager_; + FRIEND_TEST(FontCollection, HasDefaultRegistrations); FRIEND_TEST(FontCollection, GetMinikinFontCollections); FRIEND_TEST(FontCollection, GetFamilyNames); @@ -57,6 +57,10 @@ class FontCollection { return DEFAULT_FAMILY_NAME; }; + FontCollection(); + + ~FontCollection(); + // TODO(chinmaygarde): Caches go here. FTL_DISALLOW_COPY_AND_ASSIGN(FontCollection); }; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 0912565557..fd4ed256c3 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -90,6 +90,7 @@ void GetFontAndMinikinPaint(const TextStyle& style, *font = minikin::FontStyle(GetWeight(style), GetItalic(style)); paint->size = style.font_size; paint->letterSpacing = style.letter_spacing; + paint->wordSpacing = style.word_spacing; // Likely not working yet. // TODO(abarth): word_spacing. } @@ -128,8 +129,11 @@ void Paragraph::AddRunsToLineBreaker(const std::string& rootdir) { } void Paragraph::Layout(const ParagraphConstraints& constraints, - const std::string& rootdir) { + const std::string& rootdir, + const double x_offset, + const double y_offset) { breaker_.setLineWidths(0.0f, 0, constraints.width()); + width_ = constraints.width(); AddRunsToLineBreaker(rootdir); size_t breaks_count = breaker_.computeBreaks(); const int* breaks = breaker_.getBreaks(); @@ -144,7 +148,8 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, SkTextBlobBuilder builder; minikin::Layout layout; - SkScalar x = 0.0f; + SkScalar x = x_offset; + y_ = y_offset; size_t break_index = 0; for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { auto run = runs_.GetRun(run_index); @@ -155,7 +160,7 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, GetPaint(run.style, &paint); size_t layout_start = run.start; - while (layout_start < run.end) { + while (layout_start < run.end && !DidExceedMaxLines()) { const size_t next_break = (break_index > breaks_count - 1) ? std::numeric_limits::max() : breaks[break_index]; @@ -194,8 +199,8 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, // TODO(abarth): Use the line height, which is something like the max // font_size for runs in this line times the paragraph's line height. y_ += run.style.font_size * run.style.height; - lines_++; break_index += 1; + lines_++; } else { x += layout.getAdvance(); } @@ -209,8 +214,17 @@ const ParagraphStyle& Paragraph::GetParagraphStyle() const { return paragraph_style_; } +double Paragraph::GetAlphabeticBaseline() const { + return FLT_MAX; +} + +double Paragraph::GetIdeographicBaseline() const { + return FLT_MAX; +} + double Paragraph::GetHeight() const { - return y_; + return paragraph_style_.font_size * paragraph_style_.line_height * + paragraph_style_.max_lines; } void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { @@ -227,7 +241,9 @@ void Paragraph::Paint(SkCanvas* canvas, double x, double y) { } bool Paragraph::DidExceedMaxLines() const { - if (lines_ > paragraph_style_.max_lines) + if (y_ / (paragraph_style_.font_size * paragraph_style_.line_height) > + paragraph_style_.max_lines) + // if (lines_ > paragraph_style_.max_lines) return true; return false; } diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index c515e9839d..513d1fb57f 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -39,7 +39,9 @@ class Paragraph { ~Paragraph(); void Layout(const ParagraphConstraints& constraints, - const std::string& rootdir = ""); + const std::string& rootdir = "", + const double x_offset = 0.0, + const double y_offset = 0.0); void Paint(SkCanvas* canvas, double x, double y); @@ -47,6 +49,10 @@ class Paragraph { double GetHeight() const; + double GetAlphabeticBaseline() const; + + double GetIdeographicBaseline() const; + bool DidExceedMaxLines() const; private: @@ -64,8 +70,9 @@ class Paragraph { minikin::LineBreaker breaker_; std::vector records_; ParagraphStyle paragraph_style_; - int lines_ = 1; // Number of lines after Layout(). SkScalar y_ = 0.0f; // Height of the paragraph after Layout(). + double width_ = 0.0f; + int lines_ = 0; void SetText(std::vector text, StyledRuns runs); diff --git a/engine/src/flutter/src/paragraph_builder.cc b/engine/src/flutter/src/paragraph_builder.cc index 116936e184..3d980eae3a 100644 --- a/engine/src/flutter/src/paragraph_builder.cc +++ b/engine/src/flutter/src/paragraph_builder.cc @@ -13,6 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include "lib/ftl/logging.h" #include "lib/txt/src/paragraph_builder.h" #include "lib/txt/src/paragraph_style.h" @@ -23,6 +24,12 @@ namespace txt { ParagraphBuilder::ParagraphBuilder(ParagraphStyle style) : paragraph_style_(style) {} +ParagraphBuilder::ParagraphBuilder() {} + +void ParagraphBuilder::SetParagraphStyle(const ParagraphStyle& style) { + paragraph_style_ = style; +} + ParagraphBuilder::~ParagraphBuilder() = default; void ParagraphBuilder::PushStyle(const TextStyle& style) { diff --git a/engine/src/flutter/src/paragraph_builder.h b/engine/src/flutter/src/paragraph_builder.h index 41bd6a02a2..5df84ca72a 100644 --- a/engine/src/flutter/src/paragraph_builder.h +++ b/engine/src/flutter/src/paragraph_builder.h @@ -32,6 +32,8 @@ class ParagraphBuilder { public: explicit ParagraphBuilder(ParagraphStyle style); + ParagraphBuilder(); + ~ParagraphBuilder(); void PushStyle(const TextStyle& style); @@ -44,6 +46,8 @@ class ParagraphBuilder { void AddText(const char* text); + void SetParagraphStyle(const ParagraphStyle& style); + std::unique_ptr Build(); private: diff --git a/engine/src/flutter/src/paragraph_style.h b/engine/src/flutter/src/paragraph_style.h index eec58159da..e1730287a6 100644 --- a/engine/src/flutter/src/paragraph_style.h +++ b/engine/src/flutter/src/paragraph_style.h @@ -28,7 +28,11 @@ namespace txt { class ParagraphStyle { public: TextAlign text_align = TextAlign::left; - int max_lines = 0; + FontWeight font_weight = FontWeight::w400; + FontStyle font_style = FontStyle::normal; + std::string font_family = ""; + double font_size = 14; + int max_lines = 1; double line_height = 1.0; std::string ellipsis; }; From 482348524544b0c7ebfe856151e233d3d2cb5092 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 15 Jun 2017 12:13:14 -0700 Subject: [PATCH 291/364] Restructure Building of tests and FontCollection Change-Id: Ifd7d9cd505b119684ccb42c998204d41ee7ef93e --- engine/src/flutter/src/font_collection.cc | 15 +++++--- engine/src/flutter/src/font_collection.h | 9 +++-- engine/src/flutter/src/paragraph.cc | 8 ++-- engine/src/flutter/tests/BUILD.gn | 22 +++++++++++ .../tests/txt/font_collection_unittests.cc | 37 +++++++++---------- 5 files changed, 58 insertions(+), 33 deletions(-) create mode 100644 engine/src/flutter/tests/BUILD.gn diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index e7b55875bd..05b5d6b66f 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -28,14 +28,18 @@ namespace txt { -FontCollection& FontCollection::GetDefaultFontCollection() { +FontCollection& FontCollection::GetFontCollection(std::string dir) { static FontCollection* collection = nullptr; static std::once_flag once; - std::call_once(once, []() { collection = new FontCollection(); }); + std::call_once(once, [dir]() { collection = new FontCollection(dir); }); return *collection; } -FontCollection::FontCollection() { +FontCollection& FontCollection::GetDefaultFontCollection() { + return GetFontCollection(""); +} + +FontCollection::FontCollection(std::string dir) { #ifdef DIRECTORY_FONT_MANAGER_AVAILABLE skia_font_manager_ = dir.length() != 0 ? SkFontMgr_New_Custom_Directory(dir.c_str()) @@ -47,7 +51,7 @@ FontCollection::FontCollection() { FontCollection::~FontCollection() = default; -std::set FontCollection::GetFamilyNames(const std::string& dir) { +std::set FontCollection::GetFamilyNames() { std::set names; SkString str; for (int i = 0; i < skia_font_manager_->countFamilies(); i++) { @@ -72,8 +76,7 @@ const std::string FontCollection::ProcessFamilyName(const std::string& family) { } std::shared_ptr -FontCollection::GetMinikinFontCollectionForFamily(const std::string& family, - const std::string& dir) { +FontCollection::GetMinikinFontCollectionForFamily(const std::string& family) { FTL_DCHECK(skia_font_manager_ != nullptr); // Ask Skia to resolve a font style set for a font family name. diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index 531ef23e48..836e22e8ff 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -37,12 +37,13 @@ class FontCollection { public: static FontCollection& GetDefaultFontCollection(); + static FontCollection& GetFontCollection(std::string dir = ""); + std::shared_ptr GetMinikinFontCollectionForFamily( - const std::string& family, - const std::string& dir = ""); + const std::string& family); // Provides a set of all available family names. - std::set GetFamilyNames(const std::string& dir = ""); + std::set GetFamilyNames(); private: sk_sp skia_font_manager_; @@ -57,7 +58,7 @@ class FontCollection { return DEFAULT_FAMILY_NAME; }; - FontCollection(); + FontCollection(std::string dir = ""); ~FontCollection(); diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index fd4ed256c3..8f45e9f6b6 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -121,8 +121,8 @@ void Paragraph::AddRunsToLineBreaker(const std::string& rootdir) { for (size_t i = 0; i < runs_.size(); ++i) { auto run = runs_.GetRun(i); auto collection = - FontCollection::GetDefaultFontCollection() - .GetMinikinFontCollectionForFamily(run.style.font_family, rootdir); + FontCollection::GetFontCollection(rootdir) + .GetMinikinFontCollectionForFamily(run.style.font_family); GetFontAndMinikinPaint(run.style, &font, &paint); breaker_.addStyleRun(&paint, collection, font, run.start, run.end, false); } @@ -154,8 +154,8 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { auto run = runs_.GetRun(run_index); auto collection = - FontCollection::GetDefaultFontCollection() - .GetMinikinFontCollectionForFamily(run.style.font_family, rootdir); + FontCollection::GetFontCollection(rootdir) + .GetMinikinFontCollectionForFamily(run.style.font_family); GetFontAndMinikinPaint(run.style, &font, &minikin_paint); GetPaint(run.style, &paint); diff --git a/engine/src/flutter/tests/BUILD.gn b/engine/src/flutter/tests/BUILD.gn new file mode 100644 index 0000000000..98defad50b --- /dev/null +++ b/engine/src/flutter/tests/BUILD.gn @@ -0,0 +1,22 @@ +# Copyright 2017 Google, Inc. +# +# 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. + +group("tests") { + testonly = true + + deps = [ + "txt", + "unittest", + ] +} \ No newline at end of file diff --git a/engine/src/flutter/tests/txt/font_collection_unittests.cc b/engine/src/flutter/tests/txt/font_collection_unittests.cc index 4a069a3661..f501649a1c 100644 --- a/engine/src/flutter/tests/txt/font_collection_unittests.cc +++ b/engine/src/flutter/tests/txt/font_collection_unittests.cc @@ -25,33 +25,31 @@ namespace txt { TEST(FontCollection, HasDefaultRegistrations) { std::string defaultFamilyName = txt::FontCollection::GetDefaultFamilyName(); - auto collection = - txt::FontCollection::GetDefaultFontCollection() - .GetMinikinFontCollectionForFamily("", txt::GetFontDir()); - ASSERT_EQ( - defaultFamilyName, - txt::FontCollection::GetDefaultFontCollection().ProcessFamilyName("")); + auto collection = txt::FontCollection::GetFontCollection(txt::GetFontDir()) + .GetMinikinFontCollectionForFamily(""); + ASSERT_EQ(defaultFamilyName, + txt::FontCollection::GetFontCollection(txt::GetFontDir()) + .ProcessFamilyName("")); ASSERT_NE(defaultFamilyName, - txt::FontCollection::GetDefaultFontCollection().ProcessFamilyName( - "NotARealFont!")); + txt::FontCollection::GetFontCollection(txt::GetFontDir()) + .ProcessFamilyName("NotARealFont!")); ASSERT_EQ("NotARealFont!", - txt::FontCollection::GetDefaultFontCollection().ProcessFamilyName( - "NotARealFont!")); + txt::FontCollection::GetFontCollection(txt::GetFontDir()) + .ProcessFamilyName("NotARealFont!")); ASSERT_NE(collection.get(), nullptr); } TEST(FontCollection, GetMinikinFontCollections) { std::string defaultFamilyName = txt::FontCollection::GetDefaultFamilyName(); - auto collectionDef = - txt::FontCollection::GetDefaultFontCollection() - .GetMinikinFontCollectionForFamily("", txt::GetFontDir()); + auto collectionDef = txt::FontCollection::GetFontCollection(txt::GetFontDir()) + .GetMinikinFontCollectionForFamily(""); auto collectionRoboto = - txt::FontCollection::GetDefaultFontCollection() - .GetMinikinFontCollectionForFamily("Roboto", txt::GetFontDir()); - auto collectionHomemadeApple = txt::FontCollection::GetDefaultFontCollection() - .GetMinikinFontCollectionForFamily( - "Homemade Apple", txt::GetFontDir()); + txt::FontCollection::GetFontCollection(txt::GetFontDir()) + .GetMinikinFontCollectionForFamily("Roboto"); + auto collectionHomemadeApple = + txt::FontCollection::GetFontCollection(txt::GetFontDir()) + .GetMinikinFontCollectionForFamily("Homemade Apple"); for (size_t base = 0; base < 50; base++) { for (size_t variation = 0; variation < 50; variation++) { ASSERT_EQ(collectionDef->hasVariationSelector(base, variation), @@ -66,7 +64,8 @@ TEST(FontCollection, GetMinikinFontCollections) { TEST(FontCollection, GetFamilyNames) { std::set names = - txt::FontCollection::GetFamilyNames(txt::GetFontDir()); + txt::FontCollection::GetFontCollection(txt::GetFontDir()) + .GetFamilyNames(); ASSERT_EQ(names.size(), 19ull); From 1493b676ffdd5cd6731dfd7927b7591b24163306 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 15 Jun 2017 18:13:45 -0700 Subject: [PATCH 292/364] Add Getters for intrinsic widths and implement MaxInstrinsicWidth. Update tests. Change-Id: I210fac9d47f55f8317ca77bca64cfcfd438a246a --- engine/src/flutter/src/paragraph.cc | 13 +++++++++++++ engine/src/flutter/src/paragraph.h | 6 ++++++ engine/src/flutter/tests/txt/paragraph_unittests.cc | 5 ++++- 3 files changed, 23 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 8f45e9f6b6..e548f9d10b 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -147,6 +147,10 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, SkTextBlobBuilder builder; + // Reset member variables so Layout still works when called more than once + max_intrinsic_width_ = 0.0f; + lines_ = 0; + minikin::Layout layout; SkScalar x = x_offset; y_ = y_offset; @@ -187,6 +191,7 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, buffer.pos[pos_index + 1] = layout.getY(glyph_index); } blob_start += blob_length; + max_intrinsic_width_ += layout.getX(blob_start - 1); } // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the @@ -222,6 +227,14 @@ double Paragraph::GetIdeographicBaseline() const { return FLT_MAX; } +double Paragraph::GetMaxIntrinsicWidth() const { + return max_intrinsic_width_; +} + +double Paragraph::GetMinIntrinsicWidth() const { + return min_intrinsic_width_; +} + double Paragraph::GetHeight() const { return paragraph_style_.font_size * paragraph_style_.line_height * paragraph_style_.max_lines; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 513d1fb57f..ca05810209 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -53,6 +53,10 @@ class Paragraph { double GetIdeographicBaseline() const; + double GetMaxIntrinsicWidth() const; + + double GetMinIntrinsicWidth() const; + bool DidExceedMaxLines() const; private: @@ -73,6 +77,8 @@ class Paragraph { SkScalar y_ = 0.0f; // Height of the paragraph after Layout(). double width_ = 0.0f; int lines_ = 0; + double max_intrinsic_width_ = 0.0f; + double min_intrinsic_width_ = FLT_MAX; void SetText(std::vector text, StyledRuns runs); diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index e3901f02f0..88071b13bd 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -110,7 +110,9 @@ TEST_F(RenderTest, RainbowParagraph) { auto icu_text4 = icu::UnicodeString::fromUTF8(text4); std::u16string u16_text4(icu_text4.getBuffer(), icu_text4.getBuffer() + icu_text4.length()); - const char* text5 = "ContinueLastStyle"; + const char* text5 = + "Continue Last Style With lots of words to check if it overlaps properly " + "or not"; auto icu_text5 = icu::UnicodeString::fromUTF8(text5); std::u16string u16_text5(icu_text5.getBuffer(), icu_text5.getBuffer() + icu_text5.length()); @@ -284,6 +286,7 @@ TEST_F(RenderTest, LinebreakParagraph) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 1000; txt::ParagraphBuilder builder(paragraph_style); txt::TextStyle text_style; From 6baa479ed08e93fb4f0cf916ca6068575719fe1c Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 16 Jun 2017 16:32:50 -0700 Subject: [PATCH 293/364] Respect letter spacing and word spacing. Remove ParagraphConstraint. Change-Id: Ie833eab67b50be40b7ea38f9c82577cb46e0e1a7 --- engine/src/flutter/BUILD.gn | 2 - engine/src/flutter/examples/main.cc | 2 +- engine/src/flutter/src/paragraph.cc | 46 +++++++++++++++---- engine/src/flutter/src/paragraph.h | 9 ++-- .../src/flutter/src/paragraph_constraints.cc | 23 ---------- .../src/flutter/src/paragraph_constraints.h | 38 --------------- .../flutter/tests/txt/paragraph_unittests.cc | 27 ++++------- 7 files changed, 52 insertions(+), 95 deletions(-) delete mode 100644 engine/src/flutter/src/paragraph_constraints.cc delete mode 100644 engine/src/flutter/src/paragraph_constraints.h diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn index d5e1d7596e..b47c5a20c8 100644 --- a/engine/src/flutter/BUILD.gn +++ b/engine/src/flutter/BUILD.gn @@ -38,8 +38,6 @@ static_library("txt") { "src/paragraph.h", "src/paragraph_builder.cc", "src/paragraph_builder.h", - "src/paragraph_constraints.cc", - "src/paragraph_constraints.h", "src/paragraph_style.cc", "src/paragraph_style.h", "src/styled_runs.cc", diff --git a/engine/src/flutter/examples/main.cc b/engine/src/flutter/examples/main.cc index 3137207c38..a4b52da6cb 100644 --- a/engine/src/flutter/examples/main.cc +++ b/engine/src/flutter/examples/main.cc @@ -52,7 +52,7 @@ int runTest() { int width = 800; int height = 600; - paragraph->Layout(ParagraphConstraints(width)); + paragraph->Layout(width); SkAutoGraphics ag; SkBitmap bitmap; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index e548f9d10b..26e8c3b96a 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -128,12 +128,12 @@ void Paragraph::AddRunsToLineBreaker(const std::string& rootdir) { } } -void Paragraph::Layout(const ParagraphConstraints& constraints, +void Paragraph::Layout(double width, const std::string& rootdir, const double x_offset, const double y_offset) { - breaker_.setLineWidths(0.0f, 0, constraints.width()); - width_ = constraints.width(); + breaker_.setLineWidths(0.0f, 0, width); + width_ = width; AddRunsToLineBreaker(rootdir); size_t breaks_count = breaker_.computeBreaks(); const int* breaks = breaker_.getBreaks(); @@ -149,12 +149,14 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, // Reset member variables so Layout still works when called more than once max_intrinsic_width_ = 0.0f; - lines_ = 0; + lines_ = 1; minikin::Layout layout; SkScalar x = x_offset; y_ = y_offset; size_t break_index = 0; + double letter_spacing_offset = 0.0f; + double word_spacing_offset = 0.0f; for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { auto run = runs_.GetRun(run_index); auto collection = @@ -163,8 +165,13 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, GetFontAndMinikinPaint(run.style, &font, &minikin_paint); GetPaint(run.style, &paint); + // Subtract inital offset to avoid big gap at start of run. + letter_spacing_offset -= run.style.letter_spacing; + size_t layout_start = run.start; - while (layout_start < run.end && !DidExceedMaxLines()) { + + while (layout_start < run.end && + GetLineCount() <= paragraph_style_.max_lines) { const size_t next_break = (break_index > breaks_count - 1) ? std::numeric_limits::max() : breaks[break_index]; @@ -187,11 +194,20 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, const size_t glyph_index = blob_start + blob_index; buffer.glyphs[blob_index] = layout.getGlyphId(glyph_index); const size_t pos_index = 2 * blob_index; - buffer.pos[pos_index] = layout.getX(glyph_index); + letter_spacing_offset += run.style.letter_spacing; + buffer.pos[pos_index] = layout.getX(glyph_index) + + letter_spacing_offset + word_spacing_offset; buffer.pos[pos_index + 1] = layout.getY(glyph_index); } blob_start += blob_length; - max_intrinsic_width_ += layout.getX(blob_start - 1); + + // Subtract letter offset to avoid big gap at end of run. + letter_spacing_offset -= run.style.letter_spacing; + + word_spacing_offset += run.style.word_spacing; + + max_intrinsic_width_ += + layout.getX(blob_start - 1) + letter_spacing_offset; } // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the @@ -201,11 +217,15 @@ void Paragraph::Layout(const ParagraphConstraints& constraints, if (layout_end == next_break) { x = 0.0f; + letter_spacing_offset = 0.0f; + word_spacing_offset = 0.0f; // TODO(abarth): Use the line height, which is something like the max // font_size for runs in this line times the paragraph's line height. y_ += run.style.font_size * run.style.height; break_index += 1; lines_++; + if (lines_ > paragraph_style_.max_lines) + lines_--; } else { x += layout.getAdvance(); } @@ -220,10 +240,12 @@ const ParagraphStyle& Paragraph::GetParagraphStyle() const { } double Paragraph::GetAlphabeticBaseline() const { + // TODO(garyq): Implement. return FLT_MAX; } double Paragraph::GetIdeographicBaseline() const { + // TODO(garyq): Implement. return FLT_MAX; } @@ -232,6 +254,7 @@ double Paragraph::GetMaxIntrinsicWidth() const { } double Paragraph::GetMinIntrinsicWidth() const { + // TODO(garyq): Implement. return min_intrinsic_width_; } @@ -253,10 +276,13 @@ void Paragraph::Paint(SkCanvas* canvas, double x, double y) { } } +int Paragraph::GetLineCount() const { + // FTL_LOG(INFO) << "Lines: " << lines_; + return lines_; +} + bool Paragraph::DidExceedMaxLines() const { - if (y_ / (paragraph_style_.font_size * paragraph_style_.line_height) > - paragraph_style_.max_lines) - // if (lines_ > paragraph_style_.max_lines) + if (GetLineCount() > paragraph_style_.max_lines) return true; return false; } diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index ca05810209..4ef74e3fca 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -21,7 +21,6 @@ #include "lib/ftl/macros.h" #include "lib/txt/src/paint_record.h" -#include "lib/txt/src/paragraph_constraints.h" #include "lib/txt/src/paragraph_style.h" #include "lib/txt/src/styled_runs.h" #include "minikin/LineBreaker.h" @@ -38,7 +37,7 @@ class Paragraph { ~Paragraph(); - void Layout(const ParagraphConstraints& constraints, + void Layout(double width, const std::string& rootdir = "", const double x_offset = 0.0, const double y_offset = 0.0); @@ -57,6 +56,8 @@ class Paragraph { double GetMinIntrinsicWidth() const; + int GetLineCount() const; + bool DidExceedMaxLines() const; private: @@ -76,9 +77,9 @@ class Paragraph { ParagraphStyle paragraph_style_; SkScalar y_ = 0.0f; // Height of the paragraph after Layout(). double width_ = 0.0f; - int lines_ = 0; + int lines_ = 1; double max_intrinsic_width_ = 0.0f; - double min_intrinsic_width_ = FLT_MAX; + double min_intrinsic_width_ = 0; void SetText(std::vector text, StyledRuns runs); diff --git a/engine/src/flutter/src/paragraph_constraints.cc b/engine/src/flutter/src/paragraph_constraints.cc deleted file mode 100644 index 26a85e0463..0000000000 --- a/engine/src/flutter/src/paragraph_constraints.cc +++ /dev/null @@ -1,23 +0,0 @@ -/* - * Copyright 2017 Google, Inc. - * - * 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 "lib/txt/src/paragraph_constraints.h" - -namespace txt { - -ParagraphConstraints::ParagraphConstraints(double width) : width_(width) {} - -} // namespace txt diff --git a/engine/src/flutter/src/paragraph_constraints.h b/engine/src/flutter/src/paragraph_constraints.h deleted file mode 100644 index e666451527..0000000000 --- a/engine/src/flutter/src/paragraph_constraints.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright 2017 Google, Inc. - * - * 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 LIB_TXT_SRC_PARAGRAPH_CONSTRAINTS_H_ -#define LIB_TXT_SRC_PARAGRAPH_CONSTRAINTS_H_ - -#include "lib/ftl/macros.h" - -namespace txt { - -class ParagraphConstraints { - public: - explicit ParagraphConstraints(double width); - - double width() const { return width_; } - - private: - double width_; - - FTL_DISALLOW_COPY_AND_ASSIGN(ParagraphConstraints); -}; - -} // namespace txt - -#endif // LIB_TXT_SRC_PARAGRAPH_CONSTRAINTS_H_ diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 88071b13bd..64c38a98a0 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -43,8 +43,7 @@ TEST_F(RenderTest, SimpleParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, - txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); paragraph->Paint(GetCanvas(), 10.0, 15.0); @@ -77,8 +76,7 @@ TEST_F(RenderTest, SimpleRedParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, - txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); paragraph->Paint(GetCanvas(), 10.0, 15.0); @@ -98,7 +96,7 @@ TEST_F(RenderTest, RainbowParagraph) { auto icu_text1 = icu::UnicodeString::fromUTF8(text1); std::u16string u16_text1(icu_text1.getBuffer(), icu_text1.getBuffer() + icu_text1.length()); - const char* text2 = "BigGreenDefault "; + const char* text2 = "Big Green Default "; auto icu_text2 = icu::UnicodeString::fromUTF8(text2); std::u16string u16_text2(icu_text2.getBuffer(), icu_text2.getBuffer() + icu_text2.length()); @@ -129,8 +127,8 @@ TEST_F(RenderTest, RainbowParagraph) { txt::TextStyle text_style2; text_style2.font_size = 50; - // Letter spacing not yet implemented - text_style2.letter_spacing = 100; + text_style2.letter_spacing = 10; + text_style2.word_spacing = 30; text_style2.font_weight = txt::FontWeight::w600; text_style2.fake_bold = true; text_style2.color = SK_ColorGREEN; @@ -159,8 +157,7 @@ TEST_F(RenderTest, RainbowParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, - txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); paragraph->Paint(GetCanvas(), 10.0, 50.0); @@ -199,8 +196,7 @@ TEST_F(RenderTest, DefaultStyleParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, - txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); paragraph->Paint(GetCanvas(), 10.0, 15.0); @@ -236,8 +232,7 @@ TEST_F(RenderTest, BoldParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, - txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); paragraph->Paint(GetCanvas(), 10.0, 60.0); @@ -302,8 +297,7 @@ TEST_F(RenderTest, LinebreakParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, - txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); paragraph->Paint(GetCanvas(), 5.0, 30.0); @@ -338,8 +332,7 @@ TEST_F(RenderTest, ItalicsParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(txt::ParagraphConstraints{GetTestCanvasWidth()}, - txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); paragraph->Paint(GetCanvas(), 10.0, 35.0); From 23cc989a3598add72f9f2fe2ee43a434608554d6 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 19 Jun 2017 11:26:12 -0700 Subject: [PATCH 294/364] Add preliminary support for letter-spacing and word-spacing Change-Id: If3f64cf0c18ff0aa087091626532bcd983f6b54c --- engine/src/flutter/src/paragraph.cc | 20 +++++++++---------- .../flutter/tests/txt/paragraph_unittests.cc | 20 +++++++++---------- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 26e8c3b96a..117e20c05a 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -149,7 +149,7 @@ void Paragraph::Layout(double width, // Reset member variables so Layout still works when called more than once max_intrinsic_width_ = 0.0f; - lines_ = 1; + lines_ = 0; minikin::Layout layout; SkScalar x = x_offset; @@ -170,8 +170,7 @@ void Paragraph::Layout(double width, size_t layout_start = run.start; - while (layout_start < run.end && - GetLineCount() <= paragraph_style_.max_lines) { + while (layout_start < run.end && lines_ < paragraph_style_.max_lines) { const size_t next_break = (break_index > breaks_count - 1) ? std::numeric_limits::max() : breaks[break_index]; @@ -194,14 +193,15 @@ void Paragraph::Layout(double width, const size_t glyph_index = blob_start + blob_index; buffer.glyphs[blob_index] = layout.getGlyphId(glyph_index); const size_t pos_index = 2 * blob_index; - letter_spacing_offset += run.style.letter_spacing; buffer.pos[pos_index] = layout.getX(glyph_index) + letter_spacing_offset + word_spacing_offset; + letter_spacing_offset += run.style.letter_spacing; buffer.pos[pos_index + 1] = layout.getY(glyph_index); } blob_start += blob_length; - // Subtract letter offset to avoid big gap at end of run. + // Subtract letter offset to avoid big gap at end of run. This my be + // removed depending on the specificatins for letter spacing. letter_spacing_offset -= run.style.letter_spacing; word_spacing_offset += run.style.word_spacing; @@ -210,6 +210,10 @@ void Paragraph::Layout(double width, layout.getX(blob_start - 1) + letter_spacing_offset; } + // Subtract word offset to avoid big gap at end of run. This my be + // removed depending on the specificatins for word spacing. + word_spacing_offset -= run.style.word_spacing; + // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the // color stayed the same. records_.push_back( @@ -224,8 +228,6 @@ void Paragraph::Layout(double width, y_ += run.style.font_size * run.style.height; break_index += 1; lines_++; - if (lines_ > paragraph_style_.max_lines) - lines_--; } else { x += layout.getAdvance(); } @@ -259,8 +261,7 @@ double Paragraph::GetMinIntrinsicWidth() const { } double Paragraph::GetHeight() const { - return paragraph_style_.font_size * paragraph_style_.line_height * - paragraph_style_.max_lines; + return y_; } void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { @@ -277,7 +278,6 @@ void Paragraph::Paint(SkCanvas* canvas, double x, double y) { } int Paragraph::GetLineCount() const { - // FTL_LOG(INFO) << "Lines: " << lines_; return lines_; } diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 64c38a98a0..86988e8a2d 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -92,25 +92,25 @@ TEST_F(RenderTest, SimpleRedParagraph) { } TEST_F(RenderTest, RainbowParagraph) { - const char* text1 = "RedRoboto "; + const char* text1 = "Red Roboto"; auto icu_text1 = icu::UnicodeString::fromUTF8(text1); std::u16string u16_text1(icu_text1.getBuffer(), icu_text1.getBuffer() + icu_text1.length()); - const char* text2 = "Big Green Default "; + const char* text2 = "Big Green Default"; auto icu_text2 = icu::UnicodeString::fromUTF8(text2); std::u16string u16_text2(icu_text2.getBuffer(), icu_text2.getBuffer() + icu_text2.length()); - const char* text3 = "DefcolorHomemadeApple "; + const char* text3 = "Defcolor Homemade Apple"; auto icu_text3 = icu::UnicodeString::fromUTF8(text3); std::u16string u16_text3(icu_text3.getBuffer(), icu_text3.getBuffer() + icu_text3.length()); - const char* text4 = "SmallBlueRoboto "; + const char* text4 = "Small Blue Roboto"; auto icu_text4 = icu::UnicodeString::fromUTF8(text4); std::u16string u16_text4(icu_text4.getBuffer(), icu_text4.getBuffer() + icu_text4.length()); const char* text5 = - "Continue Last Style With lots of words to check if it overlaps properly " - "or not"; + "Continue Last Style With lots of words to check if it overlaps " + "properly or not"; auto icu_text5 = icu::UnicodeString::fromUTF8(text5); std::u16string u16_text5(icu_text5.getBuffer(), icu_text5.getBuffer() + icu_text5.length()); @@ -281,13 +281,13 @@ TEST_F(RenderTest, LinebreakParagraph) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - paragraph_style.max_lines = 1000; + paragraph_style.max_lines = 14; txt::ParagraphBuilder builder(paragraph_style); txt::TextStyle text_style; text_style.font_size = 26; // Letter spacing not yet implemented - text_style.letter_spacing = 10; + text_style.letter_spacing = 0; text_style.color = SK_ColorBLACK; text_style.height = 1.15; builder.PushStyle(text_style); @@ -297,9 +297,9 @@ TEST_F(RenderTest, LinebreakParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth() - 100, txt::GetFontDir()); - paragraph->Paint(GetCanvas(), 5.0, 30.0); + paragraph->Paint(GetCanvas(), 0, 30.0); ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); for (size_t i = 0; i < u16_text.length(); i++) { From 197827c35cb160546e793442f336e320edac2fdd Mon Sep 17 00:00:00 2001 From: Ankur Mittal Date: Mon, 19 Jun 2017 15:39:58 -0700 Subject: [PATCH 295/364] Remove deps on gtest from static lib rule Change-Id: Iae0c4370ad0c7c3194209b7784797e81ee5f6825 --- engine/src/flutter/BUILD.gn | 1 - 1 file changed, 1 deletion(-) diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn index b47c5a20c8..11ff6440bd 100644 --- a/engine/src/flutter/BUILD.gn +++ b/engine/src/flutter/BUILD.gn @@ -54,7 +54,6 @@ static_library("txt") { deps = [ "//lib/txt/libs/minikin", - "//third_party/gtest", "//third_party/skia", ] } From 3f5ae2f4a39d0acbe5e5c44d3267d31781403573 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 20 Jun 2017 16:22:44 -0700 Subject: [PATCH 296/364] Add support for underline, overline, and strikethrough. Change-Id: Id98ecb8409be69d9de44dc931ed6143163469c27 --- engine/src/flutter/src/paint_record.cc | 15 +++- engine/src/flutter/src/paint_record.h | 16 +++- engine/src/flutter/src/paragraph.cc | 85 ++++++++++++++++--- engine/src/flutter/src/paragraph.h | 15 +++- .../flutter/tests/txt/paragraph_unittests.cc | 9 +- 5 files changed, 116 insertions(+), 24 deletions(-) diff --git a/engine/src/flutter/src/paint_record.cc b/engine/src/flutter/src/paint_record.cc index 226b803d42..8740ee8ea4 100644 --- a/engine/src/flutter/src/paint_record.cc +++ b/engine/src/flutter/src/paint_record.cc @@ -15,26 +15,33 @@ */ #include "lib/txt/src/paint_record.h" +#include "lib/ftl/logging.h" namespace txt { -PaintRecord::PaintRecord() = default; - PaintRecord::~PaintRecord() = default; -PaintRecord::PaintRecord(SkColor color, SkPoint offset, sk_sp text) - : color_(color), offset_(offset), text_(std::move(text)) {} +PaintRecord::PaintRecord(SkColor color, + SkPoint offset, + sk_sp text, + SkPaint::FontMetrics metrics) + : color_(color), + offset_(offset), + text_(std::move(text)), + metrics_(metrics) {} PaintRecord::PaintRecord(PaintRecord&& other) { color_ = other.color_; offset_ = other.offset_; text_ = std::move(other.text_); + metrics_ = other.metrics_; } PaintRecord& PaintRecord::operator=(PaintRecord&& other) { color_ = other.color_; offset_ = other.offset_; text_ = std::move(other.text_); + metrics_ = other.metrics_; return *this; } diff --git a/engine/src/flutter/src/paint_record.h b/engine/src/flutter/src/paint_record.h index 04d6f300d6..f758b68729 100644 --- a/engine/src/flutter/src/paint_record.h +++ b/engine/src/flutter/src/paint_record.h @@ -17,20 +17,23 @@ #ifndef LIB_TXT_SRC_PAINT_RECORD_H_ #define LIB_TXT_SRC_PAINT_RECORD_H_ +#include "lib/ftl/logging.h" #include "lib/ftl/macros.h" +#include "third_party/skia/include/core/SkPaint.h" #include "third_party/skia/include/core/SkTextBlob.h" namespace txt { class PaintRecord { public: - PaintRecord(); + PaintRecord() = delete; ~PaintRecord(); - PaintRecord(SkColor color, SkPoint offset, sk_sp text); - - PaintRecord(const PaintRecord& other) = delete; + PaintRecord(SkColor color, + SkPoint offset, + sk_sp text, + SkPaint::FontMetrics metrics); PaintRecord(PaintRecord&& other); @@ -42,10 +45,15 @@ class PaintRecord { SkTextBlob* text() const { return text_.get(); } + const SkPaint::FontMetrics& metrics() const { return metrics_; } + private: SkColor color_; SkPoint offset_; sk_sp text_; + SkPaint::FontMetrics metrics_; + + FTL_DISALLOW_COPY_AND_ASSIGN(PaintRecord); }; } // namespace txt diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 117e20c05a..220e7c260a 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -18,16 +18,15 @@ #include #include +#include #include #include #include -#include "minikin/LineBreaker.h" - #include "lib/ftl/logging.h" - #include "lib/txt/src/font_collection.h" #include "lib/txt/src/font_skia.h" +#include "minikin/LineBreaker.h" #include "third_party/skia/include/core/SkCanvas.h" #include "third_party/skia/include/core/SkPaint.h" #include "third_party/skia/include/core/SkTextBlob.h" @@ -42,6 +41,7 @@ const sk_sp& GetTypefaceForGlyph(const minikin::Layout& layout, return font->GetSkTypeface(); } +// Return the number of glyphs until the typeface changes. size_t GetBlobLength(const minikin::Layout& layout, size_t blob_start) { const size_t glyph_count = layout.nGlyphs(); const sk_sp& typeface = GetTypefaceForGlyph(layout, blob_start); @@ -52,8 +52,8 @@ size_t GetBlobLength(const minikin::Layout& layout, size_t blob_start) { return glyph_count - blob_start; } -int GetWeight(const TextStyle& style) { - switch (style.font_weight) { +int GetWeight(const FontWeight weight) { + switch (weight) { case FontWeight::w100: return 1; case FontWeight::w200: @@ -75,6 +75,10 @@ int GetWeight(const TextStyle& style) { } } +int GetWeight(const TextStyle& style) { + return GetWeight(style.font_weight); +} + bool GetItalic(const TextStyle& style) { switch (style.font_style) { case FontStyle::normal: @@ -157,6 +161,8 @@ void Paragraph::Layout(double width, size_t break_index = 0; double letter_spacing_offset = 0.0f; double word_spacing_offset = 0.0f; + double max_line_spacing = 0.0f; + for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { auto run = runs_.GetRun(run_index); auto collection = @@ -170,6 +176,7 @@ void Paragraph::Layout(double width, size_t layout_start = run.start; + // Layout until the end of the run or too many lines. while (layout_start < run.end && lines_ < paragraph_style_.max_lines) { const size_t next_break = (break_index > breaks_count - 1) ? std::numeric_limits::max() @@ -182,6 +189,7 @@ void Paragraph::Layout(double width, const size_t glyph_count = layout.nGlyphs(); size_t blob_start = 0; + // Each word/blob. while (blob_start < glyph_count) { const size_t blob_length = GetBlobLength(layout, blob_start); // TODO(abarth): Precompute when we can use allocRunPosH. @@ -189,6 +197,9 @@ void Paragraph::Layout(double width, auto buffer = builder.allocRunPos(paint, blob_length); + letter_spacing_offset += run.style.letter_spacing; + + // Each Glyph/Letter. for (size_t blob_index = 0; blob_index < blob_length; ++blob_index) { const size_t glyph_index = blob_start + blob_index; buffer.glyphs[blob_index] = layout.getGlyphId(glyph_index); @@ -201,8 +212,8 @@ void Paragraph::Layout(double width, blob_start += blob_length; // Subtract letter offset to avoid big gap at end of run. This my be - // removed depending on the specificatins for letter spacing. - letter_spacing_offset -= run.style.letter_spacing; + // removed depending on the specifications for letter spacing. + // letter_spacing_offset -= run.style.letter_spacing; word_spacing_offset += run.style.word_spacing; @@ -213,19 +224,29 @@ void Paragraph::Layout(double width, // Subtract word offset to avoid big gap at end of run. This my be // removed depending on the specificatins for word spacing. word_spacing_offset -= run.style.word_spacing; - // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the // color stayed the same. - records_.push_back( - PaintRecord(run.style.color, SkPoint::Make(x, y_), builder.make())); + // TODO(garyq): Ensure that the typeface does not change throughout a + // run. + SkPaint::FontMetrics metrics; + paint.getFontMetrics(&metrics); + records_.push_back(PaintRecord{run.style.color, SkPoint::Make(x, y_), + builder.make(), metrics}); + decorations_.push_back( + std::make_tuple(run.style.decoration, run.style.decoration_color, + run.style.decoration_style, run.style.font_weight)); + if (max_line_spacing < -metrics.fAscent * run.style.height) + max_line_spacing = -metrics.fAscent * run.style.height; if (layout_end == next_break) { + y_ += max_line_spacing; + + max_line_spacing = 0.0f; x = 0.0f; letter_spacing_offset = 0.0f; word_spacing_offset = 0.0f; // TODO(abarth): Use the line height, which is something like the max // font_size for runs in this line times the paragraph's line height. - y_ += run.style.font_size * run.style.height; break_index += 1; lines_++; } else { @@ -269,11 +290,49 @@ void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { } void Paragraph::Paint(SkCanvas* canvas, double x, double y) { - SkPaint paint; + int i = 0; for (const auto& record : records_) { + SkPaint paint; paint.setColor(record.color()); const SkPoint& offset = record.offset(); canvas->drawTextBlob(record.text(), x + offset.x(), y + offset.y(), paint); + PaintDecorations(canvas, x + offset.x(), y + offset.y(), decorations_[i], + record.metrics(), record.text()); + i++; + } +} + +void Paragraph::PaintDecorations( + SkCanvas* canvas, + double x, + double y, + std::tuple + decoration, + SkPaint::FontMetrics metrics, + SkTextBlob* blob) { + if (std::get<0>(decoration) != TextDecoration::kNone) { + SkPaint paint; + paint.setStyle(SkPaint::kStroke_Style); + paint.setColor(std::get<1>(decoration)); + paint.setAntiAlias(true); + + double width = blob->bounds().fRight + blob->bounds().fLeft; + + if (std::get<0>(decoration) & 0x1) { + paint.setStrokeWidth(metrics.fUnderlineThickness); + canvas->drawLine(x, y + metrics.fUnderlineThickness, x + width, + y + metrics.fUnderlineThickness, paint); + } + if (std::get<0>(decoration) & 0x2) { + paint.setStrokeWidth(metrics.fUnderlineThickness); + canvas->drawLine(x, y + metrics.fAscent, x + width, y + metrics.fAscent, + paint); + } + if (std::get<0>(decoration) & 0x4) { + paint.setStrokeWidth(metrics.fUnderlineThickness); + canvas->drawLine(x, y - metrics.fCapHeight / 2.5, x + width, + y - metrics.fCapHeight / 2.5, paint); + } } } @@ -282,7 +341,7 @@ int Paragraph::GetLineCount() const { } bool Paragraph::DidExceedMaxLines() const { - if (GetLineCount() > paragraph_style_.max_lines) + if (lines_ > paragraph_style_.max_lines) return true; return false; } diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 4ef74e3fca..5a1e861afd 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -17,6 +17,7 @@ #ifndef LIB_TXT_SRC_PARAGRAPH_H_ #define LIB_TXT_SRC_PARAGRAPH_H_ +#include #include #include "lib/ftl/macros.h" @@ -74,12 +75,15 @@ class Paragraph { StyledRuns runs_; minikin::LineBreaker breaker_; std::vector records_; + std::vector< + std::tuple> + decorations_; ParagraphStyle paragraph_style_; SkScalar y_ = 0.0f; // Height of the paragraph after Layout(). double width_ = 0.0f; int lines_ = 1; double max_intrinsic_width_ = 0.0f; - double min_intrinsic_width_ = 0; + double min_intrinsic_width_ = 0.0f; void SetText(std::vector text, StyledRuns runs); @@ -87,6 +91,15 @@ class Paragraph { void AddRunsToLineBreaker(const std::string& rootdir = ""); + void PaintDecorations( + SkCanvas* canvas, + double x, + double y, + std::tuple + decoration, + SkPaint::FontMetrics metrics, + SkTextBlob* blob); + FTL_DISALLOW_COPY_AND_ASSIGN(Paragraph); }; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 86988e8a2d..7f01eb45c7 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -96,7 +96,7 @@ TEST_F(RenderTest, RainbowParagraph) { auto icu_text1 = icu::UnicodeString::fromUTF8(text1); std::u16string u16_text1(icu_text1.getBuffer(), icu_text1.getBuffer() + icu_text1.length()); - const char* text2 = "Big Green Default"; + const char* text2 = "big Greeen Default"; auto icu_text2 = icu::UnicodeString::fromUTF8(text2); std::u16string u16_text2(icu_text2.getBuffer(), icu_text2.getBuffer() + icu_text2.length()); @@ -116,6 +116,7 @@ TEST_F(RenderTest, RainbowParagraph) { icu_text5.getBuffer() + icu_text5.length()); txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 2; txt::ParagraphBuilder builder(paragraph_style); txt::TextStyle text_style1; @@ -132,6 +133,8 @@ TEST_F(RenderTest, RainbowParagraph) { text_style2.font_weight = txt::FontWeight::w600; text_style2.fake_bold = true; text_style2.color = SK_ColorGREEN; + text_style2.decoration = txt::TextDecoration(0x1 | 0x2 | 0x4); + text_style2.decoration_color = SK_ColorBLACK; builder.PushStyle(text_style2); builder.AddText(u16_text2); @@ -165,6 +168,7 @@ TEST_F(RenderTest, RainbowParagraph) { for (size_t i = 0; i < u16_text1.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text1[i]); } + ASSERT_TRUE(Snapshot()); ASSERT_EQ(paragraph->runs_.runs_.size(), 4ull); ASSERT_EQ(paragraph->runs_.styles_.size(), 4ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style1)); @@ -175,7 +179,6 @@ TEST_F(RenderTest, RainbowParagraph) { ASSERT_EQ(paragraph->records_[1].color(), text_style2.color); ASSERT_EQ(paragraph->records_[2].color(), text_style3.color); ASSERT_EQ(paragraph->records_[3].color(), text_style4.color); - ASSERT_TRUE(Snapshot()); } // Currently, this should render nothing without a supplied TextStyle. @@ -290,6 +293,8 @@ TEST_F(RenderTest, LinebreakParagraph) { text_style.letter_spacing = 0; text_style.color = SK_ColorBLACK; text_style.height = 1.15; + text_style.decoration = txt::TextDecoration(0x1); + text_style.decoration_color = SK_ColorBLACK; builder.PushStyle(text_style); builder.AddText(u16_text); From b4c8d2c134234afc0eeb2f5b4975ac83b456efbc Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 20 Jun 2017 18:28:09 -0700 Subject: [PATCH 297/364] Add support for Decoration Styles, remove usage of separate decoration records. Change-Id: I8fe929b0814b22e37e1517a7ddafb70a1c6b3d37 --- engine/src/flutter/src/paint_record.cc | 4 + engine/src/flutter/src/paint_record.h | 5 ++ engine/src/flutter/src/paragraph.cc | 103 ++++++++++++++++------- engine/src/flutter/src/paragraph.h | 17 ++-- engine/src/flutter/src/text_decoration.h | 10 +-- 5 files changed, 89 insertions(+), 50 deletions(-) diff --git a/engine/src/flutter/src/paint_record.cc b/engine/src/flutter/src/paint_record.cc index 8740ee8ea4..f8d13dbc25 100644 --- a/engine/src/flutter/src/paint_record.cc +++ b/engine/src/flutter/src/paint_record.cc @@ -22,16 +22,19 @@ namespace txt { PaintRecord::~PaintRecord() = default; PaintRecord::PaintRecord(SkColor color, + TextStyle style, SkPoint offset, sk_sp text, SkPaint::FontMetrics metrics) : color_(color), + style_(style), offset_(offset), text_(std::move(text)), metrics_(metrics) {} PaintRecord::PaintRecord(PaintRecord&& other) { color_ = other.color_; + style_ = other.style_; offset_ = other.offset_; text_ = std::move(other.text_); metrics_ = other.metrics_; @@ -39,6 +42,7 @@ PaintRecord::PaintRecord(PaintRecord&& other) { PaintRecord& PaintRecord::operator=(PaintRecord&& other) { color_ = other.color_; + style_ = other.style_; offset_ = other.offset_; text_ = std::move(other.text_); metrics_ = other.metrics_; diff --git a/engine/src/flutter/src/paint_record.h b/engine/src/flutter/src/paint_record.h index f758b68729..d0c18fc05d 100644 --- a/engine/src/flutter/src/paint_record.h +++ b/engine/src/flutter/src/paint_record.h @@ -19,6 +19,7 @@ #include "lib/ftl/logging.h" #include "lib/ftl/macros.h" +#include "lib/txt/src/text_style.h" #include "third_party/skia/include/core/SkPaint.h" #include "third_party/skia/include/core/SkTextBlob.h" @@ -31,6 +32,7 @@ class PaintRecord { ~PaintRecord(); PaintRecord(SkColor color, + TextStyle style, SkPoint offset, sk_sp text, SkPaint::FontMetrics metrics); @@ -47,8 +49,11 @@ class PaintRecord { const SkPaint::FontMetrics& metrics() const { return metrics_; } + const TextStyle& style() const { return style_; } + private: SkColor color_; + TextStyle style_; SkPoint offset_; sk_sp text_; SkPaint::FontMetrics metrics_; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 220e7c260a..48fcc8a56f 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -31,6 +31,8 @@ #include "third_party/skia/include/core/SkPaint.h" #include "third_party/skia/include/core/SkTextBlob.h" #include "third_party/skia/include/core/SkTypeface.h" +#include "third_party/skia/include/effects/SkDashPathEffect.h" +#include "third_party/skia/include/effects/SkDiscretePathEffect.h" namespace txt { namespace { @@ -230,11 +232,9 @@ void Paragraph::Layout(double width, // run. SkPaint::FontMetrics metrics; paint.getFontMetrics(&metrics); - records_.push_back(PaintRecord{run.style.color, SkPoint::Make(x, y_), - builder.make(), metrics}); - decorations_.push_back( - std::make_tuple(run.style.decoration, run.style.decoration_color, - run.style.decoration_style, run.style.font_weight)); + records_.push_back(PaintRecord{run.style.color, run.style, + SkPoint::Make(x, y_), builder.make(), + metrics}); if (max_line_spacing < -metrics.fAscent * run.style.height) max_line_spacing = -metrics.fAscent * run.style.height; @@ -290,48 +290,87 @@ void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { } void Paragraph::Paint(SkCanvas* canvas, double x, double y) { - int i = 0; for (const auto& record : records_) { SkPaint paint; paint.setColor(record.color()); const SkPoint& offset = record.offset(); canvas->drawTextBlob(record.text(), x + offset.x(), y + offset.y(), paint); - PaintDecorations(canvas, x + offset.x(), y + offset.y(), decorations_[i], + PaintDecorations(canvas, x + offset.x(), y + offset.y(), record.style(), record.metrics(), record.text()); - i++; } } -void Paragraph::PaintDecorations( - SkCanvas* canvas, - double x, - double y, - std::tuple - decoration, - SkPaint::FontMetrics metrics, - SkTextBlob* blob) { - if (std::get<0>(decoration) != TextDecoration::kNone) { +void Paragraph::PaintDecorations(SkCanvas* canvas, + double x, + double y, + TextStyle style, + SkPaint::FontMetrics metrics, + SkTextBlob* blob) { + if (style.decoration != TextDecoration::kNone) { SkPaint paint; paint.setStyle(SkPaint::kStroke_Style); - paint.setColor(std::get<1>(decoration)); + paint.setColor(style.decoration_color); paint.setAntiAlias(true); + // This is set to 2 for the double line style + int decoration_count = 1; + + switch (style.decoration_style) { + case TextDecorationStyle::kSolid: + break; + case TextDecorationStyle::kDouble: { + decoration_count = 2; + break; + } + case TextDecorationStyle::kDotted: { + const SkScalar intervals[] = {3.0f, 5.0f, 3.0f, 5.0f}; + size_t count = sizeof(intervals) / sizeof(intervals[0]); + paint.setPathEffect(SkPathEffect::MakeCompose( + SkDashPathEffect::Make(intervals, count, 0.0f), + SkDiscretePathEffect::Make(0, 0))); + break; + } + case TextDecorationStyle::kDashed: { + const SkScalar intervals[] = {10.0f, 5.0f, 10.0f, 5.0f}; + size_t count = sizeof(intervals) / sizeof(intervals[0]); + paint.setPathEffect(SkPathEffect::MakeCompose( + SkDashPathEffect::Make(intervals, count, 0.0f), + SkDiscretePathEffect::Make(0, 0))); + break; + } + case TextDecorationStyle::kWavy: { + // TODO(garyq): Wave currently does a random wave instead of an ordered + // wave. + const SkScalar intervals[] = {1}; + size_t count = sizeof(intervals) / sizeof(intervals[0]); + paint.setPathEffect(SkPathEffect::MakeCompose( + SkDashPathEffect::Make(intervals, count, 0.0f), + SkDiscretePathEffect::Make(metrics.fAvgCharWidth / 10.0f, + metrics.fAvgCharWidth / 10.0f))); + break; + } + } + double width = blob->bounds().fRight + blob->bounds().fLeft; - if (std::get<0>(decoration) & 0x1) { - paint.setStrokeWidth(metrics.fUnderlineThickness); - canvas->drawLine(x, y + metrics.fUnderlineThickness, x + width, - y + metrics.fUnderlineThickness, paint); - } - if (std::get<0>(decoration) & 0x2) { - paint.setStrokeWidth(metrics.fUnderlineThickness); - canvas->drawLine(x, y + metrics.fAscent, x + width, y + metrics.fAscent, - paint); - } - if (std::get<0>(decoration) & 0x4) { - paint.setStrokeWidth(metrics.fUnderlineThickness); - canvas->drawLine(x, y - metrics.fCapHeight / 2.5, x + width, - y - metrics.fCapHeight / 2.5, paint); + for (int i = 0; i < decoration_count; i++) { + double y_offset = i * metrics.fUnderlineThickness * 3.0f; + if (style.decoration & 0x1) { + paint.setStrokeWidth(metrics.fUnderlineThickness); + canvas->drawLine(x, y + metrics.fUnderlineThickness + y_offset, + x + width, y + metrics.fUnderlineThickness + y_offset, + paint); + } + if (style.decoration & 0x2) { + paint.setStrokeWidth(metrics.fUnderlineThickness); + canvas->drawLine(x, y + metrics.fAscent + y_offset, x + width, + y + metrics.fAscent + y_offset, paint); + } + if (style.decoration & 0x4) { + paint.setStrokeWidth(metrics.fUnderlineThickness); + canvas->drawLine(x, y - metrics.fXHeight / 2 + y_offset, x + width, + y - metrics.fXHeight / 2 + y_offset, paint); + } } } } diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 5a1e861afd..1d6ccd402d 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -75,9 +75,6 @@ class Paragraph { StyledRuns runs_; minikin::LineBreaker breaker_; std::vector records_; - std::vector< - std::tuple> - decorations_; ParagraphStyle paragraph_style_; SkScalar y_ = 0.0f; // Height of the paragraph after Layout(). double width_ = 0.0f; @@ -91,14 +88,12 @@ class Paragraph { void AddRunsToLineBreaker(const std::string& rootdir = ""); - void PaintDecorations( - SkCanvas* canvas, - double x, - double y, - std::tuple - decoration, - SkPaint::FontMetrics metrics, - SkTextBlob* blob); + void PaintDecorations(SkCanvas* canvas, + double x, + double y, + TextStyle style, + SkPaint::FontMetrics metrics, + SkTextBlob* blob); FTL_DISALLOW_COPY_AND_ASSIGN(Paragraph); }; diff --git a/engine/src/flutter/src/text_decoration.h b/engine/src/flutter/src/text_decoration.h index 8e7b1654a4..055cf4b579 100644 --- a/engine/src/flutter/src/text_decoration.h +++ b/engine/src/flutter/src/text_decoration.h @@ -19,6 +19,8 @@ namespace txt { +// Multiple decorations can be applied at once. Ex: Underline and overline is +// (0x1 | 0x2) enum TextDecoration { kNone = 0x0, kUnderline = 0x1, @@ -26,13 +28,7 @@ enum TextDecoration { kLineThrough = 0x4, }; -enum TextDecorationStyle { - kSolid, - kDouble, // "double" is reserved. - kDotted, - kDashed, - kWavy -}; +enum TextDecorationStyle { kSolid, kDouble, kDotted, kDashed, kWavy }; } // namespace txt From f1a7448f4422e75aad038cb902d62ffdfac0da26 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 21 Jun 2017 11:46:37 -0700 Subject: [PATCH 298/364] Properly implement line spacing. Change-Id: I2f7f7768fc9d6332873f27dce6e058b354b0330d --- engine/src/flutter/src/paint_record.cc | 17 ++++--- engine/src/flutter/src/paint_record.h | 12 +++-- engine/src/flutter/src/paragraph.cc | 51 ++++++++++++++----- engine/src/flutter/src/paragraph.h | 4 +- .../flutter/tests/txt/paragraph_unittests.cc | 18 +++---- 5 files changed, 69 insertions(+), 33 deletions(-) diff --git a/engine/src/flutter/src/paint_record.cc b/engine/src/flutter/src/paint_record.cc index f8d13dbc25..e360e55a43 100644 --- a/engine/src/flutter/src/paint_record.cc +++ b/engine/src/flutter/src/paint_record.cc @@ -21,19 +21,21 @@ namespace txt { PaintRecord::~PaintRecord() = default; -PaintRecord::PaintRecord(SkColor color, - TextStyle style, +PaintRecord::PaintRecord(TextStyle style, SkPoint offset, sk_sp text, SkPaint::FontMetrics metrics) - : color_(color), - style_(style), + : style_(style), offset_(offset), text_(std::move(text)), metrics_(metrics) {} +PaintRecord::PaintRecord(TextStyle style, + sk_sp text, + SkPaint::FontMetrics metrics) + : style_(style), text_(std::move(text)), metrics_(metrics) {} + PaintRecord::PaintRecord(PaintRecord&& other) { - color_ = other.color_; style_ = other.style_; offset_ = other.offset_; text_ = std::move(other.text_); @@ -41,7 +43,6 @@ PaintRecord::PaintRecord(PaintRecord&& other) { } PaintRecord& PaintRecord::operator=(PaintRecord&& other) { - color_ = other.color_; style_ = other.style_; offset_ = other.offset_; text_ = std::move(other.text_); @@ -49,4 +50,8 @@ PaintRecord& PaintRecord::operator=(PaintRecord&& other) { return *this; } +void PaintRecord::SetOffset(SkPoint pt) { + offset_ = pt; +} + } // namespace txt diff --git a/engine/src/flutter/src/paint_record.h b/engine/src/flutter/src/paint_record.h index d0c18fc05d..f9434ed163 100644 --- a/engine/src/flutter/src/paint_record.h +++ b/engine/src/flutter/src/paint_record.h @@ -31,20 +31,23 @@ class PaintRecord { ~PaintRecord(); - PaintRecord(SkColor color, - TextStyle style, + PaintRecord(TextStyle style, SkPoint offset, sk_sp text, SkPaint::FontMetrics metrics); + PaintRecord(TextStyle style, + sk_sp text, + SkPaint::FontMetrics metrics); + PaintRecord(PaintRecord&& other); PaintRecord& operator=(PaintRecord&& other); - SkColor color() const { return color_; } - SkPoint offset() const { return offset_; } + void SetOffset(SkPoint pt); + SkTextBlob* text() const { return text_.get(); } const SkPaint::FontMetrics& metrics() const { return metrics_; } @@ -52,7 +55,6 @@ class PaintRecord { const TextStyle& style() const { return style_; } private: - SkColor color_; TextStyle style_; SkPoint offset_; sk_sp text_; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 48fcc8a56f..cb2d7d99e7 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -138,8 +138,9 @@ void Paragraph::Layout(double width, const std::string& rootdir, const double x_offset, const double y_offset) { - breaker_.setLineWidths(0.0f, 0, width); width_ = width; + + breaker_.setLineWidths(0.0f, 0, width); AddRunsToLineBreaker(rootdir); size_t breaks_count = breaker_.computeBreaks(); const int* breaks = breaker_.getBreaks(); @@ -150,20 +151,31 @@ void Paragraph::Layout(double width, minikin::FontStyle font; minikin::MinikinPaint minikin_paint; + minikin::Layout layout; SkTextBlobBuilder builder; // Reset member variables so Layout still works when called more than once max_intrinsic_width_ = 0.0f; lines_ = 0; - - minikin::Layout layout; - SkScalar x = x_offset; y_ = y_offset; + + SkScalar x = x_offset; size_t break_index = 0; double letter_spacing_offset = 0.0f; double word_spacing_offset = 0.0f; double max_line_spacing = 0.0f; + double max_descent = 0.0f; + double prev_max_descent = 0.0f; + std::vector x_queue; + + auto flush = [this, &x_queue]() -> void { + for (size_t i = 0; i < x_queue.size(); ++i) { + records_[records_.size() - (x_queue.size() - i)].SetOffset( + SkPoint::Make(x_queue[i], y_)); + } + x_queue.clear(); + }; for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { auto run = runs_.GetRun(run_index); @@ -206,10 +218,12 @@ void Paragraph::Layout(double width, const size_t glyph_index = blob_start + blob_index; buffer.glyphs[blob_index] = layout.getGlyphId(glyph_index); const size_t pos_index = 2 * blob_index; + buffer.pos[pos_index] = layout.getX(glyph_index) + letter_spacing_offset + word_spacing_offset; - letter_spacing_offset += run.style.letter_spacing; buffer.pos[pos_index + 1] = layout.getY(glyph_index); + + letter_spacing_offset += run.style.letter_spacing; } blob_start += blob_length; @@ -232,16 +246,27 @@ void Paragraph::Layout(double width, // run. SkPaint::FontMetrics metrics; paint.getFontMetrics(&metrics); - records_.push_back(PaintRecord{run.style.color, run.style, - SkPoint::Make(x, y_), builder.make(), - metrics}); - if (max_line_spacing < -metrics.fAscent * run.style.height) - max_line_spacing = -metrics.fAscent * run.style.height; + records_.push_back(PaintRecord{run.style, builder.make(), metrics}); + + // Must adjust each line to the largest text in the line, so cannot + // directly push the offset property of PaintRecord until line is + // finished. + x_queue.push_back(x); + + if (max_line_spacing < + (-metrics.fAscent + metrics.fLeading) * run.style.height) + max_line_spacing = + (-metrics.fAscent + metrics.fLeading) * run.style.height; + if (max_descent < metrics.fDescent * run.style.height) + max_descent = metrics.fDescent * run.style.height; if (layout_end == next_break) { - y_ += max_line_spacing; + y_ += max_line_spacing + prev_max_descent; + prev_max_descent = max_descent; + flush(); max_line_spacing = 0.0f; + max_descent = 0.0f; x = 0.0f; letter_spacing_offset = 0.0f; word_spacing_offset = 0.0f; @@ -256,6 +281,8 @@ void Paragraph::Layout(double width, layout_start = layout_end; } } + y_ += max_line_spacing; + flush(); } const ParagraphStyle& Paragraph::GetParagraphStyle() const { @@ -292,7 +319,7 @@ void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { void Paragraph::Paint(SkCanvas* canvas, double x, double y) { for (const auto& record : records_) { SkPaint paint; - paint.setColor(record.color()); + paint.setColor(record.style().color); const SkPoint& offset = record.offset(); canvas->drawTextBlob(record.text(), x + offset.x(), y + offset.y(), paint); PaintDecorations(canvas, x + offset.x(), y + offset.y(), record.style(), diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 1d6ccd402d..1b128481fd 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -76,7 +76,9 @@ class Paragraph { minikin::LineBreaker breaker_; std::vector records_; ParagraphStyle paragraph_style_; - SkScalar y_ = 0.0f; // Height of the paragraph after Layout(). + SkScalar y_ = 0.0f; + // TODO(garyq): Height of the paragraph after Layout(). + SkScalar height_ = 0.0f; double width_ = 0.0f; int lines_ = 1; double max_intrinsic_width_ = 0.0f; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 7f01eb45c7..941d6cd8c9 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -54,7 +54,7 @@ TEST_F(RenderTest, SimpleParagraph) { ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); - ASSERT_EQ(paragraph->records_[0].color(), text_style.color); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_TRUE(Snapshot()); } @@ -87,7 +87,7 @@ TEST_F(RenderTest, SimpleRedParagraph) { ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); - ASSERT_EQ(paragraph->records_[0].color(), text_style.color); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_TRUE(Snapshot()); } @@ -175,10 +175,10 @@ TEST_F(RenderTest, RainbowParagraph) { ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style2)); ASSERT_TRUE(paragraph->runs_.styles_[2].equals(text_style3)); ASSERT_TRUE(paragraph->runs_.styles_[3].equals(text_style4)); - ASSERT_EQ(paragraph->records_[0].color(), text_style1.color); - ASSERT_EQ(paragraph->records_[1].color(), text_style2.color); - ASSERT_EQ(paragraph->records_[2].color(), text_style3.color); - ASSERT_EQ(paragraph->records_[3].color(), text_style4.color); + ASSERT_EQ(paragraph->records_[0].style().color, text_style1.color); + ASSERT_EQ(paragraph->records_[1].style().color, text_style2.color); + ASSERT_EQ(paragraph->records_[2].style().color, text_style3.color); + ASSERT_EQ(paragraph->records_[3].style().color, text_style4.color); } // Currently, this should render nothing without a supplied TextStyle. @@ -246,7 +246,7 @@ TEST_F(RenderTest, BoldParagraph) { ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); - ASSERT_EQ(paragraph->records_[0].color(), text_style.color); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_TRUE(Snapshot()); } @@ -313,7 +313,7 @@ TEST_F(RenderTest, LinebreakParagraph) { ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); - ASSERT_EQ(paragraph->records_[0].color(), text_style.color); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_TRUE(Snapshot()); } @@ -348,7 +348,7 @@ TEST_F(RenderTest, ItalicsParagraph) { ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); - ASSERT_EQ(paragraph->records_[0].color(), text_style.color); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_TRUE(Snapshot()); } From b5d528f2793cc656919f47ae2793d8b88615dc30 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 21 Jun 2017 15:22:27 -0700 Subject: [PATCH 299/364] Implemented early version of text alignment/justification and baselines. Change-Id: Id36a20bb9c392f09813175677776d9367d8ccfc2 --- engine/src/flutter/src/paint_record.cc | 13 ++-- engine/src/flutter/src/paint_record.h | 9 ++- engine/src/flutter/src/paragraph.cc | 65 +++++++++++++++---- engine/src/flutter/src/paragraph.h | 4 +- .../flutter/tests/txt/paragraph_unittests.cc | 3 + 5 files changed, 73 insertions(+), 21 deletions(-) diff --git a/engine/src/flutter/src/paint_record.cc b/engine/src/flutter/src/paint_record.cc index e360e55a43..07322ce05a 100644 --- a/engine/src/flutter/src/paint_record.cc +++ b/engine/src/flutter/src/paint_record.cc @@ -24,22 +24,26 @@ PaintRecord::~PaintRecord() = default; PaintRecord::PaintRecord(TextStyle style, SkPoint offset, sk_sp text, - SkPaint::FontMetrics metrics) + SkPaint::FontMetrics metrics, + int line) : style_(style), offset_(offset), text_(std::move(text)), - metrics_(metrics) {} + metrics_(metrics), + line_(line) {} PaintRecord::PaintRecord(TextStyle style, sk_sp text, - SkPaint::FontMetrics metrics) - : style_(style), text_(std::move(text)), metrics_(metrics) {} + SkPaint::FontMetrics metrics, + int line) + : style_(style), text_(std::move(text)), metrics_(metrics), line_(line) {} PaintRecord::PaintRecord(PaintRecord&& other) { style_ = other.style_; offset_ = other.offset_; text_ = std::move(other.text_); metrics_ = other.metrics_; + line_ = other.line_; } PaintRecord& PaintRecord::operator=(PaintRecord&& other) { @@ -47,6 +51,7 @@ PaintRecord& PaintRecord::operator=(PaintRecord&& other) { offset_ = other.offset_; text_ = std::move(other.text_); metrics_ = other.metrics_; + line_ = other.line_; return *this; } diff --git a/engine/src/flutter/src/paint_record.h b/engine/src/flutter/src/paint_record.h index f9434ed163..cc5b82807a 100644 --- a/engine/src/flutter/src/paint_record.h +++ b/engine/src/flutter/src/paint_record.h @@ -34,11 +34,13 @@ class PaintRecord { PaintRecord(TextStyle style, SkPoint offset, sk_sp text, - SkPaint::FontMetrics metrics); + SkPaint::FontMetrics metrics, + int line); PaintRecord(TextStyle style, sk_sp text, - SkPaint::FontMetrics metrics); + SkPaint::FontMetrics metrics, + int line); PaintRecord(PaintRecord&& other); @@ -54,11 +56,14 @@ class PaintRecord { const TextStyle& style() const { return style_; } + double line() const { return line_; } + private: TextStyle style_; SkPoint offset_; sk_sp text_; SkPaint::FontMetrics metrics_; + int line_; FTL_DISALLOW_COPY_AND_ASSIGN(PaintRecord); }; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index cb2d7d99e7..474632c1b7 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -158,21 +158,22 @@ void Paragraph::Layout(double width, // Reset member variables so Layout still works when called more than once max_intrinsic_width_ = 0.0f; lines_ = 0; - y_ = y_offset; SkScalar x = x_offset; + SkScalar y = y_offset; size_t break_index = 0; double letter_spacing_offset = 0.0f; double word_spacing_offset = 0.0f; double max_line_spacing = 0.0f; double max_descent = 0.0f; double prev_max_descent = 0.0f; + double line_width = 0.0f; std::vector x_queue; - auto flush = [this, &x_queue]() -> void { + auto flush = [this, &x_queue, &y]() -> void { for (size_t i = 0; i < x_queue.size(); ++i) { records_[records_.size() - (x_queue.size() - i)].SetOffset( - SkPoint::Make(x_queue[i], y_)); + SkPoint::Make(x_queue[i], y)); } x_queue.clear(); }; @@ -240,13 +241,18 @@ void Paragraph::Layout(double width, // Subtract word offset to avoid big gap at end of run. This my be // removed depending on the specificatins for word spacing. word_spacing_offset -= run.style.word_spacing; + // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the // color stayed the same. // TODO(garyq): Ensure that the typeface does not change throughout a // run. SkPaint::FontMetrics metrics; paint.getFontMetrics(&metrics); - records_.push_back(PaintRecord{run.style, builder.make(), metrics}); + records_.push_back( + PaintRecord{run.style, builder.make(), metrics, lines_}); + line_width += + std::abs(records_[records_.size() - 1].text()->bounds().fRight + + records_[records_.size() - 1].text()->bounds().fLeft); // Must adjust each line to the largest text in the line, so cannot // directly push the offset property of PaintRecord until line is @@ -254,15 +260,25 @@ void Paragraph::Layout(double width, x_queue.push_back(x); if (max_line_spacing < - (-metrics.fAscent + metrics.fLeading) * run.style.height) - max_line_spacing = - (-metrics.fAscent + metrics.fLeading) * run.style.height; + (-metrics.fAscent + metrics.fLeading) * run.style.height) { + max_line_spacing = lines_ == 0 ? -metrics.fAscent * run.style.height + : (-metrics.fAscent + metrics.fLeading) * + run.style.height; + // Record the alphabetic_baseline_: + if (lines_ == 0) { + alphabetic_baseline_ = -metrics.fAscent * run.style.height; + // TODO(garyq): Properly implement ideographic_baseline_. + ideographic_baseline_ = + ((metrics.fDescent / 2) - metrics.fAscent) * run.style.height; + } + } if (max_descent < metrics.fDescent * run.style.height) max_descent = metrics.fDescent * run.style.height; if (layout_end == next_break) { - y_ += max_line_spacing + prev_max_descent; + y += max_line_spacing + prev_max_descent; prev_max_descent = max_descent; + line_widths_.push_back(line_width); flush(); max_line_spacing = 0.0f; @@ -270,6 +286,7 @@ void Paragraph::Layout(double width, x = 0.0f; letter_spacing_offset = 0.0f; word_spacing_offset = 0.0f; + line_width = 0.0f; // TODO(abarth): Use the line height, which is something like the max // font_size for runs in this line times the paragraph's line height. break_index += 1; @@ -281,8 +298,12 @@ void Paragraph::Layout(double width, layout_start = layout_end; } } - y_ += max_line_spacing; + y += max_line_spacing; flush(); + if (line_width != 0) + line_widths_.push_back(line_width); + + height_ = y + max_descent; } const ParagraphStyle& Paragraph::GetParagraphStyle() const { @@ -290,13 +311,12 @@ const ParagraphStyle& Paragraph::GetParagraphStyle() const { } double Paragraph::GetAlphabeticBaseline() const { - // TODO(garyq): Implement. - return FLT_MAX; + return alphabetic_baseline_; } double Paragraph::GetIdeographicBaseline() const { // TODO(garyq): Implement. - return FLT_MAX; + return ideographic_baseline_; } double Paragraph::GetMaxIntrinsicWidth() const { @@ -309,7 +329,7 @@ double Paragraph::GetMinIntrinsicWidth() const { } double Paragraph::GetHeight() const { - return y_; + return height_; } void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { @@ -320,7 +340,24 @@ void Paragraph::Paint(SkCanvas* canvas, double x, double y) { for (const auto& record : records_) { SkPaint paint; paint.setColor(record.style().color); - const SkPoint& offset = record.offset(); + SkPoint offset = record.offset(); + // TODO(garyq): Fix alignment for paragraphs with multiple styles per line. + switch (paragraph_style_.text_align) { + case TextAlign::left: + break; + case TextAlign::right: { + offset.offset(width_ - line_widths_[record.line()], 0); + break; + } + case TextAlign::center: { + offset.offset((width_ - line_widths_[record.line()]) / 2, 0); + break; + } + case TextAlign::justify: { + // TODO(garyq): implement justify. + break; + } + } canvas->drawTextBlob(record.text(), x + offset.x(), y + offset.y(), paint); PaintDecorations(canvas, x + offset.x(), y + offset.y(), record.style(), record.metrics(), record.text()); diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 1b128481fd..a4e8529e51 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -75,14 +75,16 @@ class Paragraph { StyledRuns runs_; minikin::LineBreaker breaker_; std::vector records_; + std::vector line_widths_; ParagraphStyle paragraph_style_; - SkScalar y_ = 0.0f; // TODO(garyq): Height of the paragraph after Layout(). SkScalar height_ = 0.0f; double width_ = 0.0f; int lines_ = 1; double max_intrinsic_width_ = 0.0f; double min_intrinsic_width_ = 0.0f; + double alphabetic_baseline_ = FLT_MAX; + double ideographic_baseline_ = FLT_MAX; void SetText(std::vector text, StyledRuns runs); diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 941d6cd8c9..463d18e5b0 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -18,6 +18,7 @@ #include "lib/txt/src/font_style.h" #include "lib/txt/src/font_weight.h" #include "lib/txt/src/paragraph.h" +#include "lib/txt/src/text_align.h" #include "lib/txt/tests/txt/utils.h" #include "paragraph_builder.h" #include "render_test.h" @@ -117,6 +118,7 @@ TEST_F(RenderTest, RainbowParagraph) { txt::ParagraphStyle paragraph_style; paragraph_style.max_lines = 2; + paragraph_style.text_align = TextAlign::left; txt::ParagraphBuilder builder(paragraph_style); txt::TextStyle text_style1; @@ -285,6 +287,7 @@ TEST_F(RenderTest, LinebreakParagraph) { txt::ParagraphStyle paragraph_style; paragraph_style.max_lines = 14; + paragraph_style.text_align = TextAlign::center; txt::ParagraphBuilder builder(paragraph_style); txt::TextStyle text_style; From f17cdae74ed79679f58807b33be15e287f248b6d Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 22 Jun 2017 10:22:52 -0700 Subject: [PATCH 300/364] Prevent multiple calls to layout without changing paragraph. Change-Id: I64e81606f095e3029161f5a01623df4c1ccbf5a9 --- engine/src/flutter/src/paragraph.cc | 23 +++++++++++++++++++---- engine/src/flutter/src/paragraph.h | 1 + 2 files changed, 20 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 474632c1b7..e8de72d399 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -112,6 +112,9 @@ Paragraph::Paragraph() = default; Paragraph::~Paragraph() = default; void Paragraph::SetText(std::vector text, StyledRuns runs) { + needs_layout_ = true; + if (text.size() == 0) + return; text_ = std::move(text); runs_ = std::move(runs); @@ -138,6 +141,11 @@ void Paragraph::Layout(double width, const std::string& rootdir, const double x_offset, const double y_offset) { + // Do not allow calling layout multiple times without changing anything. + if (!needs_layout_) + return; + needs_layout_ = false; + width_ = width; breaker_.setLineWidths(0.0f, 0, width); @@ -261,15 +269,15 @@ void Paragraph::Layout(double width, if (max_line_spacing < (-metrics.fAscent + metrics.fLeading) * run.style.height) { - max_line_spacing = lines_ == 0 ? -metrics.fAscent * run.style.height + max_line_spacing = lines_ == 0 ? metrics.fCapHeight * run.style.height : (-metrics.fAscent + metrics.fLeading) * run.style.height; // Record the alphabetic_baseline_: if (lines_ == 0) { - alphabetic_baseline_ = -metrics.fAscent * run.style.height; + alphabetic_baseline_ = metrics.fCapHeight * run.style.height; // TODO(garyq): Properly implement ideographic_baseline_. ideographic_baseline_ = - ((metrics.fDescent / 2) - metrics.fAscent) * run.style.height; + (metrics.fDescent + metrics.fCapHeight) * run.style.height; } } if (max_descent < metrics.fDescent * run.style.height) @@ -333,12 +341,13 @@ double Paragraph::GetHeight() const { } void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { + needs_layout_ = true; paragraph_style_ = style; } void Paragraph::Paint(SkCanvas* canvas, double x, double y) { + SkPaint paint; for (const auto& record : records_) { - SkPaint paint; paint.setColor(record.style().color); SkPoint offset = record.offset(); // TODO(garyq): Fix alignment for paragraphs with multiple styles per line. @@ -362,6 +371,12 @@ void Paragraph::Paint(SkCanvas* canvas, double x, double y) { PaintDecorations(canvas, x + offset.x(), y + offset.y(), record.style(), record.metrics(), record.text()); } + + paint.setStyle(SkPaint::kFill_Style); + paint.setAntiAlias(true); + paint.setStrokeWidth(4); + paint.setColor(0xffFE938C); + canvas->drawCircle(x, y, 3, paint); } void Paragraph::PaintDecorations(SkCanvas* canvas, diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index a4e8529e51..93b28b6f02 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -85,6 +85,7 @@ class Paragraph { double min_intrinsic_width_ = 0.0f; double alphabetic_baseline_ = FLT_MAX; double ideographic_baseline_ = FLT_MAX; + bool needs_layout_ = true; void SetText(std::vector text, StyledRuns runs); From 1d9ea69014dd02b80080ea6d1d645d1f4099b121 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 22 Jun 2017 15:16:05 -0700 Subject: [PATCH 301/364] Begin to move FontCollection to a multi-manager system. Change-Id: Ied69fa2d567f695990a754337bab79dc2f17c6ef --- engine/src/flutter/src/font_collection.cc | 104 ++++++++++-------- engine/src/flutter/src/font_collection.h | 8 +- .../tests/txt/font_collection_unittests.cc | 6 +- 3 files changed, 67 insertions(+), 51 deletions(-) diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index 05b5d6b66f..2983769494 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -29,9 +29,15 @@ namespace txt { FontCollection& FontCollection::GetFontCollection(std::string dir) { + std::vector dirs = {dir}; + return GetFontCollection(std::move(dirs)); +} + +FontCollection& FontCollection::GetFontCollection( + std::vector dirs) { static FontCollection* collection = nullptr; static std::once_flag once; - std::call_once(once, [dir]() { collection = new FontCollection(dir); }); + std::call_once(once, [dirs]() { collection = new FontCollection(dirs); }); return *collection; } @@ -39,28 +45,33 @@ FontCollection& FontCollection::GetDefaultFontCollection() { return GetFontCollection(""); } -FontCollection::FontCollection(std::string dir) { +FontCollection::FontCollection(const std::vector& dirs) { #ifdef DIRECTORY_FONT_MANAGER_AVAILABLE - skia_font_manager_ = dir.length() != 0 - ? SkFontMgr_New_Custom_Directory(dir.c_str()) - : SkFontMgr::RefDefault(); -#else - skia_font_manager_ = SkFontMgr::RefDefault(); + for (std::string dir : dirs) { + if (dir.length() != 0) { + skia_font_managers_.push_back( + SkFontMgr_New_Custom_Directory(dir.c_str())); + } + } #endif + skia_font_managers_.push_back(SkFontMgr::RefDefault()); + + SkString str; + for (sk_sp mgr : skia_font_managers_) { + for (int i = 0; i < mgr->countFamilies(); i++) { + mgr->getFamilyName(i, &str); + family_names_.insert(std::string{str.writable_str()}); + } + } } FontCollection::~FontCollection() = default; std::set FontCollection::GetFamilyNames() { - std::set names; - SkString str; - for (int i = 0; i < skia_font_manager_->countFamilies(); i++) { - skia_font_manager_->getFamilyName(i, &str); - names.insert(std::string{str.writable_str()}); - } - return names; + return family_names_; } +// TODO(garyq): Rework this to use font fallback system. const std::string FontCollection::ProcessFamilyName(const std::string& family) { #ifdef DIRECTORY_FONT_MANAGER_AVAILABLE return family.length() == 0 ? DEFAULT_FAMILY_NAME : family; @@ -77,49 +88,52 @@ const std::string FontCollection::ProcessFamilyName(const std::string& family) { std::shared_ptr FontCollection::GetMinikinFontCollectionForFamily(const std::string& family) { - FTL_DCHECK(skia_font_manager_ != nullptr); + FTL_DCHECK(skia_font_managers_.size() > 0); // Ask Skia to resolve a font style set for a font family name. // FIXME(chinmaygarde): The name "Coolvetica" is hardcoded because CoreText // crashes when passed a null string. This seems to be a bug in Skia as // SkFontMgr explicitly says passing in nullptr gives the default font. + for (sk_sp mgr : skia_font_managers_) { + FTL_DCHECK(mgr != nullptr); + auto font_style_set = mgr->matchFamily(ProcessFamilyName(family).c_str()); + FTL_DCHECK(font_style_set != nullptr); - auto font_style_set = - skia_font_manager_->matchFamily(ProcessFamilyName(family).c_str()); - FTL_DCHECK(font_style_set != nullptr); + std::vector minikin_fonts; - std::vector minikin_fonts; + // Add fonts to the Minikin font family. + for (int i = 0, style_count = font_style_set->count(); i < style_count; + ++i) { + // Create the skia typeface + auto skia_typeface = + sk_ref_sp(font_style_set->createTypeface(i)); + if (skia_typeface == nullptr) { + continue; + } - // Add fonts to the Minikin font family. - for (int i = 0, style_count = font_style_set->count(); i < style_count; ++i) { - // Create the skia typeface - auto skia_typeface = - sk_ref_sp(font_style_set->createTypeface(i)); - if (skia_typeface == nullptr) { - continue; + // Create the minikin font from the skia typeface. + minikin::Font minikin_font( + std::make_shared(skia_typeface), + minikin::FontStyle{skia_typeface->fontStyle().weight(), + skia_typeface->isItalic()}); + + minikin_fonts.emplace_back(std::move(minikin_font)); } - // Create the minikin font from the skia typeface. - minikin::Font minikin_font( - std::make_shared(skia_typeface), - minikin::FontStyle{skia_typeface->fontStyle().weight(), - skia_typeface->isItalic()}); + // Create a Minikin font family. + auto minikin_family = + std::make_shared(std::move(minikin_fonts)); - minikin_fonts.emplace_back(std::move(minikin_font)); + // Create a vector of font families for the Minkin font collection. For now, + // we only have one family in our collection. + std::vector> minikin_families = { + minikin_family, + }; + + // Return the font collection. + return std::make_shared(minikin_families); } - - // Create a Minikin font family. - auto minikin_family = - std::make_shared(std::move(minikin_fonts)); - - // Create a vector of font families for the Minkin font collection. For now, - // we only have one family in our collection. - std::vector> minikin_families = { - minikin_family, - }; - - // Return the font collection. - return std::make_shared(minikin_families); + return nullptr; } } // namespace txt diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index 836e22e8ff..b8a0c8a6de 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -39,6 +39,8 @@ class FontCollection { static FontCollection& GetFontCollection(std::string dir = ""); + static FontCollection& GetFontCollection(std::vector dirs); + std::shared_ptr GetMinikinFontCollectionForFamily( const std::string& family); @@ -46,7 +48,9 @@ class FontCollection { std::set GetFamilyNames(); private: - sk_sp skia_font_manager_; + std::vector> skia_font_managers_; + // Cache the names because GetFamilyNames() can be frequently called. + std::set family_names_; FRIEND_TEST(FontCollection, HasDefaultRegistrations); FRIEND_TEST(FontCollection, GetMinikinFontCollections); @@ -58,7 +62,7 @@ class FontCollection { return DEFAULT_FAMILY_NAME; }; - FontCollection(std::string dir = ""); + FontCollection(const std::vector& dirs); ~FontCollection(); diff --git a/engine/src/flutter/tests/txt/font_collection_unittests.cc b/engine/src/flutter/tests/txt/font_collection_unittests.cc index f501649a1c..7f98cccb30 100644 --- a/engine/src/flutter/tests/txt/font_collection_unittests.cc +++ b/engine/src/flutter/tests/txt/font_collection_unittests.cc @@ -67,7 +67,7 @@ TEST(FontCollection, GetFamilyNames) { txt::FontCollection::GetFontCollection(txt::GetFontDir()) .GetFamilyNames(); - ASSERT_EQ(names.size(), 19ull); + ASSERT_TRUE(names.size() >= 19ull); ASSERT_EQ(names.count("Roboto"), 1ull); ASSERT_EQ(names.count("Homemade Apple"), 1ull); @@ -92,9 +92,7 @@ TEST(FontCollection, GetFamilyNames) { ASSERT_EQ(names.count("Not a real font!"), 0ull); ASSERT_EQ(names.count(""), 0ull); - ASSERT_EQ(names.count("Helvetica"), 0ull); - ASSERT_EQ(names.count("TimesNewRoman"), 0ull); - ASSERT_EQ(names.count("Arial"), 0ull); + ASSERT_EQ(names.count("Another Fake Font"), 0ull); } } // namespace txt From 9935045848599ac9ea2df9be2c19521e1a50d15e Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 23 Jun 2017 12:54:46 -0700 Subject: [PATCH 302/364] Implement initial version of text justification, new tests, and fix bugs with right and center alignment. Change-Id: I3b6a547e1d81c966b82108c02d60aa7181cb0b87 --- engine/src/flutter/src/paint_record.h | 4 +- engine/src/flutter/src/paragraph.cc | 104 +++++++--- engine/src/flutter/src/paragraph.h | 12 +- engine/src/flutter/src/paragraph_style.h | 2 +- engine/src/flutter/src/styled_runs.h | 5 +- .../flutter/tests/txt/paragraph_unittests.cc | 178 +++++++++++++++++- engine/src/flutter/tests/txt/render_test.cc | 2 +- 7 files changed, 264 insertions(+), 43 deletions(-) diff --git a/engine/src/flutter/src/paint_record.h b/engine/src/flutter/src/paint_record.h index cc5b82807a..c34fd9d162 100644 --- a/engine/src/flutter/src/paint_record.h +++ b/engine/src/flutter/src/paint_record.h @@ -56,14 +56,14 @@ class PaintRecord { const TextStyle& style() const { return style_; } - double line() const { return line_; } + size_t line() const { return line_; } private: TextStyle style_; SkPoint offset_; sk_sp text_; SkPaint::FontMetrics metrics_; - int line_; + size_t line_; FTL_DISALLOW_COPY_AND_ASSIGN(PaintRecord); }; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index e8de72d399..549de3af7b 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -24,6 +24,7 @@ #include #include "lib/ftl/logging.h" +#include "lib/txt/libs/minikin/LayoutUtils.h" #include "lib/txt/src/font_collection.h" #include "lib/txt/src/font_skia.h" #include "minikin/LineBreaker.h" @@ -96,7 +97,7 @@ void GetFontAndMinikinPaint(const TextStyle& style, *font = minikin::FontStyle(GetWeight(style), GetItalic(style)); paint->size = style.font_size; paint->letterSpacing = style.letter_spacing; - paint->wordSpacing = style.word_spacing; // Likely not working yet. + paint->wordSpacing = style.word_spacing; // TODO(abarth): word_spacing. } @@ -148,8 +149,9 @@ void Paragraph::Layout(double width, width_ = width; - breaker_.setLineWidths(0.0f, 0, width); + breaker_.setLineWidths(0.0f, 0, width_); AddRunsToLineBreaker(rootdir); + breaker_.setJustified(paragraph_style_.text_align == TextAlign::justify); size_t breaks_count = breaker_.computeBreaks(); const int* breaks = breaker_.getBreaks(); @@ -171,12 +173,12 @@ void Paragraph::Layout(double width, SkScalar y = y_offset; size_t break_index = 0; double letter_spacing_offset = 0.0f; - double word_spacing_offset = 0.0f; double max_line_spacing = 0.0f; double max_descent = 0.0f; double prev_max_descent = 0.0f; double line_width = 0.0f; std::vector x_queue; + size_t character_index = 0; auto flush = [this, &x_queue, &y]() -> void { for (size_t i = 0; i < x_queue.size(); ++i) { @@ -209,28 +211,44 @@ void Paragraph::Layout(double width, int bidiFlags = 0; layout.doLayout(text_.data(), layout_start, layout_end - layout_start, text_.size(), bidiFlags, font, minikin_paint, collection); - const size_t glyph_count = layout.nGlyphs(); size_t blob_start = 0; - // Each word/blob. + // Each blob. + std::vector buffers; + std::vector buffer_sizes; + int word_count = 0; while (blob_start < glyph_count) { const size_t blob_length = GetBlobLength(layout, blob_start); + buffer_sizes.push_back(blob_length); // TODO(abarth): Precompute when we can use allocRunPosH. paint.setTypeface(GetTypefaceForGlyph(layout, blob_start)); - auto buffer = builder.allocRunPos(paint, blob_length); + buffers.push_back(&builder.allocRunPos(paint, blob_length)); letter_spacing_offset += run.style.letter_spacing; // Each Glyph/Letter. + bool whitespace_ended = true; for (size_t blob_index = 0; blob_index < blob_length; ++blob_index) { const size_t glyph_index = blob_start + blob_index; - buffer.glyphs[blob_index] = layout.getGlyphId(glyph_index); + buffers.back()->glyphs[blob_index] = layout.getGlyphId(glyph_index); + // Check if the current Glyph is a whitespace and handle multiple + // whitespaces in a row. + if (minikin::isWordSpace(text_[character_index])) { + // Only increment word_count if it is the first in a series of + // whitespaces. + if (whitespace_ended) + ++word_count; + whitespace_ended = false; + } else { + whitespace_ended = true; + } + ++character_index; const size_t pos_index = 2 * blob_index; - buffer.pos[pos_index] = layout.getX(glyph_index) + - letter_spacing_offset + word_spacing_offset; - buffer.pos[pos_index + 1] = layout.getY(glyph_index); + buffers.back()->pos[pos_index] = + layout.getX(glyph_index) + letter_spacing_offset; + buffers.back()->pos[pos_index + 1] = layout.getY(glyph_index); letter_spacing_offset += run.style.letter_spacing; } @@ -240,22 +258,21 @@ void Paragraph::Layout(double width, // removed depending on the specifications for letter spacing. // letter_spacing_offset -= run.style.letter_spacing; - word_spacing_offset += run.style.word_spacing; - max_intrinsic_width_ += layout.getX(blob_start - 1) + letter_spacing_offset; } - // Subtract word offset to avoid big gap at end of run. This my be - // removed depending on the specificatins for word spacing. - word_spacing_offset -= run.style.word_spacing; - // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the // color stayed the same. // TODO(garyq): Ensure that the typeface does not change throughout a // run. SkPaint::FontMetrics metrics; paint.getFontMetrics(&metrics); + // Apply additional word spacing if the text is justified. + if (paragraph_style_.text_align == TextAlign::justify && + buffer_sizes.size() > 0) { + JustifyLine(buffers, buffer_sizes, word_count, character_index); + } records_.push_back( PaintRecord{run.style, builder.make(), metrics, lines_}); line_width += @@ -293,7 +310,7 @@ void Paragraph::Layout(double width, max_descent = 0.0f; x = 0.0f; letter_spacing_offset = 0.0f; - word_spacing_offset = 0.0f; + word_count = 0; line_width = 0.0f; // TODO(abarth): Use the line height, which is something like the max // font_size for runs in this line times the paragraph's line height. @@ -314,6 +331,45 @@ void Paragraph::Layout(double width, height_ = y + max_descent; } +// Amends the buffers to incorporate justification. +void Paragraph::JustifyLine( + std::vector& buffers, + std::vector& buffer_sizes, + int word_count, + size_t character_index) { + // TODO(garyq): Add letter_spacing_offset back in. It is Temporarily + // removed. + double justify_spacing = + (width_ - breaker_.getWidths()[lines_]) / (word_count - 1); + word_count = 0; + // Set up index to properly access text_ because minikin::isWordSpace() + // takes uint_16 instead of GlyphIDs. + size_t line_character_index = character_index; + for (size_t i = 0; i < buffers.size(); ++i) + line_character_index -= buffer_sizes[i]; + bool whitespace_ended = true; + for (size_t i = 0; i < buffers.size(); ++i) { + for (size_t glyph_index = 0; glyph_index < buffer_sizes[i]; ++glyph_index) { + // Check if the current Glyph is a whitespace and handle multiple + // whitespaces in a row. + if (minikin::isWordSpace(text_[line_character_index])) { + // Only increment word_count and add justification spacing to + // whitespace if it is the first in a series of whitespaces. + if (whitespace_ended) { + ++word_count; + buffers[i]->pos[glyph_index * 2] += justify_spacing * word_count; + } + whitespace_ended = false; + } else { + // Add justification spacing for all non-whitespace glyphs. + buffers[i]->pos[glyph_index * 2] += justify_spacing * word_count; + whitespace_ended = true; + } + ++line_character_index; + } + } +} + const ParagraphStyle& Paragraph::GetParagraphStyle() const { return paragraph_style_; } @@ -346,8 +402,8 @@ void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { } void Paragraph::Paint(SkCanvas* canvas, double x, double y) { - SkPaint paint; for (const auto& record : records_) { + SkPaint paint; paint.setColor(record.style().color); SkPoint offset = record.offset(); // TODO(garyq): Fix alignment for paragraphs with multiple styles per line. @@ -355,15 +411,15 @@ void Paragraph::Paint(SkCanvas* canvas, double x, double y) { case TextAlign::left: break; case TextAlign::right: { - offset.offset(width_ - line_widths_[record.line()], 0); + offset.offset(width_ - breaker_.getWidths()[record.line()], 0); break; } case TextAlign::center: { - offset.offset((width_ - line_widths_[record.line()]) / 2, 0); + offset.offset((width_ - breaker_.getWidths()[record.line()]) / 2, 0); break; } case TextAlign::justify: { - // TODO(garyq): implement justify. + // Justify is performed in the Layout(). break; } } @@ -371,12 +427,6 @@ void Paragraph::Paint(SkCanvas* canvas, double x, double y) { PaintDecorations(canvas, x + offset.x(), y + offset.y(), record.style(), record.metrics(), record.text()); } - - paint.setStyle(SkPaint::kFill_Style); - paint.setAntiAlias(true); - paint.setStrokeWidth(4); - paint.setColor(0xffFE938C); - canvas->drawCircle(x, y, 3, paint); } void Paragraph::PaintDecorations(SkCanvas* canvas, diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 93b28b6f02..f71b16be11 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -68,7 +68,10 @@ class Paragraph { FRIEND_TEST(RenderTest, RainbowParagraph); FRIEND_TEST(RenderTest, DefaultStyleParagraph); FRIEND_TEST(RenderTest, BoldParagraph); - FRIEND_TEST(RenderTest, LinebreakParagraph); + FRIEND_TEST(RenderTest, LeftAlignParagraph); + FRIEND_TEST(RenderTest, RightAlignParagraph); + FRIEND_TEST(RenderTest, CenterAlignParagraph); + FRIEND_TEST(RenderTest, JustifyAlignParagraph); FRIEND_TEST(RenderTest, ItalicsParagraph); std::vector text_; @@ -80,7 +83,7 @@ class Paragraph { // TODO(garyq): Height of the paragraph after Layout(). SkScalar height_ = 0.0f; double width_ = 0.0f; - int lines_ = 1; + size_t lines_ = 0; double max_intrinsic_width_ = 0.0f; double min_intrinsic_width_ = 0.0f; double alphabetic_baseline_ = FLT_MAX; @@ -93,6 +96,11 @@ class Paragraph { void AddRunsToLineBreaker(const std::string& rootdir = ""); + void JustifyLine(std::vector& buffers, + std::vector& buffer_sizes, + int word_count, + size_t character_index); + void PaintDecorations(SkCanvas* canvas, double x, double y, diff --git a/engine/src/flutter/src/paragraph_style.h b/engine/src/flutter/src/paragraph_style.h index e1730287a6..45f1dd745d 100644 --- a/engine/src/flutter/src/paragraph_style.h +++ b/engine/src/flutter/src/paragraph_style.h @@ -32,7 +32,7 @@ class ParagraphStyle { FontStyle font_style = FontStyle::normal; std::string font_family = ""; double font_size = 14; - int max_lines = 1; + size_t max_lines = 1; double line_height = 1.0; std::string ellipsis; }; diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index 8b757658a4..4942b9cc20 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -60,7 +60,10 @@ class StyledRuns { FRIEND_TEST(RenderTest, RainbowParagraph); FRIEND_TEST(RenderTest, DefaultStyleParagraph); FRIEND_TEST(RenderTest, BoldParagraph); - FRIEND_TEST(RenderTest, LinebreakParagraph); + FRIEND_TEST(RenderTest, LeftAlignParagraph); + FRIEND_TEST(RenderTest, RightAlignParagraph); + FRIEND_TEST(RenderTest, CenterAlignParagraph); + FRIEND_TEST(RenderTest, JustifyAlignParagraph); FRIEND_TEST(RenderTest, ItalicsParagraph); struct IndexedRun { diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 463d18e5b0..e18cc23a78 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -252,28 +252,132 @@ TEST_F(RenderTest, BoldParagraph) { ASSERT_TRUE(Snapshot()); } -TEST_F(RenderTest, LinebreakParagraph) { +TEST_F(RenderTest, LeftAlignParagraph) { const char* text = "This is a very long sentence to test if the text will properly wrap " "around and go to the next line. Sometimes, short sentence. Longer " - "sentences are okay too because they are nessecary. Very short." + "sentences are okay too because they are nessecary. Very short. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 14; + paragraph_style.text_align = TextAlign::left; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.font_size = 26; + text_style.letter_spacing = 1; + text_style.word_spacing = 5; + text_style.color = SK_ColorBLACK; + text_style.height = 1.15; + text_style.decoration = txt::TextDecoration(0x1); + text_style.decoration_color = SK_ColorBLACK; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth() - 100, txt::GetFontDir()); + + paragraph->Paint(GetCanvas(), 0, 0); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_TRUE(Snapshot()); +} + +TEST_F(RenderTest, RightAlignParagraph) { + const char* text = "This is a very long sentence to test if the text will properly wrap " "around and go to the next line. Sometimes, short sentence. Longer " - "sentences are okay too because they are nessecary. Very short." + "sentences are okay too because they are nessecary. Very short. " "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " - "mollit anim id est laborum." + "mollit anim id est laborum. " "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " - "mollit anim id est laborum." + "mollit anim id est laborum."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 14; + paragraph_style.text_align = TextAlign::right; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.font_size = 26; + text_style.letter_spacing = 1; + text_style.word_spacing = 5; + text_style.color = SK_ColorBLACK; + text_style.height = 1.15; + text_style.decoration = txt::TextDecoration(0x1); + text_style.decoration_color = SK_ColorBLACK; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth() - 100, txt::GetFontDir()); + + paragraph->Paint(GetCanvas(), 0, 0); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_TRUE(Snapshot()); +} + +TEST_F(RenderTest, CenterAlignParagraph) { + const char* text = + "This is a very long sentence to test if the text will properly wrap " + "around and go to the next line. Sometimes, short sentence. Longer " + "sentences are okay too because they are nessecary. Very short. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum. " "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " @@ -292,8 +396,8 @@ TEST_F(RenderTest, LinebreakParagraph) { txt::TextStyle text_style; text_style.font_size = 26; - // Letter spacing not yet implemented - text_style.letter_spacing = 0; + text_style.letter_spacing = 1; + text_style.word_spacing = 5; text_style.color = SK_ColorBLACK; text_style.height = 1.15; text_style.decoration = txt::TextDecoration(0x1); @@ -307,8 +411,64 @@ TEST_F(RenderTest, LinebreakParagraph) { auto paragraph = builder.Build(); paragraph->Layout(GetTestCanvasWidth() - 100, txt::GetFontDir()); - paragraph->Paint(GetCanvas(), 0, 30.0); + paragraph->Paint(GetCanvas(), 0, 0); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_TRUE(Snapshot()); +} +TEST_F(RenderTest, JustifyAlignParagraph) { + const char* text = + "This is a very long sentence to test if the text will properly wrap " + "around and go to the next line. Sometimes, short sentence. Longer " + "sentences are okay too because they are nessecary. Very short. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 14; + paragraph_style.text_align = TextAlign::justify; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.font_size = 26; + text_style.letter_spacing = 1; + text_style.word_spacing = 5; + text_style.color = SK_ColorBLACK; + text_style.height = 1.15; + text_style.decoration = txt::TextDecoration(0x1); + text_style.decoration_color = SK_ColorBLACK; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth() - 100, txt::GetFontDir()); + + paragraph->Paint(GetCanvas(), 0, 0); ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); @@ -321,7 +481,7 @@ TEST_F(RenderTest, LinebreakParagraph) { } TEST_F(RenderTest, ItalicsParagraph) { - const char* text = "I am Italicized!"; + const char* text = "I am Italicized! "; auto icu_text = icu::UnicodeString::fromUTF8(text); std::u16string u16_text(icu_text.getBuffer(), icu_text.getBuffer() + icu_text.length()); diff --git a/engine/src/flutter/tests/txt/render_test.cc b/engine/src/flutter/tests/txt/render_test.cc index 68b45e98ac..4b87a06bbb 100644 --- a/engine/src/flutter/tests/txt/render_test.cc +++ b/engine/src/flutter/tests/txt/render_test.cc @@ -47,7 +47,7 @@ bool RenderTest::Snapshot() { } size_t RenderTest::GetTestCanvasWidth() const { - return 800; + return 1000; } size_t RenderTest::GetTestCanvasHeight() const { From adcdcc19a8d71acacc07e04ea2a14be580dd5684 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 26 Jun 2017 09:39:09 -0700 Subject: [PATCH 303/364] Reorganize text alignment code location and add unit tests. Change-Id: I3ccfb03230050c4c0f8ae4b7d0c73bf6f3b685ae --- engine/src/flutter/src/paragraph.cc | 53 +++--- engine/src/flutter/src/text_style.cc | 2 +- engine/src/flutter/src/text_style.h | 2 +- .../flutter/tests/txt/paragraph_unittests.cc | 175 ++++++++++++++++-- 4 files changed, 195 insertions(+), 37 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 549de3af7b..dff8b5f449 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -180,10 +180,36 @@ void Paragraph::Layout(double width, std::vector x_queue; size_t character_index = 0; - auto flush = [this, &x_queue, &y]() -> void { + auto postprocess_line = [this, &x_queue, &y]() -> void { + size_t record_index = 0; for (size_t i = 0; i < x_queue.size(); ++i) { - records_[records_.size() - (x_queue.size() - i)].SetOffset( - SkPoint::Make(x_queue[i], y)); + record_index = records_.size() - (x_queue.size() - i); + records_[record_index].SetOffset(SkPoint::Make(x_queue[i], y)); + // TODO(garyq): Fix alignment for paragraphs with multiple styles per + // line. + switch (paragraph_style_.text_align) { + case TextAlign::left: + break; + case TextAlign::right: { + records_[record_index].SetOffset(SkPoint::Make( + records_[record_index].offset().x() + width_ - + breaker_.getWidths()[records_[record_index].line()], + records_[record_index].offset().y())); + break; + } + case TextAlign::center: { + records_[record_index].SetOffset(SkPoint::Make( + records_[record_index].offset().x() + + (width_ - + breaker_.getWidths()[records_[record_index].line()]) / + 2, + records_[record_index].offset().y())); + break; + } + case TextAlign::justify: { + break; + } + } } x_queue.clear(); }; @@ -304,7 +330,7 @@ void Paragraph::Layout(double width, y += max_line_spacing + prev_max_descent; prev_max_descent = max_descent; line_widths_.push_back(line_width); - flush(); + postprocess_line(); max_line_spacing = 0.0f; max_descent = 0.0f; @@ -324,7 +350,7 @@ void Paragraph::Layout(double width, } } y += max_line_spacing; - flush(); + postprocess_line(); if (line_width != 0) line_widths_.push_back(line_width); @@ -406,23 +432,6 @@ void Paragraph::Paint(SkCanvas* canvas, double x, double y) { SkPaint paint; paint.setColor(record.style().color); SkPoint offset = record.offset(); - // TODO(garyq): Fix alignment for paragraphs with multiple styles per line. - switch (paragraph_style_.text_align) { - case TextAlign::left: - break; - case TextAlign::right: { - offset.offset(width_ - breaker_.getWidths()[record.line()], 0); - break; - } - case TextAlign::center: { - offset.offset((width_ - breaker_.getWidths()[record.line()]) / 2, 0); - break; - } - case TextAlign::justify: { - // Justify is performed in the Layout(). - break; - } - } canvas->drawTextBlob(record.text(), x + offset.x(), y + offset.y(), paint); PaintDecorations(canvas, x + offset.x(), y + offset.y(), record.style(), record.metrics(), record.text()); diff --git a/engine/src/flutter/src/text_style.cc b/engine/src/flutter/src/text_style.cc index bacb9a55fe..692176c687 100644 --- a/engine/src/flutter/src/text_style.cc +++ b/engine/src/flutter/src/text_style.cc @@ -21,7 +21,7 @@ namespace txt { -bool TextStyle::equals(TextStyle& other) { +bool TextStyle::equals(const TextStyle& other) const { if (color != other.color) return false; if (font_weight != other.font_weight) diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index 23c2043b0a..7692c7a58c 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -43,7 +43,7 @@ class TextStyle { double word_spacing = 0.0; double height = 1.0; - bool equals(TextStyle& other); + bool equals(const TextStyle& other) const; }; } // namespace txt diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index e18cc23a78..d93ea32e3e 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -225,7 +225,6 @@ TEST_F(RenderTest, BoldParagraph) { txt::TextStyle text_style; text_style.font_size = 60; - // Letter spacing not yet implemented text_style.letter_spacing = 10; text_style.font_weight = txt::FontWeight::w700; text_style.fake_bold = true; @@ -285,8 +284,8 @@ TEST_F(RenderTest, LeftAlignParagraph) { text_style.letter_spacing = 1; text_style.word_spacing = 5; text_style.color = SK_ColorBLACK; - text_style.height = 1.15; - text_style.decoration = txt::TextDecoration(0x1); + text_style.height = 1; + text_style.decoration = txt::TextDecoration(0x0); text_style.decoration_color = SK_ColorBLACK; builder.PushStyle(text_style); @@ -305,7 +304,36 @@ TEST_F(RenderTest, LeftAlignParagraph) { ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); - ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); + double expected_y = 18.484375; + + ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().x(), 0); + + ASSERT_TRUE(paragraph->records_[1].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().x(), 0); + + ASSERT_TRUE(paragraph->records_[2].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 0); + + ASSERT_TRUE(paragraph->records_[3].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().y(), expected_y); + expected_y += 30.46875 * 10; + ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 0); + + ASSERT_TRUE(paragraph->records_[13].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[13].offset().y(), expected_y); + ASSERT_DOUBLE_EQ(paragraph->records_[13].offset().x(), 0); + + ASSERT_EQ(paragraph_style.text_align, + paragraph->GetParagraphStyle().text_align); + ASSERT_TRUE(Snapshot()); } @@ -342,8 +370,8 @@ TEST_F(RenderTest, RightAlignParagraph) { text_style.letter_spacing = 1; text_style.word_spacing = 5; text_style.color = SK_ColorBLACK; - text_style.height = 1.15; - text_style.decoration = txt::TextDecoration(0x1); + text_style.height = 1; + text_style.decoration = txt::TextDecoration(0x0); text_style.decoration_color = SK_ColorBLACK; builder.PushStyle(text_style); @@ -362,7 +390,51 @@ TEST_F(RenderTest, RightAlignParagraph) { ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); - ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); + double expected_y = 18.484375; + + ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_DOUBLE_EQ( + paragraph->records_[0].offset().x(), + paragraph->width_ - + paragraph->breaker_.getWidths()[paragraph->records_[0].line()]); + + ASSERT_TRUE(paragraph->records_[1].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_DOUBLE_EQ( + paragraph->records_[1].offset().x(), + paragraph->width_ - + paragraph->breaker_.getWidths()[paragraph->records_[1].line()]); + + ASSERT_TRUE(paragraph->records_[2].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_DOUBLE_EQ( + paragraph->records_[2].offset().x(), + paragraph->width_ - + paragraph->breaker_.getWidths()[paragraph->records_[2].line()]); + + ASSERT_TRUE(paragraph->records_[3].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().y(), expected_y); + expected_y += 30.46875 * 10; + ASSERT_DOUBLE_EQ( + paragraph->records_[3].offset().x(), + paragraph->width_ - + paragraph->breaker_.getWidths()[paragraph->records_[3].line()]); + + ASSERT_TRUE(paragraph->records_[13].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[13].offset().y(), expected_y); + ASSERT_DOUBLE_EQ( + paragraph->records_[13].offset().x(), + paragraph->width_ - + paragraph->breaker_.getWidths()[paragraph->records_[13].line()]); + + ASSERT_EQ(paragraph_style.text_align, + paragraph->GetParagraphStyle().text_align); + ASSERT_TRUE(Snapshot()); } @@ -399,8 +471,8 @@ TEST_F(RenderTest, CenterAlignParagraph) { text_style.letter_spacing = 1; text_style.word_spacing = 5; text_style.color = SK_ColorBLACK; - text_style.height = 1.15; - text_style.decoration = txt::TextDecoration(0x1); + text_style.height = 1; + text_style.decoration = txt::TextDecoration(0x0); text_style.decoration_color = SK_ColorBLACK; builder.PushStyle(text_style); @@ -419,7 +491,55 @@ TEST_F(RenderTest, CenterAlignParagraph) { ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); - ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); + double expected_y = 18.484375; + + ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_DOUBLE_EQ( + paragraph->records_[0].offset().x(), + (paragraph->width_ - + paragraph->breaker_.getWidths()[paragraph->records_[0].line()]) / + 2); + + ASSERT_TRUE(paragraph->records_[1].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_DOUBLE_EQ( + paragraph->records_[1].offset().x(), + (paragraph->width_ - + paragraph->breaker_.getWidths()[paragraph->records_[1].line()]) / + 2); + + ASSERT_TRUE(paragraph->records_[2].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_EQ(paragraph->records_[2].offset().x(), + (paragraph->width_ - + paragraph->breaker_.getWidths()[paragraph->records_[2].line()]) / + 2); + + ASSERT_TRUE(paragraph->records_[3].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().y(), expected_y); + expected_y += 30.46875 * 10; + ASSERT_DOUBLE_EQ( + paragraph->records_[3].offset().x(), + (paragraph->width_ - + paragraph->breaker_.getWidths()[paragraph->records_[3].line()]) / + 2); + + ASSERT_TRUE(paragraph->records_[13].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[13].offset().y(), expected_y); + ASSERT_DOUBLE_EQ( + paragraph->records_[13].offset().x(), + (paragraph->width_ - + paragraph->breaker_.getWidths()[paragraph->records_[13].line()]) / + 2); + + ASSERT_EQ(paragraph_style.text_align, + paragraph->GetParagraphStyle().text_align); + ASSERT_TRUE(Snapshot()); } @@ -456,8 +576,8 @@ TEST_F(RenderTest, JustifyAlignParagraph) { text_style.letter_spacing = 1; text_style.word_spacing = 5; text_style.color = SK_ColorBLACK; - text_style.height = 1.15; - text_style.decoration = txt::TextDecoration(0x1); + text_style.height = 1; + text_style.decoration = txt::TextDecoration(0x0); text_style.decoration_color = SK_ColorBLACK; builder.PushStyle(text_style); @@ -476,7 +596,36 @@ TEST_F(RenderTest, JustifyAlignParagraph) { ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); - ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); + double expected_y = 18.484375; + + ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().x(), 0); + + ASSERT_TRUE(paragraph->records_[1].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().x(), 0); + + ASSERT_TRUE(paragraph->records_[2].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().y(), expected_y); + expected_y += 30.46875; + ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 0); + + ASSERT_TRUE(paragraph->records_[3].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().y(), expected_y); + expected_y += 30.46875 * 10; + ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 0); + + ASSERT_TRUE(paragraph->records_[13].style().equals(text_style)); + ASSERT_DOUBLE_EQ(paragraph->records_[13].offset().y(), expected_y); + ASSERT_DOUBLE_EQ(paragraph->records_[13].offset().x(), 0); + + ASSERT_EQ(paragraph_style.text_align, + paragraph->GetParagraphStyle().text_align); + ASSERT_TRUE(Snapshot()); } From ea45f66608c633fd9777b3db850aada81f9598aa Mon Sep 17 00:00:00 2001 From: George Kulakowski Date: Wed, 28 Jun 2017 09:45:52 -0700 Subject: [PATCH 304/364] Add PATENTS file Change-Id: Ie25d2b4caa6a805ce76a288b41804700d7d37c5a --- engine/src/flutter/PATENTS | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 engine/src/flutter/PATENTS diff --git a/engine/src/flutter/PATENTS b/engine/src/flutter/PATENTS new file mode 100644 index 0000000000..2746e78d1b --- /dev/null +++ b/engine/src/flutter/PATENTS @@ -0,0 +1,22 @@ +Additional IP Rights Grant (Patents) + +"This implementation" means the copyrightable works distributed by +Google as part of the Fuchsia project. + +Google hereby grants to you a perpetual, worldwide, non-exclusive, +no-charge, royalty-free, irrevocable (except as stated in this +section) patent license to make, have made, use, offer to sell, sell, +import, transfer, and otherwise run, modify and propagate the contents +of this implementation of Fuchsia, where such license applies only to +those patent claims, both currently owned by Google and acquired in +the future, licensable by Google that are necessarily infringed by +this implementation. This grant does not include claims that would be +infringed only as a consequence of further modification of this +implementation. If you or your agent or exclusive licensee institute +or order or agree to the institution of patent litigation or any other +patent enforcement activity against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that this +implementation of Fuchsia constitutes direct or contributory patent +infringement, or inducement of patent infringement, then any patent +rights granted to you under this License for this implementation of +Fuchsia shall terminate as of the date such litigation is filed. From f716e8115c46def41ff7bfbd6420e119abfb2520 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 27 Jun 2017 17:14:01 -0700 Subject: [PATCH 305/364] Add benchmarking. Change-Id: I92b8d1d27d5d6b79a831853446e83086fa56a133 --- engine/src/flutter/benchmarks/BUILD.gn | 45 ++++ .../benchmarks/font_collection_benchmarks.cc | 49 +++++ .../benchmarks/paragraph_benchmarks.cc | 116 +++++++++++ .../paragraph_builder_benchmarks.cc | 194 ++++++++++++++++++ .../benchmarks/txt_run_all_benchmarks.cc | 41 ++++ engine/src/flutter/benchmarks/utils.cc | 43 ++++ engine/src/flutter/benchmarks/utils.h | 31 +++ engine/src/flutter/src/paragraph.cc | 3 +- engine/src/flutter/src/paragraph.h | 1 + engine/src/flutter/tests/txt/utils.cc | 8 +- engine/src/flutter/tests/txt/utils.h | 2 +- 11 files changed, 527 insertions(+), 6 deletions(-) create mode 100644 engine/src/flutter/benchmarks/BUILD.gn create mode 100644 engine/src/flutter/benchmarks/font_collection_benchmarks.cc create mode 100644 engine/src/flutter/benchmarks/paragraph_benchmarks.cc create mode 100644 engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc create mode 100644 engine/src/flutter/benchmarks/txt_run_all_benchmarks.cc create mode 100644 engine/src/flutter/benchmarks/utils.cc create mode 100644 engine/src/flutter/benchmarks/utils.h diff --git a/engine/src/flutter/benchmarks/BUILD.gn b/engine/src/flutter/benchmarks/BUILD.gn new file mode 100644 index 0000000000..7a3f14d7d7 --- /dev/null +++ b/engine/src/flutter/benchmarks/BUILD.gn @@ -0,0 +1,45 @@ +# Copyright 2017 Google, Inc. +# +# 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. + +executable("benchmarks") { + output_name = "txt_benchmarks" + + include_dirs = [ + "//lib/txt/src", + "//lib/txt/include", + "//third_party/icu/source", + ] + + sources = [ + "font_collection_benchmarks.cc", + "paragraph_benchmarks.cc", + "paragraph_builder_benchmarks.cc", + "txt_run_all_benchmarks.cc", + "utils.cc", + "utils.h", + ] + + deps = [ + "//dart/runtime:libdart_jit", # Logging + "//flutter/fml", + "//lib/txt/shims", + "//lib/txt", + "//build/secondary/testing/benchmark", + "//third_party/skia", + "//third_party/harfbuzz", + "//lib/txt/libs/minikin", + ] + + +} diff --git a/engine/src/flutter/benchmarks/font_collection_benchmarks.cc b/engine/src/flutter/benchmarks/font_collection_benchmarks.cc new file mode 100644 index 0000000000..10751e324f --- /dev/null +++ b/engine/src/flutter/benchmarks/font_collection_benchmarks.cc @@ -0,0 +1,49 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "third_party/benchmark/include/benchmark/benchmark_api.h" + +#include "lib/ftl/command_line.h" +#include "lib/ftl/logging.h" +#include "lib/txt/src/font_collection.h" +#include "utils.h" + +namespace txt { + +// Include this fake bench first because the first benchmark produces +// inconsistent times. +static void BM_FAKE_BENCHMARK(benchmark::State& state) { + while (state.KeepRunning()) { + continue; + } +} +BENCHMARK(BM_FAKE_BENCHMARK); + +static void BM_FontCollectionInit(benchmark::State& state) { + while (state.KeepRunning()) { + FontCollection::GetFontCollection(txt::GetFontDir()); + } +} +BENCHMARK(BM_FontCollectionInit); + +static void BM_FontCollectionGetMinikinFontCollectionForFamily(benchmark::State& state) { + while (state.KeepRunning()) { + FontCollection::GetFontCollection(txt::GetFontDir()).GetMinikinFontCollectionForFamily("Roboto"); + } +} +BENCHMARK(BM_FontCollectionGetMinikinFontCollectionForFamily); + +} // namespace txt diff --git a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc new file mode 100644 index 0000000000..34d44ad557 --- /dev/null +++ b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc @@ -0,0 +1,116 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "third_party/benchmark/include/benchmark/benchmark_api.h" + +#include "lib/ftl/command_line.h" +#include "lib/ftl/logging.h" +#include "lib/txt/src/font_style.h" +#include "lib/txt/src/font_weight.h" +#include "lib/txt/src/paragraph.h" +#include "lib/txt/src/paragraph_builder.h" +#include "lib/txt/src/text_align.h" +#include "third_party/icu/source/common/unicode/unistr.h" +#include "third_party/skia/include/core/SkColor.h" +#include "utils.h" + +namespace txt { + +static void BM_ParagraphShortLayout(benchmark::State& state) { + const char* text = "Hello World"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + while (state.KeepRunning()) { + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + auto paragraph = builder.Build(); + paragraph->Layout(300, txt::GetFontDir(), true); + } +} +BENCHMARK(BM_ParagraphShortLayout); + +static void BM_ParagraphLongLayout(benchmark::State& state) { + const char* text = + "This is a very long sentence to test if the text will properly wrap " + "around and go to the next line. Sometimes, short sentence. Longer " + "sentences are okay too because they are necessary. Very short. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + auto paragraph = builder.Build(); + while (state.KeepRunning()) { + paragraph->Layout(300, txt::GetFontDir(), true); + } +} +BENCHMARK(BM_ParagraphLongLayout); + +static void BM_ParagraphManyStylesLayout(benchmark::State& state) { + const char* text = "A short sentence. "; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + while (state.KeepRunning()) { + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + + for (int i = 0; i < 100; ++i) { + builder.PushStyle(text_style); + builder.AddText(u16_text); + } + auto paragraph = builder.Build(); + paragraph->Layout(300, txt::GetFontDir(), true); + } +} +BENCHMARK(BM_ParagraphManyStylesLayout); + +} // namespace txt diff --git a/engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc new file mode 100644 index 0000000000..88da483736 --- /dev/null +++ b/engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc @@ -0,0 +1,194 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "third_party/benchmark/include/benchmark/benchmark_api.h" + +#include "lib/ftl/logging.h" +#include "lib/txt/src/font_style.h" +#include "lib/txt/src/font_weight.h" +#include "lib/txt/src/paragraph.h" +#include "lib/txt/src/paragraph_builder.h" +#include "lib/txt/src/text_align.h" +#include "third_party/icu/source/common/unicode/unistr.h" +#include "third_party/skia/include/core/SkColor.h" + +namespace txt { + +static void BM_ParagraphBuilderConstruction(benchmark::State& state) { + txt::ParagraphStyle paragraph_style; + while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); + } +} +BENCHMARK(BM_ParagraphBuilderConstruction); + +static void BM_ParagraphBuilderPushStyle(benchmark::State& state) { + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + while (state.KeepRunning()) { + builder.PushStyle(text_style); + } +} +BENCHMARK(BM_ParagraphBuilderPushStyle); + +static void BM_ParagraphBuilderPushPop(benchmark::State& state) { + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + while (state.KeepRunning()) { + builder.PushStyle(text_style); + builder.Pop(); + } +} +BENCHMARK(BM_ParagraphBuilderPushPop); + +static void BM_ParagraphBuilderAddTextString(benchmark::State& state) { + std::string text = "Hello World"; + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + while (state.KeepRunning()) { + builder.AddText(text); + } +} +BENCHMARK(BM_ParagraphBuilderAddTextString); + +static void BM_ParagraphBuilderAddTextChar(benchmark::State& state) { + const char* text = "Hello World"; + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + while (state.KeepRunning()) { + builder.AddText(text); + } +} +BENCHMARK(BM_ParagraphBuilderAddTextChar); + +static void BM_ParagraphBuilderAddTextU16stringShort(benchmark::State& state) { + const char* text = "H"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + while (state.KeepRunning()) { + builder.AddText(u16_text); + } +} +BENCHMARK(BM_ParagraphBuilderAddTextU16stringShort); + +static void BM_ParagraphBuilderAddTextU16stringLong(benchmark::State& state) { + const char* text = + "This is a very long sentence to test if the text will properly wrap " + "around and go to the next line. Sometimes, short sentence. Longer " + "sentences are okay too because they are necessary. Very short. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + while (state.KeepRunning()) { + builder.AddText(u16_text); + } +} +BENCHMARK(BM_ParagraphBuilderAddTextU16stringLong); + +static void BM_ParagraphBuilderShortParagraphConstruct( + benchmark::State& state) { + const char* text = "Hello World"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + + while (state.KeepRunning()) { + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + auto paragraph = builder.Build(); + } +} +BENCHMARK(BM_ParagraphBuilderShortParagraphConstruct); + +static void BM_ParagraphBuilderLongParagraphConstruct(benchmark::State& state) { + const char* text = + "This is a very long sentence to test if the text will properly wrap " + "around and go to the next line. Sometimes, short sentence. Longer " + "sentences are okay too because they are necessary. Very short. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + txt::ParagraphBuilder builder(paragraph_style); + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + + while (state.KeepRunning()) { + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + auto paragraph = builder.Build(); + } +} +BENCHMARK(BM_ParagraphBuilderLongParagraphConstruct); + +} // namespace txt diff --git a/engine/src/flutter/benchmarks/txt_run_all_benchmarks.cc b/engine/src/flutter/benchmarks/txt_run_all_benchmarks.cc new file mode 100644 index 0000000000..cc5bfc3645 --- /dev/null +++ b/engine/src/flutter/benchmarks/txt_run_all_benchmarks.cc @@ -0,0 +1,41 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "third_party/benchmark/include/benchmark/benchmark_api.h" + +#include "flutter/fml/icu_util.h" +#include "lib/ftl/logging.h" +#include "utils.h" + +// We will use a custom main to allow custom font directories for consistency. +int main(int argc, char** argv) { + ::benchmark::Initialize(&argc, argv); + ftl::CommandLine cmd = ftl::CommandLineFromArgcArgv(argc, argv); + txt::SetCommandLine(cmd); + std::string dir = txt::GetCommandLineForProcess().GetOptionValueWithDefault( + "font-directory", ""); + txt::SetFontDir(dir); + if (txt::GetFontDir().length() <= 0) { + FTL_LOG(ERROR) << "Font directory must be specified with " + "--font-directoy=\"\" to run this test."; + return EXIT_FAILURE; + } + FTL_DCHECK(txt::GetFontDir().length() > 0); + + fml::icu::InitializeICU(); + + ::benchmark::RunSpecifiedBenchmarks(); +} \ No newline at end of file diff --git a/engine/src/flutter/benchmarks/utils.cc b/engine/src/flutter/benchmarks/utils.cc new file mode 100644 index 0000000000..6ec90c2a5c --- /dev/null +++ b/engine/src/flutter/benchmarks/utils.cc @@ -0,0 +1,43 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 + +#include "lib/ftl/command_line.h" +#include "lib/txt/tests/txt/utils.h" + +namespace txt { + +static std::string gFontDir; +static ftl::CommandLine gCommandLine; + +const std::string GetFontDir() { + return gFontDir; +} + +void SetFontDir(const std::string& dir) { + gFontDir = dir; +} + +const ftl::CommandLine& GetCommandLineForProcess() { + return gCommandLine; +} + +void SetCommandLine(ftl::CommandLine cmd) { + gCommandLine = std::move(cmd); +} + +} // namespace txt diff --git a/engine/src/flutter/benchmarks/utils.h b/engine/src/flutter/benchmarks/utils.h new file mode 100644 index 0000000000..5b6db12718 --- /dev/null +++ b/engine/src/flutter/benchmarks/utils.h @@ -0,0 +1,31 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 + +#include "lib/ftl/command_line.h" + +namespace txt { + +const std::string GetFontDir(); + +void SetFontDir(const std::string& dir); + +const ftl::CommandLine& GetCommandLineForProcess(); + +void SetCommandLine(ftl::CommandLine cmd); + +} // namespace txt diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index dff8b5f449..0dda95b66a 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -140,10 +140,11 @@ void Paragraph::AddRunsToLineBreaker(const std::string& rootdir) { void Paragraph::Layout(double width, const std::string& rootdir, + bool force, const double x_offset, const double y_offset) { // Do not allow calling layout multiple times without changing anything. - if (!needs_layout_) + if (!needs_layout_ && !force) return; needs_layout_ = false; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index f71b16be11..b4b90a4ee9 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -40,6 +40,7 @@ class Paragraph { void Layout(double width, const std::string& rootdir = "", + bool force = false, const double x_offset = 0.0, const double y_offset = 0.0); diff --git a/engine/src/flutter/tests/txt/utils.cc b/engine/src/flutter/tests/txt/utils.cc index 3f853b8a92..6ec90c2a5c 100644 --- a/engine/src/flutter/tests/txt/utils.cc +++ b/engine/src/flutter/tests/txt/utils.cc @@ -21,15 +21,15 @@ namespace txt { -static std::string gFontdir; +static std::string gFontDir; static ftl::CommandLine gCommandLine; const std::string GetFontDir() { - return gFontdir; + return gFontDir; } -void SetFontDir(std::string& dir) { - gFontdir = dir; +void SetFontDir(const std::string& dir) { + gFontDir = dir; } const ftl::CommandLine& GetCommandLineForProcess() { diff --git a/engine/src/flutter/tests/txt/utils.h b/engine/src/flutter/tests/txt/utils.h index ed42b82073..5b6db12718 100644 --- a/engine/src/flutter/tests/txt/utils.h +++ b/engine/src/flutter/tests/txt/utils.h @@ -22,7 +22,7 @@ namespace txt { const std::string GetFontDir(); -void SetFontDir(std::string& dir); +void SetFontDir(const std::string& dir); const ftl::CommandLine& GetCommandLineForProcess(); From 704aa0d2bf1f9b6d0bba9ef23349080f7720966c Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 28 Jun 2017 11:30:32 -0700 Subject: [PATCH 306/364] Only obtain new font if font has changed. Change-Id: I9a6316854e13ff5f01a34bbfca8750d223a90af8 --- .../benchmarks/font_collection_benchmarks.cc | 6 ++++-- engine/src/flutter/src/paragraph.cc | 14 ++++++++++---- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/engine/src/flutter/benchmarks/font_collection_benchmarks.cc b/engine/src/flutter/benchmarks/font_collection_benchmarks.cc index 10751e324f..99eb26eecf 100644 --- a/engine/src/flutter/benchmarks/font_collection_benchmarks.cc +++ b/engine/src/flutter/benchmarks/font_collection_benchmarks.cc @@ -39,9 +39,11 @@ static void BM_FontCollectionInit(benchmark::State& state) { } BENCHMARK(BM_FontCollectionInit); -static void BM_FontCollectionGetMinikinFontCollectionForFamily(benchmark::State& state) { +static void BM_FontCollectionGetMinikinFontCollectionForFamily( + benchmark::State& state) { while (state.KeepRunning()) { - FontCollection::GetFontCollection(txt::GetFontDir()).GetMinikinFontCollectionForFamily("Roboto"); + FontCollection::GetFontCollection(txt::GetFontDir()) + .GetMinikinFontCollectionForFamily("Roboto"); } } BENCHMARK(BM_FontCollectionGetMinikinFontCollectionForFamily); diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 0dda95b66a..fbdc53c6a9 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -214,12 +214,18 @@ void Paragraph::Layout(double width, } x_queue.clear(); }; - + std::shared_ptr collection = nullptr; + std::string prev_font_family = ""; for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { auto run = runs_.GetRun(run_index); - auto collection = - FontCollection::GetFontCollection(rootdir) - .GetMinikinFontCollectionForFamily(run.style.font_family); + + // Only obtain new font family if the font has changed between runs. + if (run.style.font_family != prev_font_family || collection == nullptr) { + collection = + FontCollection::GetFontCollection(rootdir) + .GetMinikinFontCollectionForFamily(run.style.font_family); + } + prev_font_family = run.style.font_family; GetFontAndMinikinPaint(run.style, &font, &minikin_paint); GetPaint(run.style, &paint); From 7e02287cf9dc6f88513249f6928036a43dedd407 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 28 Jun 2017 18:16:37 -0700 Subject: [PATCH 307/364] Add additional benchmarks and initial bigO checks. Change-Id: I3d2d9186fb187d55319c10260bf7e0d579c65a6f --- engine/src/flutter/benchmarks/BUILD.gn | 2 +- .../benchmarks/paragraph_benchmarks.cc | 139 ++++++++++++++++-- .../paragraph_builder_benchmarks.cc | 14 +- .../benchmarks/styled_runs_benchmarks.cc | 39 +++++ 4 files changed, 170 insertions(+), 24 deletions(-) create mode 100644 engine/src/flutter/benchmarks/styled_runs_benchmarks.cc diff --git a/engine/src/flutter/benchmarks/BUILD.gn b/engine/src/flutter/benchmarks/BUILD.gn index 7a3f14d7d7..3b637cc4c3 100644 --- a/engine/src/flutter/benchmarks/BUILD.gn +++ b/engine/src/flutter/benchmarks/BUILD.gn @@ -25,6 +25,7 @@ executable("benchmarks") { "font_collection_benchmarks.cc", "paragraph_benchmarks.cc", "paragraph_builder_benchmarks.cc", + "styled_runs_benchmarks.cc", "txt_run_all_benchmarks.cc", "utils.cc", "utils.h", @@ -41,5 +42,4 @@ executable("benchmarks") { "//lib/txt/libs/minikin", ] - } diff --git a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc index 34d44ad557..7a694f6eb5 100644 --- a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc @@ -16,8 +16,12 @@ #include "third_party/benchmark/include/benchmark/benchmark_api.h" +#include #include "lib/ftl/command_line.h" #include "lib/ftl/logging.h" +#include "lib/txt/libs/minikin/LayoutUtils.h" +#include "lib/txt/src/font_collection.h" +#include "lib/txt/src/font_skia.h" #include "lib/txt/src/font_style.h" #include "lib/txt/src/font_weight.h" #include "lib/txt/src/paragraph.h" @@ -35,17 +39,18 @@ static void BM_ParagraphShortLayout(benchmark::State& state) { std::u16string u16_text(icu_text.getBuffer(), icu_text.getBuffer() + icu_text.length()); - while (state.KeepRunning()) { - txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); + txt::ParagraphStyle paragraph_style; - txt::TextStyle text_style; - text_style.color = SK_ColorBLACK; + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); builder.PushStyle(text_style); builder.AddText(u16_text); builder.Pop(); auto paragraph = builder.Build(); + paragraph->Layout(300, txt::GetFontDir(), true); } } @@ -75,16 +80,17 @@ static void BM_ParagraphLongLayout(benchmark::State& state) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); txt::TextStyle text_style; text_style.color = SK_ColorBLACK; - - builder.PushStyle(text_style); - builder.AddText(u16_text); - builder.Pop(); - auto paragraph = builder.Build(); while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); + + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + auto paragraph = builder.Build(); + paragraph->Layout(300, txt::GetFontDir(), true); } } @@ -96,13 +102,12 @@ static void BM_ParagraphManyStylesLayout(benchmark::State& state) { std::u16string u16_text(icu_text.getBuffer(), icu_text.getBuffer() + icu_text.length()); + txt::ParagraphStyle paragraph_style; + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; while (state.KeepRunning()) { - txt::ParagraphStyle paragraph_style; txt::ParagraphBuilder builder(paragraph_style); - - txt::TextStyle text_style; - text_style.color = SK_ColorBLACK; - for (int i = 0; i < 100; ++i) { builder.PushStyle(text_style); builder.AddText(u16_text); @@ -113,4 +118,106 @@ static void BM_ParagraphManyStylesLayout(benchmark::State& state) { } BENCHMARK(BM_ParagraphManyStylesLayout); +static void BM_ParagraphTextBigO(benchmark::State& state) { + std::string text(state.range(0), '-'); + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); + + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + auto paragraph = builder.Build(); + + paragraph->Layout(300, txt::GetFontDir(), true); + } + state.SetComplexityN(state.range(0)); +} +BENCHMARK(BM_ParagraphTextBigO) + ->RangeMultiplier(20) + ->Range(1 << 4, 1 << 12) + ->Complexity(benchmark::oN); + +static void BM_ParagraphStylesBigO(benchmark::State& state) { + const char* text = "A short sentence. "; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); + + for (int i = 0; i < state.range(0); ++i) { + builder.PushStyle(text_style); + builder.AddText(u16_text); + } + auto paragraph = builder.Build(); + paragraph->Layout(300, txt::GetFontDir(), true); + } + state.SetComplexityN(state.range(0)); +} +BENCHMARK(BM_ParagraphStylesBigO) + ->RangeMultiplier(20) + ->Range(1 << 2, 1 << 8) + ->Complexity(benchmark::oN); + +// ----------------------------------------------------------------------------- +// +// The following benchmarks break down the layout function and attempts to time +// each of the components to more finely attribute latency. +// +// ----------------------------------------------------------------------------- + +static void BM_ParagraphMinikinDoLayout(benchmark::State& state) { + std::vector text; + for (uint16_t i = 0; i < 100; ++i) { + text.push_back(i); + } + minikin::FontStyle font; + txt::TextStyle text_style; + text_style.font_family = "Roboto"; + minikin::MinikinPaint paint; + + font = minikin::FontStyle(4, false); + paint.size = text_style.font_size; + paint.letterSpacing = text_style.letter_spacing; + paint.wordSpacing = text_style.word_spacing; + + auto collection = + FontCollection::GetFontCollection(txt::GetFontDir()) + .GetMinikinFontCollectionForFamily(text_style.font_family); + + while (state.KeepRunning()) { + minikin::Layout layout; + layout.doLayout(text.data(), 0, 50, text.size(), 0, font, paint, + collection); + } +} +BENCHMARK(BM_ParagraphMinikinDoLayout); + +static void BM_ParagraphSkTextBlobAlloc(benchmark::State& state) { + SkPaint paint; + paint.setAntiAlias(true); + paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); + paint.setTextSize(14); + paint.setFakeBoldText(false); + + while (state.KeepRunning()) { + SkTextBlobBuilder builder; + builder.allocRunPos(paint, 100); + } +} +BENCHMARK(BM_ParagraphSkTextBlobAlloc); + } // namespace txt diff --git a/engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc index 88da483736..e91ba4416d 100644 --- a/engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc @@ -37,11 +37,11 @@ BENCHMARK(BM_ParagraphBuilderConstruction); static void BM_ParagraphBuilderPushStyle(benchmark::State& state) { txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); txt::TextStyle text_style; text_style.color = SK_ColorBLACK; while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); builder.PushStyle(text_style); } } @@ -64,9 +64,9 @@ static void BM_ParagraphBuilderAddTextString(benchmark::State& state) { std::string text = "Hello World"; txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); builder.AddText(text); } } @@ -76,9 +76,9 @@ static void BM_ParagraphBuilderAddTextChar(benchmark::State& state) { const char* text = "Hello World"; txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); builder.AddText(text); } } @@ -91,9 +91,9 @@ static void BM_ParagraphBuilderAddTextU16stringShort(benchmark::State& state) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); builder.AddText(u16_text); } } @@ -123,9 +123,9 @@ static void BM_ParagraphBuilderAddTextU16stringLong(benchmark::State& state) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); builder.AddText(u16_text); } } @@ -139,12 +139,12 @@ static void BM_ParagraphBuilderShortParagraphConstruct( icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); txt::TextStyle text_style; text_style.color = SK_ColorBLACK; while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); builder.PushStyle(text_style); builder.AddText(u16_text); builder.Pop(); @@ -177,12 +177,12 @@ static void BM_ParagraphBuilderLongParagraphConstruct(benchmark::State& state) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); txt::TextStyle text_style; text_style.color = SK_ColorBLACK; while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style); builder.PushStyle(text_style); builder.AddText(u16_text); builder.Pop(); diff --git a/engine/src/flutter/benchmarks/styled_runs_benchmarks.cc b/engine/src/flutter/benchmarks/styled_runs_benchmarks.cc new file mode 100644 index 0000000000..b0531c2da0 --- /dev/null +++ b/engine/src/flutter/benchmarks/styled_runs_benchmarks.cc @@ -0,0 +1,39 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "third_party/benchmark/include/benchmark/benchmark_api.h" + +#include "lib/ftl/command_line.h" +#include "lib/ftl/logging.h" +#include "lib/txt/src/styled_runs.h" +#include "lib/txt/src/text_style.h" +#include "utils.h" + +namespace txt { + +static void BM_StyledRunsGetRun(benchmark::State& state) { + StyledRuns runs; + TextStyle style; + runs.AddStyle(style); + runs.StartRun(0, 0); + runs.EndRunIfNeeded(11); + while (state.KeepRunning()) { + runs.GetRun(0); + } +} +BENCHMARK(BM_StyledRunsGetRun); + +} // namespace txt From 4ddb034139767b18487620b3eb1923c2142eb539 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 29 Jun 2017 15:04:54 -0700 Subject: [PATCH 308/364] Major efficiency improvements, new benches, and API change to allow changing font collections. Change-Id: Id33cdcd161d659310d28dd36f415dc01da2e03a7 --- engine/src/flutter/benchmarks/BUILD.gn | 1 + .../benchmarks/font_collection_benchmarks.cc | 23 +++++++-- .../benchmarks/paint_record_benchmarks.cc | 46 +++++++++++++++++ .../benchmarks/paragraph_benchmarks.cc | 27 ++++++---- .../paragraph_builder_benchmarks.cc | 21 ++++---- engine/src/flutter/src/font_collection.cc | 12 +++++ engine/src/flutter/src/font_collection.h | 16 ++++-- engine/src/flutter/src/paragraph.cc | 39 ++++++++------- engine/src/flutter/src/paragraph.h | 14 +++--- engine/src/flutter/src/paragraph_builder.cc | 17 +++++++ engine/src/flutter/src/paragraph_builder.h | 6 +++ .../flutter/tests/txt/paragraph_unittests.cc | 50 +++++++++++-------- engine/src/flutter/tests/txt/utils.cc | 2 +- 13 files changed, 202 insertions(+), 72 deletions(-) create mode 100644 engine/src/flutter/benchmarks/paint_record_benchmarks.cc diff --git a/engine/src/flutter/benchmarks/BUILD.gn b/engine/src/flutter/benchmarks/BUILD.gn index 3b637cc4c3..184d2a5a0b 100644 --- a/engine/src/flutter/benchmarks/BUILD.gn +++ b/engine/src/flutter/benchmarks/BUILD.gn @@ -23,6 +23,7 @@ executable("benchmarks") { sources = [ "font_collection_benchmarks.cc", + "paint_record_benchmarks.cc", "paragraph_benchmarks.cc", "paragraph_builder_benchmarks.cc", "styled_runs_benchmarks.cc", diff --git a/engine/src/flutter/benchmarks/font_collection_benchmarks.cc b/engine/src/flutter/benchmarks/font_collection_benchmarks.cc index 99eb26eecf..74737a8f70 100644 --- a/engine/src/flutter/benchmarks/font_collection_benchmarks.cc +++ b/engine/src/flutter/benchmarks/font_collection_benchmarks.cc @@ -19,6 +19,8 @@ #include "lib/ftl/command_line.h" #include "lib/ftl/logging.h" #include "lib/txt/src/font_collection.h" +#include "third_party/skia/include/ports/SkFontMgr.h" +#include "third_party/skia/include/ports/SkFontMgr_directory.h" #include "utils.h" namespace txt { @@ -32,18 +34,33 @@ static void BM_FAKE_BENCHMARK(benchmark::State& state) { } BENCHMARK(BM_FAKE_BENCHMARK); +static void BM_FontCollectionCustomInit(benchmark::State& state) { + while (state.KeepRunning()) { + benchmark::DoNotOptimize( + FontCollection::GetFontCollection(txt::GetFontDir())); + } +} +BENCHMARK(BM_FontCollectionCustomInit); + static void BM_FontCollectionInit(benchmark::State& state) { while (state.KeepRunning()) { - FontCollection::GetFontCollection(txt::GetFontDir()); + benchmark::DoNotOptimize(FontCollection::GetFontCollection()); } } BENCHMARK(BM_FontCollectionInit); +static void BM_FontCollectionSkFontMgr(benchmark::State& state) { + while (state.KeepRunning()) { + auto mgr = SkFontMgr_New_Custom_Directory(txt::GetFontDir().c_str()); + } +} +BENCHMARK(BM_FontCollectionSkFontMgr); + static void BM_FontCollectionGetMinikinFontCollectionForFamily( benchmark::State& state) { + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); while (state.KeepRunning()) { - FontCollection::GetFontCollection(txt::GetFontDir()) - .GetMinikinFontCollectionForFamily("Roboto"); + font_collection.GetMinikinFontCollectionForFamily("Roboto"); } } BENCHMARK(BM_FontCollectionGetMinikinFontCollectionForFamily); diff --git a/engine/src/flutter/benchmarks/paint_record_benchmarks.cc b/engine/src/flutter/benchmarks/paint_record_benchmarks.cc new file mode 100644 index 0000000000..f5f7143d72 --- /dev/null +++ b/engine/src/flutter/benchmarks/paint_record_benchmarks.cc @@ -0,0 +1,46 @@ +/* + * Copyright 2017 Google, Inc. + * + * 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 "third_party/benchmark/include/benchmark/benchmark_api.h" + +#include "lib/ftl/command_line.h" +#include "lib/ftl/logging.h" +#include "lib/txt/src/paint_record.h" +#include "lib/txt/src/text_style.h" +#include "utils.h" + +namespace txt { + +static void BM_PaintRecordInit(benchmark::State& state) { + TextStyle style; + + SkPaint paint; + paint.setAntiAlias(true); + paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); + paint.setTextSize(14); + paint.setFakeBoldText(false); + + SkTextBlobBuilder builder; + builder.allocRunPos(paint, 100); + auto text_blob = builder.make(); + + while (state.KeepRunning()) { + PaintRecord PaintRecord(style, text_blob, SkPaint::FontMetrics(), 0); + } +} +BENCHMARK(BM_PaintRecordInit); + +} // namespace txt diff --git a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc index 7a694f6eb5..455b75e047 100644 --- a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc @@ -43,15 +43,16 @@ static void BM_ParagraphShortLayout(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); builder.PushStyle(text_style); builder.AddText(u16_text); builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(300, txt::GetFontDir(), true); + paragraph->Layout(300, true); } } BENCHMARK(BM_ParagraphShortLayout); @@ -83,15 +84,16 @@ static void BM_ParagraphLongLayout(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); builder.PushStyle(text_style); builder.AddText(u16_text); builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(300, txt::GetFontDir(), true); + paragraph->Layout(300, true); } } BENCHMARK(BM_ParagraphLongLayout); @@ -106,14 +108,15 @@ static void BM_ParagraphManyStylesLayout(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style); - for (int i = 0; i < 100; ++i) { + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + for (int i = 0; i < 1000; ++i) { builder.PushStyle(text_style); builder.AddText(u16_text); } auto paragraph = builder.Build(); - paragraph->Layout(300, txt::GetFontDir(), true); + paragraph->Layout(300, true); } } BENCHMARK(BM_ParagraphManyStylesLayout); @@ -128,15 +131,16 @@ static void BM_ParagraphTextBigO(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); builder.PushStyle(text_style); builder.AddText(u16_text); builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(300, txt::GetFontDir(), true); + paragraph->Layout(300, true); } state.SetComplexityN(state.range(0)); } @@ -155,15 +159,16 @@ static void BM_ParagraphStylesBigO(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); for (int i = 0; i < state.range(0); ++i) { builder.PushStyle(text_style); builder.AddText(u16_text); } auto paragraph = builder.Build(); - paragraph->Layout(300, txt::GetFontDir(), true); + paragraph->Layout(300, true); } state.SetComplexityN(state.range(0)); } diff --git a/engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc index e91ba4416d..c589dfd9ae 100644 --- a/engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_builder_benchmarks.cc @@ -17,6 +17,7 @@ #include "third_party/benchmark/include/benchmark/benchmark_api.h" #include "lib/ftl/logging.h" +#include "lib/txt/src/font_collection.h" #include "lib/txt/src/font_style.h" #include "lib/txt/src/font_weight.h" #include "lib/txt/src/paragraph.h" @@ -24,6 +25,7 @@ #include "lib/txt/src/text_align.h" #include "third_party/icu/source/common/unicode/unistr.h" #include "third_party/skia/include/core/SkColor.h" +#include "utils.h" namespace txt { @@ -40,8 +42,9 @@ static void BM_ParagraphBuilderPushStyle(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); builder.PushStyle(text_style); } } @@ -76,9 +79,9 @@ static void BM_ParagraphBuilderAddTextChar(benchmark::State& state) { const char* text = "Hello World"; txt::ParagraphStyle paragraph_style; - + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); builder.AddText(text); } } @@ -91,9 +94,9 @@ static void BM_ParagraphBuilderAddTextU16stringShort(benchmark::State& state) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); builder.AddText(u16_text); } } @@ -142,9 +145,9 @@ static void BM_ParagraphBuilderShortParagraphConstruct( txt::TextStyle text_style; text_style.color = SK_ColorBLACK; - + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); builder.PushStyle(text_style); builder.AddText(u16_text); builder.Pop(); @@ -180,9 +183,9 @@ static void BM_ParagraphBuilderLongParagraphConstruct(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; - + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); builder.PushStyle(text_style); builder.AddText(u16_text); builder.Pop(); diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index 2983769494..009382d3f2 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -28,11 +28,13 @@ namespace txt { +// Will be deprecated when full compatibility with Flutter Engine is complete. FontCollection& FontCollection::GetFontCollection(std::string dir) { std::vector dirs = {dir}; return GetFontCollection(std::move(dirs)); } +// Will be deprecated when full compatibility with Flutter Engine is complete. FontCollection& FontCollection::GetFontCollection( std::vector dirs) { static FontCollection* collection = nullptr; @@ -41,10 +43,20 @@ FontCollection& FontCollection::GetFontCollection( return *collection; } +// Will be deprecated when full compatibility with Flutter Engine is complete. FontCollection& FontCollection::GetDefaultFontCollection() { return GetFontCollection(""); } +FontCollection::FontCollection() { + FontCollection(""); +} + +FontCollection::FontCollection(std::string dir) { + std::vector dirs = {dir}; + FontCollection(std::move(dirs)); +} + FontCollection::FontCollection(const std::vector& dirs) { #ifdef DIRECTORY_FONT_MANAGER_AVAILABLE for (std::string dir : dirs) { diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index b8a0c8a6de..0a05bda86d 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -35,15 +35,26 @@ namespace txt { class FontCollection { public: + // Will be deprecated when full compatibility with Flutter Engine is complete. static FontCollection& GetDefaultFontCollection(); + // Will be deprecated when full compatibility with Flutter Engine is complete. static FontCollection& GetFontCollection(std::string dir = ""); + // Will be deprecated when full compatibility with Flutter Engine is complete. static FontCollection& GetFontCollection(std::vector dirs); std::shared_ptr GetMinikinFontCollectionForFamily( const std::string& family); + FontCollection(const std::vector& dirs); + + FontCollection(std::string dir); + + FontCollection(); + + ~FontCollection(); + // Provides a set of all available family names. std::set GetFamilyNames(); @@ -62,12 +73,7 @@ class FontCollection { return DEFAULT_FAMILY_NAME; }; - FontCollection(const std::vector& dirs); - - ~FontCollection(); - // TODO(chinmaygarde): Caches go here. - FTL_DISALLOW_COPY_AND_ASSIGN(FontCollection); }; } // namespace txt diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index fbdc53c6a9..c6ee6be979 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -125,24 +125,25 @@ void Paragraph::SetText(std::vector text, StyledRuns runs) { breaker_.setText(); } -void Paragraph::AddRunsToLineBreaker(const std::string& rootdir) { +void Paragraph::AddRunsToLineBreaker( + std::shared_ptr& collection, + std::string& prev_font_family) { minikin::FontStyle font; minikin::MinikinPaint paint; for (size_t i = 0; i < runs_.size(); ++i) { auto run = runs_.GetRun(i); - auto collection = - FontCollection::GetFontCollection(rootdir) - .GetMinikinFontCollectionForFamily(run.style.font_family); + // Only obtain new font family if the font has changed between runs. + if (run.style.font_family != prev_font_family || collection == nullptr) { + collection = font_collection_->GetMinikinFontCollectionForFamily( + run.style.font_family); + } + prev_font_family = run.style.font_family; GetFontAndMinikinPaint(run.style, &font, &paint); breaker_.addStyleRun(&paint, collection, font, run.start, run.end, false); } } -void Paragraph::Layout(double width, - const std::string& rootdir, - bool force, - const double x_offset, - const double y_offset) { +void Paragraph::Layout(double width, bool force) { // Do not allow calling layout multiple times without changing anything. if (!needs_layout_ && !force) return; @@ -150,8 +151,11 @@ void Paragraph::Layout(double width, width_ = width; + std::shared_ptr collection = nullptr; + std::string prev_font_family = ""; + breaker_.setLineWidths(0.0f, 0, width_); - AddRunsToLineBreaker(rootdir); + AddRunsToLineBreaker(collection, prev_font_family); breaker_.setJustified(paragraph_style_.text_align == TextAlign::justify); size_t breaks_count = breaker_.computeBreaks(); const int* breaks = breaker_.getBreaks(); @@ -170,8 +174,8 @@ void Paragraph::Layout(double width, max_intrinsic_width_ = 0.0f; lines_ = 0; - SkScalar x = x_offset; - SkScalar y = y_offset; + SkScalar x = 0.0f; + SkScalar y = 0.0f; size_t break_index = 0; double letter_spacing_offset = 0.0f; double max_line_spacing = 0.0f; @@ -214,16 +218,13 @@ void Paragraph::Layout(double width, } x_queue.clear(); }; - std::shared_ptr collection = nullptr; - std::string prev_font_family = ""; for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { auto run = runs_.GetRun(run_index); // Only obtain new font family if the font has changed between runs. if (run.style.font_family != prev_font_family || collection == nullptr) { - collection = - FontCollection::GetFontCollection(rootdir) - .GetMinikinFontCollectionForFamily(run.style.font_family); + collection = font_collection_->GetMinikinFontCollectionForFamily( + run.style.font_family); } prev_font_family = run.style.font_family; GetFontAndMinikinPaint(run.style, &font, &minikin_paint); @@ -434,6 +435,10 @@ void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { paragraph_style_ = style; } +void Paragraph::SetFontCollection(FontCollection* font_collection) { + font_collection_ = font_collection; +} + void Paragraph::Paint(SkCanvas* canvas, double x, double y) { for (const auto& record : records_) { SkPaint paint; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index b4b90a4ee9..64739c8b95 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -21,6 +21,7 @@ #include #include "lib/ftl/macros.h" +#include "lib/txt/src/font_collection.h" #include "lib/txt/src/paint_record.h" #include "lib/txt/src/paragraph_style.h" #include "lib/txt/src/styled_runs.h" @@ -38,11 +39,7 @@ class Paragraph { ~Paragraph(); - void Layout(double width, - const std::string& rootdir = "", - bool force = false, - const double x_offset = 0.0, - const double y_offset = 0.0); + void Layout(double width, bool force = false); void Paint(SkCanvas* canvas, double x, double y); @@ -81,6 +78,7 @@ class Paragraph { std::vector records_; std::vector line_widths_; ParagraphStyle paragraph_style_; + FontCollection* font_collection_; // TODO(garyq): Height of the paragraph after Layout(). SkScalar height_ = 0.0f; double width_ = 0.0f; @@ -95,7 +93,11 @@ class Paragraph { void SetParagraphStyle(const ParagraphStyle& style); - void AddRunsToLineBreaker(const std::string& rootdir = ""); + void SetFontCollection(FontCollection* font_collection); + + void AddRunsToLineBreaker( + std::shared_ptr& collection, + std::string& prev_font_family); void JustifyLine(std::vector& buffers, std::vector& buffer_sizes, diff --git a/engine/src/flutter/src/paragraph_builder.cc b/engine/src/flutter/src/paragraph_builder.cc index 3d980eae3a..d307677458 100644 --- a/engine/src/flutter/src/paragraph_builder.cc +++ b/engine/src/flutter/src/paragraph_builder.cc @@ -21,6 +21,10 @@ namespace txt { +ParagraphBuilder::ParagraphBuilder(ParagraphStyle style, + FontCollection* font_collection) + : paragraph_style_(style), font_collection_(font_collection) {} + ParagraphBuilder::ParagraphBuilder(ParagraphStyle style) : paragraph_style_(style) {} @@ -30,6 +34,10 @@ void ParagraphBuilder::SetParagraphStyle(const ParagraphStyle& style) { paragraph_style_ = style; } +void ParagraphBuilder::SetFontCollection(FontCollection* font_collection) { + font_collection_ = font_collection; +} + ParagraphBuilder::~ParagraphBuilder() = default; void ParagraphBuilder::PushStyle(const TextStyle& style) { @@ -71,10 +79,19 @@ void ParagraphBuilder::AddText(const char* text) { } std::unique_ptr ParagraphBuilder::Build() { + if (font_collection_ == nullptr) { + // Will be deprecated when full compatibility with Flutter Engine is + // complete. + FTL_LOG(WARNING) << "No font collection provided. Falling back to default " + "fonts."; + font_collection_ = &FontCollection::GetFontCollection(""); + } + runs_.EndRunIfNeeded(text_.size()); std::unique_ptr paragraph = std::make_unique(); paragraph->SetText(std::move(text_), std::move(runs_)); paragraph->SetParagraphStyle(paragraph_style_); + paragraph->SetFontCollection(font_collection_); return paragraph; } diff --git a/engine/src/flutter/src/paragraph_builder.h b/engine/src/flutter/src/paragraph_builder.h index 5df84ca72a..07d92e69d6 100644 --- a/engine/src/flutter/src/paragraph_builder.h +++ b/engine/src/flutter/src/paragraph_builder.h @@ -21,6 +21,7 @@ #include #include "lib/ftl/macros.h" +#include "lib/txt/src/font_collection.h" #include "lib/txt/src/paragraph.h" #include "lib/txt/src/paragraph_style.h" #include "lib/txt/src/styled_runs.h" @@ -32,6 +33,8 @@ class ParagraphBuilder { public: explicit ParagraphBuilder(ParagraphStyle style); + ParagraphBuilder(ParagraphStyle style, FontCollection* font_collection); + ParagraphBuilder(); ~ParagraphBuilder(); @@ -48,6 +51,8 @@ class ParagraphBuilder { void SetParagraphStyle(const ParagraphStyle& style); + void SetFontCollection(FontCollection* font_collection); + std::unique_ptr Build(); private: @@ -55,6 +60,7 @@ class ParagraphBuilder { std::vector style_stack_; StyledRuns runs_; ParagraphStyle paragraph_style_; + FontCollection* font_collection_ = nullptr; FTL_DISALLOW_COPY_AND_ASSIGN(ParagraphBuilder); }; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index d93ea32e3e..187ccfa302 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -34,7 +34,8 @@ TEST_F(RenderTest, SimpleParagraph) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; text_style.color = SK_ColorBLACK; @@ -44,7 +45,7 @@ TEST_F(RenderTest, SimpleParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth()); paragraph->Paint(GetCanvas(), 10.0, 15.0); @@ -66,7 +67,8 @@ TEST_F(RenderTest, SimpleRedParagraph) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; text_style.color = SK_ColorRED; @@ -77,7 +79,7 @@ TEST_F(RenderTest, SimpleRedParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth()); paragraph->Paint(GetCanvas(), 10.0, 15.0); @@ -119,7 +121,8 @@ TEST_F(RenderTest, RainbowParagraph) { txt::ParagraphStyle paragraph_style; paragraph_style.max_lines = 2; paragraph_style.text_align = TextAlign::left; - txt::ParagraphBuilder builder(paragraph_style); + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style1; text_style1.color = SK_ColorRED; @@ -162,7 +165,7 @@ TEST_F(RenderTest, RainbowParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth()); paragraph->Paint(GetCanvas(), 10.0, 50.0); @@ -191,7 +194,8 @@ TEST_F(RenderTest, DefaultStyleParagraph) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; text_style.color = SK_ColorRED; @@ -201,7 +205,7 @@ TEST_F(RenderTest, DefaultStyleParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth()); paragraph->Paint(GetCanvas(), 10.0, 15.0); @@ -221,7 +225,8 @@ TEST_F(RenderTest, BoldParagraph) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; text_style.font_size = 60; @@ -236,7 +241,7 @@ TEST_F(RenderTest, BoldParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth()); paragraph->Paint(GetCanvas(), 10.0, 60.0); @@ -277,7 +282,8 @@ TEST_F(RenderTest, LeftAlignParagraph) { txt::ParagraphStyle paragraph_style; paragraph_style.max_lines = 14; paragraph_style.text_align = TextAlign::left; - txt::ParagraphBuilder builder(paragraph_style); + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; text_style.font_size = 26; @@ -294,7 +300,7 @@ TEST_F(RenderTest, LeftAlignParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth() - 100, txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth() - 100); paragraph->Paint(GetCanvas(), 0, 0); ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); @@ -363,7 +369,8 @@ TEST_F(RenderTest, RightAlignParagraph) { txt::ParagraphStyle paragraph_style; paragraph_style.max_lines = 14; paragraph_style.text_align = TextAlign::right; - txt::ParagraphBuilder builder(paragraph_style); + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; text_style.font_size = 26; @@ -380,7 +387,7 @@ TEST_F(RenderTest, RightAlignParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth() - 100, txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth() - 100); paragraph->Paint(GetCanvas(), 0, 0); ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); @@ -464,7 +471,8 @@ TEST_F(RenderTest, CenterAlignParagraph) { txt::ParagraphStyle paragraph_style; paragraph_style.max_lines = 14; paragraph_style.text_align = TextAlign::center; - txt::ParagraphBuilder builder(paragraph_style); + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; text_style.font_size = 26; @@ -481,7 +489,7 @@ TEST_F(RenderTest, CenterAlignParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth() - 100, txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth() - 100); paragraph->Paint(GetCanvas(), 0, 0); ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); @@ -569,7 +577,8 @@ TEST_F(RenderTest, JustifyAlignParagraph) { txt::ParagraphStyle paragraph_style; paragraph_style.max_lines = 14; paragraph_style.text_align = TextAlign::justify; - txt::ParagraphBuilder builder(paragraph_style); + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; text_style.font_size = 26; @@ -586,7 +595,7 @@ TEST_F(RenderTest, JustifyAlignParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth() - 100, txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth() - 100); paragraph->Paint(GetCanvas(), 0, 0); ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); @@ -636,7 +645,8 @@ TEST_F(RenderTest, ItalicsParagraph) { icu_text.getBuffer() + icu_text.length()); txt::ParagraphStyle paragraph_style; - txt::ParagraphBuilder builder(paragraph_style); + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; text_style.color = SK_ColorRED; @@ -649,7 +659,7 @@ TEST_F(RenderTest, ItalicsParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth(), txt::GetFontDir()); + paragraph->Layout(GetTestCanvasWidth()); paragraph->Paint(GetCanvas(), 10.0, 35.0); diff --git a/engine/src/flutter/tests/txt/utils.cc b/engine/src/flutter/tests/txt/utils.cc index 6ec90c2a5c..0bee521a3f 100644 --- a/engine/src/flutter/tests/txt/utils.cc +++ b/engine/src/flutter/tests/txt/utils.cc @@ -40,4 +40,4 @@ void SetCommandLine(ftl::CommandLine cmd) { gCommandLine = std::move(cmd); } -} // namespace txt +} // namespace txt \ No newline at end of file From d6a6221fc832c7e292f0a4ab663c67c7a634aa9c Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 29 Jun 2017 16:14:35 -0700 Subject: [PATCH 309/364] Switch to hashmap caching of font collections to be resillient to alternating fonts and slight performance improvement. Change-Id: Ide3a311819c41e23e88e6dca06f0ce7669f6842c --- engine/src/flutter/src/paragraph.cc | 30 +++++++++++++---------------- engine/src/flutter/src/paragraph.h | 4 ++-- 2 files changed, 15 insertions(+), 19 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index c6ee6be979..d4a7c7d13e 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -126,20 +126,21 @@ void Paragraph::SetText(std::vector text, StyledRuns runs) { } void Paragraph::AddRunsToLineBreaker( - std::shared_ptr& collection, - std::string& prev_font_family) { + std::unordered_map>& + collection_map) { minikin::FontStyle font; minikin::MinikinPaint paint; for (size_t i = 0; i < runs_.size(); ++i) { auto run = runs_.GetRun(i); // Only obtain new font family if the font has changed between runs. - if (run.style.font_family != prev_font_family || collection == nullptr) { - collection = font_collection_->GetMinikinFontCollectionForFamily( - run.style.font_family); + if (collection_map.count(run.style.font_family) == 0) { + collection_map[run.style.font_family] = + font_collection_->GetMinikinFontCollectionForFamily( + run.style.font_family); } - prev_font_family = run.style.font_family; GetFontAndMinikinPaint(run.style, &font, &paint); - breaker_.addStyleRun(&paint, collection, font, run.start, run.end, false); + breaker_.addStyleRun(&paint, collection_map.at(run.style.font_family), font, + run.start, run.end, false); } } @@ -151,11 +152,11 @@ void Paragraph::Layout(double width, bool force) { width_ = width; - std::shared_ptr collection = nullptr; - std::string prev_font_family = ""; + std::unordered_map> + collection_map; breaker_.setLineWidths(0.0f, 0, width_); - AddRunsToLineBreaker(collection, prev_font_family); + AddRunsToLineBreaker(collection_map); breaker_.setJustified(paragraph_style_.text_align == TextAlign::justify); size_t breaks_count = breaker_.computeBreaks(); const int* breaks = breaker_.getBreaks(); @@ -221,12 +222,6 @@ void Paragraph::Layout(double width, bool force) { for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { auto run = runs_.GetRun(run_index); - // Only obtain new font family if the font has changed between runs. - if (run.style.font_family != prev_font_family || collection == nullptr) { - collection = font_collection_->GetMinikinFontCollectionForFamily( - run.style.font_family); - } - prev_font_family = run.style.font_family; GetFontAndMinikinPaint(run.style, &font, &minikin_paint); GetPaint(run.style, &paint); @@ -244,7 +239,8 @@ void Paragraph::Layout(double width, bool force) { int bidiFlags = 0; layout.doLayout(text_.data(), layout_start, layout_end - layout_start, - text_.size(), bidiFlags, font, minikin_paint, collection); + text_.size(), bidiFlags, font, minikin_paint, + collection_map.at(run.style.font_family)); const size_t glyph_count = layout.nGlyphs(); size_t blob_start = 0; // Each blob. diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 64739c8b95..97e30dae51 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -96,8 +96,8 @@ class Paragraph { void SetFontCollection(FontCollection* font_collection); void AddRunsToLineBreaker( - std::shared_ptr& collection, - std::string& prev_font_family); + std::unordered_map>& + collection_map); void JustifyLine(std::vector& buffers, std::vector& buffer_sizes, From 4c93f0e97663b8b996432a7219fb93d8f8b627e7 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 29 Jun 2017 17:58:42 -0700 Subject: [PATCH 310/364] Remove trailing spaces of blobs to fix decoration positioning, justify, and centering. Change-Id: Ide66103f95be8c090ab5ddc9888cd4defc5cde51 --- engine/src/flutter/src/paragraph.cc | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index d4a7c7d13e..764291ef48 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -253,13 +253,22 @@ void Paragraph::Layout(double width, bool force) { // TODO(abarth): Precompute when we can use allocRunPosH. paint.setTypeface(GetTypefaceForGlyph(layout, blob_start)); - buffers.push_back(&builder.allocRunPos(paint, blob_length)); + // Check if we should remove trailing whitespace of blobs. + size_t trailing_length = 0; + while (minikin::isWordSpace( + text_[character_index + blob_length - trailing_length - 1])) { + ++trailing_length; + } + + buffers.push_back( + &builder.allocRunPos(paint, blob_length - trailing_length)); letter_spacing_offset += run.style.letter_spacing; // Each Glyph/Letter. bool whitespace_ended = true; - for (size_t blob_index = 0; blob_index < blob_length; ++blob_index) { + for (size_t blob_index = 0; blob_index < blob_length - trailing_length; + ++blob_index) { const size_t glyph_index = blob_start + blob_index; buffers.back()->glyphs[blob_index] = layout.getGlyphId(glyph_index); // Check if the current Glyph is a whitespace and handle multiple @@ -283,6 +292,7 @@ void Paragraph::Layout(double width, bool force) { letter_spacing_offset += run.style.letter_spacing; } blob_start += blob_length; + character_index += trailing_length; // Subtract letter offset to avoid big gap at end of run. This my be // removed depending on the specifications for letter spacing. From 11580cea63f8a3f71e88b4cbe53d995c23488ece Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 30 Jun 2017 12:05:11 -0700 Subject: [PATCH 311/364] Move font caches to FontCollection and multiple eviction schemes. ~x200 speed improvement. Change-Id: I1e2f940ddb36f9ac51cc95c42c2f121140ff3f6f --- .../benchmarks/paragraph_benchmarks.cc | 4 +- engine/src/flutter/src/font_collection.cc | 128 ++++++++++++------ engine/src/flutter/src/font_collection.h | 30 +++- engine/src/flutter/src/paragraph.cc | 17 ++- 4 files changed, 123 insertions(+), 56 deletions(-) diff --git a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc index 455b75e047..7bbfaacba5 100644 --- a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc @@ -146,7 +146,7 @@ static void BM_ParagraphTextBigO(benchmark::State& state) { } BENCHMARK(BM_ParagraphTextBigO) ->RangeMultiplier(20) - ->Range(1 << 4, 1 << 12) + ->Range(1 << 6, 1 << 14) ->Complexity(benchmark::oN); static void BM_ParagraphStylesBigO(benchmark::State& state) { @@ -174,7 +174,7 @@ static void BM_ParagraphStylesBigO(benchmark::State& state) { } BENCHMARK(BM_ParagraphStylesBigO) ->RangeMultiplier(20) - ->Range(1 << 2, 1 << 8) + ->Range(1 << 4, 1 << 12) ->Complexity(benchmark::oN); // ----------------------------------------------------------------------------- diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index 009382d3f2..eb0a793a42 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -16,9 +16,13 @@ #include "lib/txt/src/font_collection.h" +#include +#include #include #include #include +#include +#include #include "lib/ftl/logging.h" #include "lib/txt/src/font_skia.h" @@ -52,12 +56,17 @@ FontCollection::FontCollection() { FontCollection(""); } -FontCollection::FontCollection(std::string dir) { - std::vector dirs = {dir}; - FontCollection(std::move(dirs)); +FontCollection::FontCollection(CacheMethod cache_method) { + FontCollection("", cache_method); } -FontCollection::FontCollection(const std::vector& dirs) { +FontCollection::FontCollection(std::string dir, CacheMethod cache_method) { + std::vector dirs = {dir}; + FontCollection(std::move(dirs), cache_method); +} + +FontCollection::FontCollection(const std::vector& dirs, + CacheMethod cache_method) { #ifdef DIRECTORY_FONT_MANAGER_AVAILABLE for (std::string dir : dirs) { if (dir.length() != 0) { @@ -75,6 +84,8 @@ FontCollection::FontCollection(const std::vector& dirs) { family_names_.insert(std::string{str.writable_str()}); } } + + cache_method_ = cache_method; } FontCollection::~FontCollection() = default; @@ -83,6 +94,18 @@ std::set FontCollection::GetFamilyNames() { return family_names_; } +bool FontCollection::HasFamily(const std::string family) const { + return family_names_.count(family) == 1; +} + +void FontCollection::FlushCache() { + minikin_font_collection_map_.clear(); +} + +void FontCollection::SetCacheCapacity(const size_t cap) { + cache_capacity_ = cap; +} + // TODO(garyq): Rework this to use font fallback system. const std::string FontCollection::ProcessFamilyName(const std::string& family) { #ifdef DIRECTORY_FONT_MANAGER_AVAILABLE @@ -101,51 +124,70 @@ const std::string FontCollection::ProcessFamilyName(const std::string& family) { std::shared_ptr FontCollection::GetMinikinFontCollectionForFamily(const std::string& family) { FTL_DCHECK(skia_font_managers_.size() > 0); + std::string processed_family_name = ProcessFamilyName(family); + // Only obtain new font family if the font has changed between runs. + if (cache_method_ == CacheMethod::kNone || + minikin_font_collection_map_.count(processed_family_name) == 0) { + // Ask Skia to resolve a font style set for a font family name. + // FIXME(chinmaygarde): CoreText crashes when passed a null string. This + // seems to be a bug in Skia as SkFontMgr explicitly says passing in + // nullptr gives the default font. + for (sk_sp mgr : skia_font_managers_) { + FTL_DCHECK(mgr != nullptr); + auto font_style_set = mgr->matchFamily(processed_family_name.c_str()); + if (font_style_set != nullptr) { + std::vector minikin_fonts; - // Ask Skia to resolve a font style set for a font family name. - // FIXME(chinmaygarde): The name "Coolvetica" is hardcoded because CoreText - // crashes when passed a null string. This seems to be a bug in Skia as - // SkFontMgr explicitly says passing in nullptr gives the default font. - for (sk_sp mgr : skia_font_managers_) { - FTL_DCHECK(mgr != nullptr); - auto font_style_set = mgr->matchFamily(ProcessFamilyName(family).c_str()); - FTL_DCHECK(font_style_set != nullptr); + // Add fonts to the Minikin font family. + for (int i = 0, style_count = font_style_set->count(); i < style_count; + ++i) { + // Create the skia typeface + auto skia_typeface = + sk_ref_sp(font_style_set->createTypeface(i)); + if (skia_typeface == nullptr) { + continue; + } - std::vector minikin_fonts; + // Create the minikin font from the skia typeface. + minikin::Font minikin_font( + std::make_shared(skia_typeface), + minikin::FontStyle{skia_typeface->fontStyle().weight(), + skia_typeface->isItalic()}); - // Add fonts to the Minikin font family. - for (int i = 0, style_count = font_style_set->count(); i < style_count; - ++i) { - // Create the skia typeface - auto skia_typeface = - sk_ref_sp(font_style_set->createTypeface(i)); - if (skia_typeface == nullptr) { - continue; + minikin_fonts.emplace_back(std::move(minikin_font)); + } + + // Create a Minikin font family. + auto minikin_family = + std::make_shared(std::move(minikin_fonts)); + + // Create a vector of font families for the Minkin font collection. For + // now, we only have one family in our collection. + std::vector> minikin_families = { + minikin_family, + }; + + // Assign the font collection. + minikin_font_collection_map_[processed_family_name] = + std::make_shared(minikin_families); + return minikin_font_collection_map_[processed_family_name]; } - - // Create the minikin font from the skia typeface. - minikin::Font minikin_font( - std::make_shared(skia_typeface), - minikin::FontStyle{skia_typeface->fontStyle().weight(), - skia_typeface->isItalic()}); - - minikin_fonts.emplace_back(std::move(minikin_font)); } - - // Create a Minikin font family. - auto minikin_family = - std::make_shared(std::move(minikin_fonts)); - - // Create a vector of font families for the Minkin font collection. For now, - // we only have one family in our collection. - std::vector> minikin_families = { - minikin_family, - }; - - // Return the font collection. - return std::make_shared(minikin_families); + // Uh oh! Font family not found in any of the font managers! + minikin_font_collection_map_[processed_family_name] = nullptr; } - return nullptr; + + // Maintain LRU and evict old fonts no longer used. + if (cache_method_ == CacheMethod::kLRU) { + lru_tracker_.remove(processed_family_name); + lru_tracker_.push_front(processed_family_name); + if (lru_tracker_.size() > cache_capacity_) { + std::string family_to_evict = lru_tracker_.back(); + lru_tracker_.pop_back(); + minikin_font_collection_map_.erase(family_to_evict); + } + } + return minikin_font_collection_map_[processed_family_name]; } } // namespace txt diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index 0a05bda86d..efc1dab732 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -19,9 +19,11 @@ #define DEFAULT_FAMILY_NAME "Roboto" +#include #include #include #include +#include #include #include "lib/ftl/macros.h" @@ -35,6 +37,11 @@ namespace txt { class FontCollection { public: + enum CacheMethod { + kNone, + kLRU, // Least Recently Used. + kUnlimited, + }; // Will be deprecated when full compatibility with Flutter Engine is complete. static FontCollection& GetDefaultFontCollection(); @@ -47,9 +54,13 @@ class FontCollection { std::shared_ptr GetMinikinFontCollectionForFamily( const std::string& family); - FontCollection(const std::vector& dirs); + FontCollection(const std::vector& dirs, + CacheMethod cache_method = CacheMethod::kUnlimited); - FontCollection(std::string dir); + FontCollection(std::string dir, + CacheMethod cache_method = CacheMethod::kUnlimited); + + FontCollection(CacheMethod cache_method); FontCollection(); @@ -58,10 +69,25 @@ class FontCollection { // Provides a set of all available family names. std::set GetFamilyNames(); + bool HasFamily(const std::string family) const; + + void FlushCache(); + + void SetCacheCapacity(const size_t cap); + private: std::vector> skia_font_managers_; // Cache the names because GetFamilyNames() can be frequently called. std::set family_names_; + CacheMethod cache_method_ = CacheMethod::kUnlimited; + std::list lru_tracker_; + size_t cache_capacity_ = 20; + + // Cache minikin font collections to prevent slow disk reads. + // TODO(garyq): Implement optional low-memory optimized system to prevent + // fonts building up in memory. + std::unordered_map> + minikin_font_collection_map_; FRIEND_TEST(FontCollection, HasDefaultRegistrations); FRIEND_TEST(FontCollection, GetMinikinFontCollections); diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 764291ef48..848bda5d54 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -132,15 +132,11 @@ void Paragraph::AddRunsToLineBreaker( minikin::MinikinPaint paint; for (size_t i = 0; i < runs_.size(); ++i) { auto run = runs_.GetRun(i); - // Only obtain new font family if the font has changed between runs. - if (collection_map.count(run.style.font_family) == 0) { - collection_map[run.style.font_family] = - font_collection_->GetMinikinFontCollectionForFamily( - run.style.font_family); - } GetFontAndMinikinPaint(run.style, &font, &paint); - breaker_.addStyleRun(&paint, collection_map.at(run.style.font_family), font, - run.start, run.end, false); + breaker_.addStyleRun(&paint, + font_collection_->GetMinikinFontCollectionForFamily( + run.style.font_family), + font, run.start, run.end, false); } } @@ -240,7 +236,8 @@ void Paragraph::Layout(double width, bool force) { int bidiFlags = 0; layout.doLayout(text_.data(), layout_start, layout_end - layout_start, text_.size(), bidiFlags, font, minikin_paint, - collection_map.at(run.style.font_family)); + font_collection_->GetMinikinFontCollectionForFamily( + run.style.font_family)); const size_t glyph_count = layout.nGlyphs(); size_t blob_start = 0; // Each blob. @@ -445,6 +442,8 @@ void Paragraph::SetFontCollection(FontCollection* font_collection) { font_collection_ = font_collection; } +// The x,y coordinates will be the very top left corner of the rendered +// paragraph. void Paragraph::Paint(SkCanvas* canvas, double x, double y) { for (const auto& record : records_) { SkPaint paint; From 45dd415ba561a3ca587db51812c0bfdc6d7351bb Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 30 Jun 2017 13:39:24 -0700 Subject: [PATCH 312/364] Add low memory setting on FontCollection. Only remove trailing whitespace at end of line, and do not justify last line. Change-Id: Iee32003624862b3c7f5f2d0e999ef72719302551 --- engine/src/flutter/src/font_collection.cc | 32 ++++++++++++++----- engine/src/flutter/src/font_collection.h | 9 +++++- engine/src/flutter/src/paragraph.cc | 8 +++-- .../flutter/tests/txt/paragraph_unittests.cc | 4 +-- 4 files changed, 38 insertions(+), 15 deletions(-) diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index eb0a793a42..ca8132e7c6 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -100,13 +100,31 @@ bool FontCollection::HasFamily(const std::string family) const { void FontCollection::FlushCache() { minikin_font_collection_map_.clear(); + lru_tracker_.clear(); } void FontCollection::SetCacheCapacity(const size_t cap) { cache_capacity_ = cap; } -// TODO(garyq): Rework this to use font fallback system. +void FontCollection::SetLowMemoryMode(bool mode, size_t cap) { + cache_capacity_ = cap; + if (mode) { + cache_method_ = CacheMethod::kLRU; + TrimCache(); + } else { + cache_method_ = CacheMethod::kUnlimited; + } +} + +void FontCollection::TrimCache() { + while (minikin_font_collection_map_.size() > cache_capacity_) { + std::string family_to_evict = lru_tracker_.back(); + lru_tracker_.pop_back(); + minikin_font_collection_map_.erase(family_to_evict); + } +} + const std::string FontCollection::ProcessFamilyName(const std::string& family) { #ifdef DIRECTORY_FONT_MANAGER_AVAILABLE return family.length() == 0 ? DEFAULT_FAMILY_NAME : family; @@ -178,15 +196,13 @@ FontCollection::GetMinikinFontCollectionForFamily(const std::string& family) { } // Maintain LRU and evict old fonts no longer used. + + lru_tracker_.remove(processed_family_name); + lru_tracker_.push_front(processed_family_name); if (cache_method_ == CacheMethod::kLRU) { - lru_tracker_.remove(processed_family_name); - lru_tracker_.push_front(processed_family_name); - if (lru_tracker_.size() > cache_capacity_) { - std::string family_to_evict = lru_tracker_.back(); - lru_tracker_.pop_back(); - minikin_font_collection_map_.erase(family_to_evict); - } + TrimCache(); } + return minikin_font_collection_map_[processed_family_name]; } diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index efc1dab732..b5ba03ea92 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -18,6 +18,7 @@ #define LIB_TXT_SRC_FONT_COLLECTION_H_ #define DEFAULT_FAMILY_NAME "Roboto" +#define DEFAULT_CACHE_CAPACITY 20 #include #include @@ -75,13 +76,17 @@ class FontCollection { void SetCacheCapacity(const size_t cap); + // Call this to limit memory usage by cached fonts. SetLowMemoryMode() will + // enable default LRU policy and flush fonts beyond capacity. + void SetLowMemoryMode(bool mode = true, size_t cap = DEFAULT_CACHE_CAPACITY); + private: std::vector> skia_font_managers_; // Cache the names because GetFamilyNames() can be frequently called. std::set family_names_; CacheMethod cache_method_ = CacheMethod::kUnlimited; std::list lru_tracker_; - size_t cache_capacity_ = 20; + size_t cache_capacity_ = DEFAULT_CACHE_CAPACITY; // Cache minikin font collections to prevent slow disk reads. // TODO(garyq): Implement optional low-memory optimized system to prevent @@ -95,6 +100,8 @@ class FontCollection { const std::string ProcessFamilyName(const std::string& family); + void TrimCache(); + static const std::string GetDefaultFamilyName() { return DEFAULT_FAMILY_NAME; }; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 848bda5d54..9a575537b0 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -252,8 +252,10 @@ void Paragraph::Layout(double width, bool force) { // Check if we should remove trailing whitespace of blobs. size_t trailing_length = 0; - while (minikin::isWordSpace( - text_[character_index + blob_length - trailing_length - 1])) { + while ( + minikin::isWordSpace( + text_[character_index + blob_length - trailing_length - 1]) && + layout_end == next_break) { ++trailing_length; } @@ -307,7 +309,7 @@ void Paragraph::Layout(double width, bool force) { paint.getFontMetrics(&metrics); // Apply additional word spacing if the text is justified. if (paragraph_style_.text_align == TextAlign::justify && - buffer_sizes.size() > 0) { + buffer_sizes.size() > 0 && character_index != text_.size()) { JustifyLine(buffers, buffer_sizes, word_count, character_index); } records_.push_back( diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 187ccfa302..0c8b7e5924 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -567,9 +567,7 @@ TEST_F(RenderTest, JustifyAlignParagraph) { "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " - "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " - "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " - "mollit anim id est laborum."; + "velit esse cillum dolore eu fugiat."; auto icu_text = icu::UnicodeString::fromUTF8(text); std::u16string u16_text(icu_text.getBuffer(), icu_text.getBuffer() + icu_text.length()); From 42179e540389af77008319745f1fe933d9ed8384 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 5 Jul 2017 12:16:45 -0700 Subject: [PATCH 313/364] Switch to fuchsia/third_party/benchmark Change-Id: I40a9dadc1e910d4eb31085a71a372e2144d2d03d --- engine/src/flutter/benchmarks/BUILD.gn | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/benchmarks/BUILD.gn b/engine/src/flutter/benchmarks/BUILD.gn index 184d2a5a0b..7c5c6c17b0 100644 --- a/engine/src/flutter/benchmarks/BUILD.gn +++ b/engine/src/flutter/benchmarks/BUILD.gn @@ -14,6 +14,7 @@ executable("benchmarks") { output_name = "txt_benchmarks" + testonly = true include_dirs = [ "//lib/txt/src", @@ -37,7 +38,7 @@ executable("benchmarks") { "//flutter/fml", "//lib/txt/shims", "//lib/txt", - "//build/secondary/testing/benchmark", + "//third_party/benchmark", "//third_party/skia", "//third_party/harfbuzz", "//lib/txt/libs/minikin", From b6c6f1780ec7fcc335db12127cb713e760827010 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 5 Jul 2017 16:07:55 -0700 Subject: [PATCH 314/364] Implement wavy text decoration. Change-Id: Ie28dc4e833a24a9661e72f32f54a3e7489f81417 --- engine/src/flutter/src/paragraph.cc | 82 +++++++++++++------ engine/src/flutter/src/paragraph.h | 19 +++++ engine/src/flutter/src/styled_runs.h | 1 + engine/src/flutter/src/text_style.cc | 8 ++ engine/src/flutter/src/text_style.h | 1 + .../flutter/tests/txt/paragraph_unittests.cc | 78 ++++++++++++++++++ 6 files changed, 166 insertions(+), 23 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 9a575537b0..8f4221e618 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -351,8 +351,7 @@ void Paragraph::Layout(double width, bool force) { letter_spacing_offset = 0.0f; word_count = 0; line_width = 0.0f; - // TODO(abarth): Use the line height, which is something like the max - // font_size for runs in this line times the paragraph's line height. + character_index = layout_end; break_index += 1; lines_++; } else { @@ -472,9 +471,17 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, // This is set to 2 for the double line style int decoration_count = 1; + std::vector wave_coords; + + double width = blob->bounds().fRight + blob->bounds().fLeft; + + paint.setStrokeWidth(metrics.fUnderlineThickness * + style.decoration_thickness); + switch (style.decoration_style) { - case TextDecorationStyle::kSolid: + case TextDecorationStyle::kSolid: { break; + } case TextDecorationStyle::kDouble: { decoration_count = 2; break; @@ -496,42 +503,71 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, break; } case TextDecorationStyle::kWavy: { - // TODO(garyq): Wave currently does a random wave instead of an ordered - // wave. - const SkScalar intervals[] = {1}; - size_t count = sizeof(intervals) / sizeof(intervals[0]); - paint.setPathEffect(SkPathEffect::MakeCompose( - SkDashPathEffect::Make(intervals, count, 0.0f), - SkDiscretePathEffect::Make(metrics.fAvgCharWidth / 10.0f, - metrics.fAvgCharWidth / 10.0f))); + int wave_count = 0; + double x_start = 0; + double y_top = -metrics.fUnderlineThickness; + double y_bottom = metrics.fUnderlineThickness; + while (x_start + metrics.fUnderlineThickness * 2 < x + width) { + wave_coords.push_back( + WaveCoordinates(x_start, wave_count % 2 == 0 ? y_bottom : y_top, + x_start + metrics.fUnderlineThickness * 2, + wave_count % 2 == 0 ? y_top : y_bottom)); + x_start += metrics.fUnderlineThickness * 2; + ++wave_count; + } break; } } - double width = blob->bounds().fRight + blob->bounds().fLeft; - + // Use a for loop for "kDouble" decoration style for (int i = 0; i < decoration_count; i++) { double y_offset = i * metrics.fUnderlineThickness * 3.0f; + // Underline if (style.decoration & 0x1) { - paint.setStrokeWidth(metrics.fUnderlineThickness); - canvas->drawLine(x, y + metrics.fUnderlineThickness + y_offset, - x + width, y + metrics.fUnderlineThickness + y_offset, - paint); + if (style.decoration_style != TextDecorationStyle::kWavy) + canvas->drawLine(x, y + metrics.fUnderlineThickness + y_offset, + x + width, + y + metrics.fUnderlineThickness + y_offset, paint); + else + PaintWavyDecoration(canvas, wave_coords, paint, x, y, + metrics.fUnderlineThickness, width); } + // Overline if (style.decoration & 0x2) { - paint.setStrokeWidth(metrics.fUnderlineThickness); - canvas->drawLine(x, y + metrics.fAscent + y_offset, x + width, - y + metrics.fAscent + y_offset, paint); + if (style.decoration_style != TextDecorationStyle::kWavy) + canvas->drawLine(x, y + metrics.fAscent + y_offset, x + width, + y + metrics.fAscent + y_offset, paint); + else + PaintWavyDecoration(canvas, wave_coords, paint, x, y, metrics.fAscent, + width); } + // Strikethrough if (style.decoration & 0x4) { - paint.setStrokeWidth(metrics.fUnderlineThickness); - canvas->drawLine(x, y - metrics.fXHeight / 2 + y_offset, x + width, - y - metrics.fXHeight / 2 + y_offset, paint); + if (style.decoration_style != TextDecorationStyle::kWavy) + canvas->drawLine(x, y - metrics.fXHeight / 2 + y_offset, x + width, + y - metrics.fXHeight / 2 + y_offset, paint); + else + PaintWavyDecoration(canvas, wave_coords, paint, x, y, + -metrics.fXHeight / 2, width); } } } } +void Paragraph::PaintWavyDecoration(SkCanvas* canvas, + std::vector wave_coords, + SkPaint paint, + double x, + double y, + double y_offset, + double width) { + for (size_t i = 0; i < wave_coords.size(); ++i) { + WaveCoordinates coords = wave_coords[i]; + canvas->drawLine(x + coords.x_start, y + y_offset + coords.y_start, + x + coords.x_end, y + y_offset + coords.y_end, paint); + } +} + int Paragraph::GetLineCount() const { return lines_; } diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 97e30dae51..85b45811eb 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -70,6 +70,7 @@ class Paragraph { FRIEND_TEST(RenderTest, RightAlignParagraph); FRIEND_TEST(RenderTest, CenterAlignParagraph); FRIEND_TEST(RenderTest, JustifyAlignParagraph); + FRIEND_TEST(RenderTest, DecorationsParagraph); FRIEND_TEST(RenderTest, ItalicsParagraph); std::vector text_; @@ -89,6 +90,16 @@ class Paragraph { double ideographic_baseline_ = FLT_MAX; bool needs_layout_ = true; + struct WaveCoordinates { + double x_start; + double y_start; + double x_end; + double y_end; + + WaveCoordinates(double x_s, double y_s, double x_e, double y_e) + : x_start(x_s), y_start(y_s), x_end(x_e), y_end(y_e) {} + }; + void SetText(std::vector text, StyledRuns runs); void SetParagraphStyle(const ParagraphStyle& style); @@ -111,6 +122,14 @@ class Paragraph { SkPaint::FontMetrics metrics, SkTextBlob* blob); + void PaintWavyDecoration(SkCanvas* canvas, + std::vector wave_coords, + SkPaint paint, + double x, + double y, + double y_offset, + double width); + FTL_DISALLOW_COPY_AND_ASSIGN(Paragraph); }; diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index 4942b9cc20..eedd9e7a89 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -64,6 +64,7 @@ class StyledRuns { FRIEND_TEST(RenderTest, RightAlignParagraph); FRIEND_TEST(RenderTest, CenterAlignParagraph); FRIEND_TEST(RenderTest, JustifyAlignParagraph); + FRIEND_TEST(RenderTest, DecorationsParagraph); FRIEND_TEST(RenderTest, ItalicsParagraph); struct IndexedRun { diff --git a/engine/src/flutter/src/text_style.cc b/engine/src/flutter/src/text_style.cc index 692176c687..7965318cd6 100644 --- a/engine/src/flutter/src/text_style.cc +++ b/engine/src/flutter/src/text_style.cc @@ -24,6 +24,14 @@ namespace txt { bool TextStyle::equals(const TextStyle& other) const { if (color != other.color) return false; + if (decoration != other.decoration) + return false; + if (decoration_color != other.decoration_color) + return false; + if (decoration_style != other.decoration_style) + return false; + if (decoration_thickness != other.decoration_thickness) + return false; if (font_weight != other.font_weight) return false; if (font_style != other.font_style) diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index 7692c7a58c..8ed552dd80 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -33,6 +33,7 @@ class TextStyle { TextDecoration decoration = TextDecoration::kNone; SkColor decoration_color = SK_ColorWHITE; TextDecorationStyle decoration_style = TextDecorationStyle::kSolid; + double decoration_thickness = 1.0; FontWeight font_weight = FontWeight::w400; FontStyle font_style = FontStyle::normal; bool fake_bold = false; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 0c8b7e5924..7509e2e05d 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -636,6 +636,84 @@ TEST_F(RenderTest, JustifyAlignParagraph) { ASSERT_TRUE(Snapshot()); } +TEST_F(RenderTest, DecorationsParagraph) { + txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 14; + paragraph_style.text_align = TextAlign::left; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.font_size = 26; + text_style.letter_spacing = 0; + text_style.word_spacing = 5; + text_style.color = SK_ColorBLACK; + text_style.height = 2; + text_style.decoration = txt::TextDecoration(0x1 | 0x2 | 0x4); + text_style.decoration_style = txt::TextDecorationStyle::kSolid; + text_style.decoration_color = SK_ColorBLACK; + builder.PushStyle(text_style); + builder.AddText("This text should be"); + + text_style.decoration_style = txt::TextDecorationStyle::kDouble; + text_style.decoration_color = SK_ColorBLUE; + builder.PushStyle(text_style); + builder.AddText(" decorated even when"); + + text_style.decoration_style = txt::TextDecorationStyle::kDotted; + text_style.decoration_color = SK_ColorBLACK; + builder.PushStyle(text_style); + builder.AddText(" wrapped around to"); + + text_style.decoration_style = txt::TextDecorationStyle::kDashed; + text_style.decoration_color = SK_ColorBLACK; + builder.PushStyle(text_style); + builder.AddText(" the next line."); + + text_style.decoration_style = txt::TextDecorationStyle::kWavy; + text_style.decoration_color = SK_ColorRED; + builder.PushStyle(text_style); + + builder.AddText(" Otherwise, bad things happen."); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth() - 100); + + paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_EQ(paragraph->runs_.size(), 5ull); + ASSERT_EQ(paragraph->records_.size(), 6ull); + + for (size_t i = 0; i < 6; ++i) { + ASSERT_EQ(paragraph->records_[i].style().decoration, + txt::TextDecoration(0x1 | 0x2 | 0x4)); + } + + ASSERT_EQ(paragraph->records_[0].style().decoration_style, + txt::TextDecorationStyle::kSolid); + ASSERT_EQ(paragraph->records_[1].style().decoration_style, + txt::TextDecorationStyle::kDouble); + ASSERT_EQ(paragraph->records_[2].style().decoration_style, + txt::TextDecorationStyle::kDotted); + ASSERT_EQ(paragraph->records_[3].style().decoration_style, + txt::TextDecorationStyle::kDashed); + ASSERT_EQ(paragraph->records_[4].style().decoration_style, + txt::TextDecorationStyle::kDashed); + ASSERT_EQ(paragraph->records_[5].style().decoration_style, + txt::TextDecorationStyle::kWavy); + + ASSERT_EQ(paragraph->records_[0].style().decoration_color, SK_ColorBLACK); + ASSERT_EQ(paragraph->records_[1].style().decoration_color, SK_ColorBLUE); + ASSERT_EQ(paragraph->records_[2].style().decoration_color, SK_ColorBLACK); + ASSERT_EQ(paragraph->records_[3].style().decoration_color, SK_ColorBLACK); + ASSERT_EQ(paragraph->records_[4].style().decoration_color, SK_ColorBLACK); + ASSERT_EQ(paragraph->records_[5].style().decoration_color, SK_ColorRED); + + ASSERT_TRUE(Snapshot()); +} + TEST_F(RenderTest, ItalicsParagraph) { const char* text = "I am Italicized! "; auto icu_text = icu::UnicodeString::fromUTF8(text); From 4ed0e488daed26d0c5fedf6cdff4f2d64aa05cfc Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 6 Jul 2017 11:36:00 -0700 Subject: [PATCH 315/364] Add chinese tests, underline fix, cleanup, move fonts to third_party/fonts. Change-Id: I1b246534cd364c9e7e3fec3f6bcbe202932fee44 --- engine/src/flutter/src/font_collection.h | 4 - engine/src/flutter/src/paragraph.cc | 12 +- engine/src/flutter/src/paragraph.h | 1 + engine/src/flutter/src/styled_runs.h | 1 + .../flutter/tests/txt/paragraph_unittests.cc | 44 +++ engine/src/flutter/third_party/fonts/Bold.ttf | Bin 0 -> 884 bytes engine/src/flutter/third_party/fonts/Bold.ttx | 254 +++++++++++++++ .../flutter/third_party/fonts/BoldItalic.ttf | Bin 0 -> 956 bytes .../flutter/third_party/fonts/BoldItalic.ttx | 254 +++++++++++++++ .../third_party/fonts/ColorEmojiFont.ttf | Bin 0 -> 996 bytes .../third_party/fonts/ColorEmojiFont.ttx | 238 ++++++++++++++ .../fonts/ColorTextMixedEmojiFont.ttf | Bin 0 -> 860 bytes .../fonts/ColorTextMixedEmojiFont.ttx | 212 ++++++++++++ .../src/flutter/third_party/fonts/Emoji.ttf | Bin 0 -> 912 bytes .../src/flutter/third_party/fonts/Emoji.ttx | 238 ++++++++++++++ .../fonts/HomemadeApple-LICENSE.txt | 202 ++++++++++++ .../third_party/fonts/HomemadeApple.ttf | Bin 0 -> 110080 bytes .../src/flutter/third_party/fonts/Italic.ttf | Bin 0 -> 908 bytes .../src/flutter/third_party/fonts/Italic.ttx | 254 +++++++++++++++ engine/src/flutter/third_party/fonts/Ja.ttf | Bin 0 -> 1300 bytes engine/src/flutter/third_party/fonts/Ja.ttx | 306 ++++++++++++++++++ .../third_party/fonts/Katibeh-LICENSE.txt | 92 ++++++ .../third_party/fonts/Katibeh-Regular.ttf | Bin 0 -> 188360 bytes engine/src/flutter/third_party/fonts/Ko.ttf | Bin 0 -> 824 bytes engine/src/flutter/third_party/fonts/Ko.ttx | 224 +++++++++++++ .../flutter/third_party/fonts/MultiAxis.ttf | Bin 0 -> 844 bytes .../flutter/third_party/fonts/MultiAxis.ttx | 223 +++++++++++++ .../third_party/fonts/NoCmapFormat14.ttf | Bin 0 -> 844 bytes .../third_party/fonts/NoCmapFormat14.ttx | 207 ++++++++++++ .../flutter/third_party/fonts/NoGlyphFont.ttf | Bin 0 -> 712 bytes .../flutter/third_party/fonts/NoGlyphFont.ttx | 199 ++++++++++++ .../src/flutter/third_party/fonts/Regular.ttf | Bin 0 -> 984 bytes .../src/flutter/third_party/fonts/Regular.ttx | 263 +++++++++++++++ .../third_party/fonts/Roboto-Black.ttf | Bin 0 -> 171480 bytes .../third_party/fonts/Roboto-BlackItalic.ttf | Bin 0 -> 177552 bytes .../flutter/third_party/fonts/Roboto-Bold.ttf | Bin 0 -> 170760 bytes .../third_party/fonts/Roboto-BoldItalic.ttf | Bin 0 -> 174952 bytes .../third_party/fonts/Roboto-Italic.ttf | Bin 0 -> 173932 bytes .../third_party/fonts/Roboto-Light.ttf | Bin 0 -> 170420 bytes .../third_party/fonts/Roboto-LightItalic.ttf | Bin 0 -> 176616 bytes .../third_party/fonts/Roboto-Medium.ttf | Bin 0 -> 172064 bytes .../third_party/fonts/Roboto-MediumItalic.ttf | Bin 0 -> 176864 bytes .../third_party/fonts/Roboto-Regular.ttf | Bin 0 -> 171676 bytes .../flutter/third_party/fonts/Roboto-Thin.ttf | Bin 0 -> 171904 bytes .../third_party/fonts/Roboto-ThinItalic.ttf | Bin 0 -> 176300 bytes .../fonts/SourceHanSerif-LICENSE.txt | 92 ++++++ .../third_party/fonts/TextEmojiFont.ttf | Bin 0 -> 908 bytes .../third_party/fonts/TextEmojiFont.ttx | 239 ++++++++++++++ .../third_party/fonts/UnicodeBMPOnly.ttf | Bin 0 -> 696 bytes .../third_party/fonts/UnicodeBMPOnly.ttx | 177 ++++++++++ .../third_party/fonts/UnicodeBMPOnly2.ttf | Bin 0 -> 696 bytes .../third_party/fonts/UnicodeBMPOnly2.ttx | 177 ++++++++++ .../flutter/third_party/fonts/UnicodeUCS4.ttf | Bin 0 -> 744 bytes .../flutter/third_party/fonts/UnicodeUCS4.ttx | 181 +++++++++++ .../fonts/VariationSelectorTest-Regular.ttf | Bin 0 -> 1008 bytes .../fonts/VariationSelectorTest-Regular.ttx | 229 +++++++++++++ .../src/flutter/third_party/fonts/ZhHans.ttf | Bin 0 -> 1176 bytes .../src/flutter/third_party/fonts/ZhHans.ttx | 282 ++++++++++++++++ .../src/flutter/third_party/fonts/ZhHant.ttf | Bin 0 -> 984 bytes .../src/flutter/third_party/fonts/ZhHant.ttx | 240 ++++++++++++++ .../src/flutter/third_party/fonts/emoji.xml | 31 ++ .../src/flutter/third_party/fonts/itemize.xml | 39 +++ 62 files changed, 4903 insertions(+), 12 deletions(-) create mode 100644 engine/src/flutter/third_party/fonts/Bold.ttf create mode 100644 engine/src/flutter/third_party/fonts/Bold.ttx create mode 100644 engine/src/flutter/third_party/fonts/BoldItalic.ttf create mode 100644 engine/src/flutter/third_party/fonts/BoldItalic.ttx create mode 100644 engine/src/flutter/third_party/fonts/ColorEmojiFont.ttf create mode 100644 engine/src/flutter/third_party/fonts/ColorEmojiFont.ttx create mode 100644 engine/src/flutter/third_party/fonts/ColorTextMixedEmojiFont.ttf create mode 100644 engine/src/flutter/third_party/fonts/ColorTextMixedEmojiFont.ttx create mode 100644 engine/src/flutter/third_party/fonts/Emoji.ttf create mode 100644 engine/src/flutter/third_party/fonts/Emoji.ttx create mode 100644 engine/src/flutter/third_party/fonts/HomemadeApple-LICENSE.txt create mode 100644 engine/src/flutter/third_party/fonts/HomemadeApple.ttf create mode 100644 engine/src/flutter/third_party/fonts/Italic.ttf create mode 100644 engine/src/flutter/third_party/fonts/Italic.ttx create mode 100644 engine/src/flutter/third_party/fonts/Ja.ttf create mode 100644 engine/src/flutter/third_party/fonts/Ja.ttx create mode 100644 engine/src/flutter/third_party/fonts/Katibeh-LICENSE.txt create mode 100644 engine/src/flutter/third_party/fonts/Katibeh-Regular.ttf create mode 100644 engine/src/flutter/third_party/fonts/Ko.ttf create mode 100644 engine/src/flutter/third_party/fonts/Ko.ttx create mode 100644 engine/src/flutter/third_party/fonts/MultiAxis.ttf create mode 100644 engine/src/flutter/third_party/fonts/MultiAxis.ttx create mode 100644 engine/src/flutter/third_party/fonts/NoCmapFormat14.ttf create mode 100644 engine/src/flutter/third_party/fonts/NoCmapFormat14.ttx create mode 100644 engine/src/flutter/third_party/fonts/NoGlyphFont.ttf create mode 100644 engine/src/flutter/third_party/fonts/NoGlyphFont.ttx create mode 100644 engine/src/flutter/third_party/fonts/Regular.ttf create mode 100644 engine/src/flutter/third_party/fonts/Regular.ttx create mode 100644 engine/src/flutter/third_party/fonts/Roboto-Black.ttf create mode 100644 engine/src/flutter/third_party/fonts/Roboto-BlackItalic.ttf create mode 100644 engine/src/flutter/third_party/fonts/Roboto-Bold.ttf create mode 100644 engine/src/flutter/third_party/fonts/Roboto-BoldItalic.ttf create mode 100644 engine/src/flutter/third_party/fonts/Roboto-Italic.ttf create mode 100644 engine/src/flutter/third_party/fonts/Roboto-Light.ttf create mode 100644 engine/src/flutter/third_party/fonts/Roboto-LightItalic.ttf create mode 100644 engine/src/flutter/third_party/fonts/Roboto-Medium.ttf create mode 100644 engine/src/flutter/third_party/fonts/Roboto-MediumItalic.ttf create mode 100644 engine/src/flutter/third_party/fonts/Roboto-Regular.ttf create mode 100644 engine/src/flutter/third_party/fonts/Roboto-Thin.ttf create mode 100644 engine/src/flutter/third_party/fonts/Roboto-ThinItalic.ttf create mode 100644 engine/src/flutter/third_party/fonts/SourceHanSerif-LICENSE.txt create mode 100644 engine/src/flutter/third_party/fonts/TextEmojiFont.ttf create mode 100644 engine/src/flutter/third_party/fonts/TextEmojiFont.ttx create mode 100644 engine/src/flutter/third_party/fonts/UnicodeBMPOnly.ttf create mode 100644 engine/src/flutter/third_party/fonts/UnicodeBMPOnly.ttx create mode 100644 engine/src/flutter/third_party/fonts/UnicodeBMPOnly2.ttf create mode 100644 engine/src/flutter/third_party/fonts/UnicodeBMPOnly2.ttx create mode 100644 engine/src/flutter/third_party/fonts/UnicodeUCS4.ttf create mode 100644 engine/src/flutter/third_party/fonts/UnicodeUCS4.ttx create mode 100644 engine/src/flutter/third_party/fonts/VariationSelectorTest-Regular.ttf create mode 100644 engine/src/flutter/third_party/fonts/VariationSelectorTest-Regular.ttx create mode 100644 engine/src/flutter/third_party/fonts/ZhHans.ttf create mode 100644 engine/src/flutter/third_party/fonts/ZhHans.ttx create mode 100644 engine/src/flutter/third_party/fonts/ZhHant.ttf create mode 100644 engine/src/flutter/third_party/fonts/ZhHant.ttx create mode 100644 engine/src/flutter/third_party/fonts/emoji.xml create mode 100644 engine/src/flutter/third_party/fonts/itemize.xml diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index b5ba03ea92..865af8b380 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -89,8 +89,6 @@ class FontCollection { size_t cache_capacity_ = DEFAULT_CACHE_CAPACITY; // Cache minikin font collections to prevent slow disk reads. - // TODO(garyq): Implement optional low-memory optimized system to prevent - // fonts building up in memory. std::unordered_map> minikin_font_collection_map_; @@ -105,8 +103,6 @@ class FontCollection { static const std::string GetDefaultFamilyName() { return DEFAULT_FAMILY_NAME; }; - - // TODO(chinmaygarde): Caches go here. }; } // namespace txt diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 8f4221e618..3b07c4ee70 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -98,7 +98,6 @@ void GetFontAndMinikinPaint(const TextStyle& style, paint->size = style.font_size; paint->letterSpacing = style.letter_spacing; paint->wordSpacing = style.word_spacing; - // TODO(abarth): word_spacing. } void GetPaint(const TextStyle& style, SkPaint* paint) { @@ -187,8 +186,6 @@ void Paragraph::Layout(double width, bool force) { for (size_t i = 0; i < x_queue.size(); ++i) { record_index = records_.size() - (x_queue.size() - i); records_[record_index].SetOffset(SkPoint::Make(x_queue[i], y)); - // TODO(garyq): Fix alignment for paragraphs with multiple styles per - // line. switch (paragraph_style_.text_align) { case TextAlign::left: break; @@ -303,8 +300,6 @@ void Paragraph::Layout(double width, bool force) { // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the // color stayed the same. - // TODO(garyq): Ensure that the typeface does not change throughout a - // run. SkPaint::FontMetrics metrics; paint.getFontMetrics(&metrics); // Apply additional word spacing if the text is justified. @@ -471,6 +466,7 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, // This is set to 2 for the double line style int decoration_count = 1; + // Filled when drawing wavy decorations. std::vector wave_coords; double width = blob->bounds().fRight + blob->bounds().fLeft; @@ -525,9 +521,9 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, // Underline if (style.decoration & 0x1) { if (style.decoration_style != TextDecorationStyle::kWavy) - canvas->drawLine(x, y + metrics.fUnderlineThickness + y_offset, - x + width, - y + metrics.fUnderlineThickness + y_offset, paint); + canvas->drawLine(x, y + metrics.fUnderlinePosition + y_offset, + x + width, y + metrics.fUnderlinePosition + y_offset, + paint); else PaintWavyDecoration(canvas, wave_coords, paint, x, y, metrics.fUnderlineThickness, width); diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 85b45811eb..04ed7e7a60 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -72,6 +72,7 @@ class Paragraph { FRIEND_TEST(RenderTest, JustifyAlignParagraph); FRIEND_TEST(RenderTest, DecorationsParagraph); FRIEND_TEST(RenderTest, ItalicsParagraph); + FRIEND_TEST(RenderTest, ChineseParagraph); std::vector text_; StyledRuns runs_; diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index eedd9e7a89..d61ea1c57f 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -66,6 +66,7 @@ class StyledRuns { FRIEND_TEST(RenderTest, JustifyAlignParagraph); FRIEND_TEST(RenderTest, DecorationsParagraph); FRIEND_TEST(RenderTest, ItalicsParagraph); + FRIEND_TEST(RenderTest, ChineseParagraph); struct IndexedRun { size_t style_index = 0; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 7509e2e05d..5cb2a75bc6 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -750,4 +750,48 @@ TEST_F(RenderTest, ItalicsParagraph) { ASSERT_TRUE(Snapshot()); } +TEST_F(RenderTest, ChineseParagraph) { + const char* text = + "左線読設重説切後碁給能上目秘使約。満毎冠行来昼本可必図将発確年。今属場育" + "図情闘陰野高備込制詩西校客。審対江置講今固残必託地集済決維駆年策。立得庭" + "際輝求佐抗蒼提夜合逃表。注統天言件自謙雅載報紙喪。作画稿愛器灯女書利変探" + "訃第金線朝開化建。子戦年帝励害表月幕株漠新期刊人秘。図的海力生禁挙保天戦" + "聞条年所在口。"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 14; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + text_style.font_size = 35; + text_style.letter_spacing = 2; + text_style.font_family = "Source Han Serif CN"; + text_style.decoration = txt::TextDecoration(0x1 | 0x2 | 0x4); + text_style.decoration_style = txt::TextDecorationStyle::kSolid; + text_style.decoration_color = SK_ColorBLACK; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth() - 100); + + paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_EQ(paragraph->records_.size(), 7ull); + + ASSERT_TRUE(Snapshot()); +} + } // namespace txt diff --git a/engine/src/flutter/third_party/fonts/Bold.ttf b/engine/src/flutter/third_party/fonts/Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..44ef33cf89e6ea8e913879981a1ce110d0122d22 GIT binary patch literal 884 zcmZQzWME+6VrXDsW>D}C);G%Z%Cco(VANn>U`R;LO)Oyj{?D0#fpGx?1A|L?PGuSc zD+2=q1LGeC28N!D)Wj6#rl}bW3=C@+7#PelGEx&+mM|Sjnb5rfy1OG8FFoD#c zDabD_`M-m~h=GAQ1SAi3DV9($Na|6f + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + BoldFont Test + + + Bold + + + BoldFont Test + + + BoldFontTest-Bold + + + BoldFont Test + + + Bold + + + BoldFont Test + + + BoldFontTest-Bold + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/BoldItalic.ttf b/engine/src/flutter/third_party/fonts/BoldItalic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..10c7b02b955c0f67c51f83820715a3a1a3274798 GIT binary patch literal 956 zcmZQzWME+6VrXDsW>D}C);G%Z&a!1-VANn>U`R;LO)Oyj{?D0#fpGx?1A|L?PGuSc zD+2=q1LGeC28N!D)Wj6#rrGBi7#P+tFff>9WTYmtEMYpzz`*c?fq_9KBe$f2`6%N> z1_s6s1_lPPoc!cOhD!|V85kHr@?yD(6$K1uxVJJeFmf<3Fev0D=BBnVAGcs&VCrCC zU=%6HFE07NgTaV_fq4!{9_&^|28Jay_s_@k+k9nUWPSm1%_Y(4XTfyDVL1>D#q11B zP!=Nt1M`dj77PrGUl?K;r!&NYO@c~-DMqje7szX1J`)2EgA7AC0|SFC_jIrbGgA=L z9tKthPNpuV2nGfQZwSp8$6&;$15yDF7!ZR2Y!-yYz`zjd9qz~Az@W&?$gJ?+g5d=7 z3x*Rgdl@tQ}39SigrVXrNaAb^vJA2e%nXbyoD7T%Y7ACTHWPygLjsh|f+Wty zV8u}4l%JF0S(2EOne3LISE3M-T8t!wDhZO)MF=rCG2}DkFr+YeGL$eRGUPC1G9)v& rG2}DkF_bVUFoZCqG88kEU{!@rCrqC%R-Me?=wSH26_f`cY-ADunp&Dk literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/BoldItalic.ttx b/engine/src/flutter/third_party/fonts/BoldItalic.ttx new file mode 100644 index 0000000000..5de79fcb7f --- /dev/null +++ b/engine/src/flutter/third_party/fonts/BoldItalic.ttx @@ -0,0 +1,254 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + BoldItalicFont Test + + + BoldItalic + + + BoldItalicFont Test + + + BoldItalicFontTest-BoldItalic + + + BoldItalicFont Test + + + BoldItalic + + + BoldItalicFont Test + + + BoldItalicFontTest-BoldItalic + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/ColorEmojiFont.ttf b/engine/src/flutter/third_party/fonts/ColorEmojiFont.ttf new file mode 100644 index 0000000000000000000000000000000000000000..eee1c379f0314d1b2ce632a71bc62b6b19d6d82f GIT binary patch literal 996 zcmZQzWME+6VrXDsW>D}C);G#nlWxtxz^K8%z>tufn^>^byg!bCfpG!@10!d8PGuTc zJp(8mVtq> zgMop8Ehj%Yk%5naoq>UA4v3$dSW&=mgnKIk10x3m1A{_dVs7gHWp5=J7?=()FfcL| z7{_45r~^{L3L+pFVg`iG5b7Q7$Kb%Q?*D&gh5r@|CzxL_ zoM2!8+sDB8g=r7iXJD6sLW%)oHvDj66V zgyHf`4D1ZTAZr;I7+8?R*%+i4q!^eP7+E+O7#Y+UOrUHg20n%;D4PXIoQ=VRA;UR8 zC%?!wH$N-WEkCbBAtbf9Bq%k#G$*kLRR$!X3zcDTX2@sAVaR7FVsK^1Wyoj9V#s80 zW5{R7V<=%zU + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ColorEmojiFont Test + + + Regular + + + ColorEmojiFont Test + + + ColorEmojiFontTest-Regular + + + ColorEmojiFont Test + + + Regular + + + ColorEmojiFont Test + + + ColorEmojiFontTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/ColorTextMixedEmojiFont.ttf b/engine/src/flutter/third_party/fonts/ColorTextMixedEmojiFont.ttf new file mode 100644 index 0000000000000000000000000000000000000000..57ee330b79f66be79c74b7f18e323a178620df58 GIT binary patch literal 860 zcmZQzWME+6VrXDsW>D}C);G$KP2a}Az^K8%z>tufn^<6wqu|8Az&L?{fx#|4r!tL! z>HmKQ2F4o<3=CQssfj7f>)u{qU|?9oz`$UZk&&9nvV`d<0|Ubo1_lO|jNFn6ra*>W z3=E7N3=9k$Ir+(n415eS3=E7QJsi1-6$K1OxwkSfFmf<3Fev0D=B6IotLekQz{JA9 zz-UpBUtIEk2ZIp<1G5cC9_&^|28IjEZKucc+k9nUWPZWGz`$@xboyB^-6|>%qM?|b zfeFfDWME)^@!x`hf$G7RMm3=Fp1)4?j3 znSvN6Ft9RkFm*9SFfcH9Lukf01|votkP2210l}a!g|HYH7(%_n{TLh=6d02qJzyR_+0~5nP5EEpi0>eLk5Y52Apb1v1 z_6zJ}Mh3N?Q2(+s@G*#j1;GkI@r9QMQpLfL235ldiXSMOiGiI#2FhkZ5@%yjW>98e zW?*FDWME{lU~q%7nHcyO>Y!{EBylzdH-;YP{G9xvkkpD2-^_~C6xZDRtW3B3yb^_w z)Z&t$)b!Gv#3CF@Kq_>hN*J6O@)>d%@)?R4LKspRDi}%_d>JwsDi~53QW#travAa& zvKTTM+!*p1@)$}O6u_#A8A=#}7*ZM18A=&)7!nzZNHhgx6UYo*G*dw7g@J+L|5k7; Jfx;050|1+Vid6sr literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/ColorTextMixedEmojiFont.ttx b/engine/src/flutter/third_party/fonts/ColorTextMixedEmojiFont.ttx new file mode 100644 index 0000000000..461210bfd8 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/ColorTextMixedEmojiFont.ttx @@ -0,0 +1,212 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ColorTextMixedEmojiFont Test + + + Regular + + + ColorTextMixedEmojiFont Test + + + ColorTextMixedEmojiFontTest-Regular + + + ColorTextMixedEmojiFont Test + + + Regular + + + ColorTextMixedEmojiFont Test + + + ColorTextMixedEmojiFontTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/Emoji.ttf b/engine/src/flutter/third_party/fonts/Emoji.ttf new file mode 100644 index 0000000000000000000000000000000000000000..a3413b3e08f96ab5b2a0b5cffd1cc249026ffd40 GIT binary patch literal 912 zcmZQzWME+6VrXDsW>D}C);G$~OSfiVVANn>U`R;LO)OBdQJlrVz&L|}fuSxvr!tL! z<^O*M1}2bvQbuZG3iF0l8yFZE)-W(Im}O+7CbBGHI?BMn@PvVZK_w%%q=K27v4nwv zv4equK_DkTIgufRp@4ybNdm;rO{^$jILW=0fq{{Ofq_9GFEKZD+15FB3=B*?ATtW` zi%b6RU@&4}U@id3gWbx=z@YWyMsGa7%~u9S<`)bM3=Ee~O1`J!O1f(-*30}oip z2TVeA8Za<0fG`UKgTiA72ATCGoq_R7Is?cC#xI!+APn+1|01kGJ)L!VY48KvoVM=h=P2?!pXqMAj6;q zWiv7GF}Ok5EJ)&P3|b5!uDSVHnQr-cB?=*_#U(+h>7_Y|MQ}lom@ZV1!IdGGA)g_O zA(O$4A)g_Sp@cz!A%r27p_rkBA&4QBA)TR=A%`K6p$Lmgm^xiFmCPV-GBEt#3QE@y HHZlnSriqAK literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/Emoji.ttx b/engine/src/flutter/third_party/fonts/Emoji.ttx new file mode 100644 index 0000000000..3318c594ae --- /dev/null +++ b/engine/src/flutter/third_party/fonts/Emoji.ttx @@ -0,0 +1,238 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + EmojiFont Test + + + Regular + + + EmojiFont Test + + + EmojiFontTest-Regular + + + EmojiFont Test + + + Regular + + + EmojiFont Test + + + EmojiFontTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/HomemadeApple-LICENSE.txt b/engine/src/flutter/third_party/fonts/HomemadeApple-LICENSE.txt new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/HomemadeApple-LICENSE.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. diff --git a/engine/src/flutter/third_party/fonts/HomemadeApple.ttf b/engine/src/flutter/third_party/fonts/HomemadeApple.ttf new file mode 100644 index 0000000000000000000000000000000000000000..75d4fbcb8b50189a2b6c68c6b4aa32750075ddb1 GIT binary patch literal 110080 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

&!P!{83Vi#c(6Jylp5a8!w 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 E0E^T2{{R30 literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/Italic.ttf b/engine/src/flutter/third_party/fonts/Italic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..9593229f925d53632c3a1d8b28e538ed96d90937 GIT binary patch literal 908 zcmZQzWME+6VrXDsW>D}C);G$K%d%r&VANn>U`R;LO)Oyj{?D0#fpGx?1A|L?PGuSc zD+2=q1LGeC28N!D)Wj6#rm2Yx3=C@+7#PelGEx&+mM|Sjnb5pOVW#=(4FoD!R zDabD_`M-m~h=GAQ2P6-6D} zRt65HE~W?u1_o~k%^1gE#Ha&O0S*`tg8^(7gvG$X5b7Q7$Kc4I$jr#B@ZW;r1oI1q z6EJ%izcB3q`wZ+dhFA;;GKGV9($Na|6ft1}%mV z&yvKP%w)Ixyb^_w)Z!8d7eayrL1MZPE`ujS2}2@74nrnGGJ_jKK0_Wu34;Pd2tz7E dF+&N8EH;%eb-E}jnZd!!@P8{PO+(noBmfNCjZ^>t literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/Italic.ttx b/engine/src/flutter/third_party/fonts/Italic.ttx new file mode 100644 index 0000000000..1853bb6b26 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/Italic.ttx @@ -0,0 +1,254 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ItalicFont Test + + + Italic + + + ItalicFont Test + + + ItalicFontTest-Italic + + + ItalicFont Test + + + Italic + + + ItalicFont Test + + + ItalicFontTest-Italic + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/Ja.ttf b/engine/src/flutter/third_party/fonts/Ja.ttf new file mode 100644 index 0000000000000000000000000000000000000000..b3d4e848ecf02d71b1cdf7ddc2cc4e649a7ae1cd GIT binary patch literal 1300 zcmZQzWME+6VrXDsW>D}C);F5rkZ#Suz^K8%z>tufn^-Vq_4Y#y42)|S7#OY7b1Ksq zIRF1=U|{B9U|@Kck(!vo{Io2bfq`KS0|SFuMn-BP%Mzxe3=9lU7#J8-GIC2QSne>p zGB7Z9fcQE2$%%|Vn9La%m|lSRxrr48441jLGB7Z5FfcGE75%WEjdB7#M81r-M~6 zGX*hDU|?n7VCrIuU|?YIhR}?03`UGPAQh}20)jzd3SluYFob%C`!P5eIQ{?6tnlB0 z;RN#wh7&M*7{4&>0s9Q>GKN?J5accf29QM}49sAcW;5_HFff2(fSKVR$VzPx!3TDL zIfMyf`-7MaAnpF^7?_;ifw-&;rYjg2Ot&#Gm>y+dXo-f2GlJzo5zN4F0i=+DfkA+Q z!N3WELDm|$Fff2HD1Z&z7#Kj9fti89zypFASQr=#ydW6lT(Cte7#Ki~1zWg{fq{V^ zVll{akoo@W7#Kj9frEh|{wxGDurn|;zJ*{0HU@^KjS$Sh1$HpV(F_cn3=FeYKrjO@ z1LKzhFlJ!j273tX83t~UKiC=g7(^Ll7?c^b7z`OK80;C`7 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + JapaneseFont Test + + + Regular + + + JapaneseFont Test + + + JapaneseFontTest-Regular + + + JapaneseFont Test + + + Regular + + + JapaneseFont Test + + + JapaneseFontTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/Katibeh-LICENSE.txt b/engine/src/flutter/third_party/fonts/Katibeh-LICENSE.txt new file mode 100644 index 0000000000..b66a0c31aa --- /dev/null +++ b/engine/src/flutter/third_party/fonts/Katibeh-LICENSE.txt @@ -0,0 +1,92 @@ +Copyright 2015, 2016 KB-Studio (www.k-b-studio.com|tarobish@gmail.com). Copyright 2015, 2016 Lasse Fister (lasse@graphicore.de). Copyright 2015, 2016 Eduardo Tunni(edu@tipo.net.ar). +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/engine/src/flutter/third_party/fonts/Katibeh-Regular.ttf b/engine/src/flutter/third_party/fonts/Katibeh-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..ccbb8f0de2ad5c5afaec2fc8f5b642b804ab6928 GIT binary patch literal 188360 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

?NFxd&TwDS9yf-NUMs0TB_XcDl$@r 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�SoSe6fp%&#FtQwCIl;ihx{`G*0}JbV)~yUI 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 Ugrq<&1}2t9X3$;kOrZP%03NTxsQ>@~ literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/Ko.ttf b/engine/src/flutter/third_party/fonts/Ko.ttf new file mode 100644 index 0000000000000000000000000000000000000000..51f6c4ede8b4d02b18bfd591d2a478e13b5342b0 GIT binary patch literal 824 zcmZQzWME+6VrXDsW>D}C);AK(wwb}ez^K8%z>tufn^>?s*Xt4k1LG711_qb(oXRu? z=Kud07#N>0Ffh1fq$Z{?H_dToU|?9oz`$UZk&&9nvV`d<0|Ns{UL_;9q=IQ3qc{Tt zV+R8R15ZwVaw3BkgFOQS;|&l$H?g9C;W+nJ1_nkB1_lO&yu{p8WoLm71_mY_1_p*# z1^LA#|93DLF)%PofaJk$Wn^GD7bg@O&u{aUfsy$I0|NuYCDG|;!F0soNgx`E*%_Fi zEJg+f<`@4h7#JA8FvK!WXNU!x1eF9+j9?K~1_m(Az`(@7!yv;@&cMK6%RL>ef|)6Z zaRLJ?0|!$VQv?G8gExd`jAJlj1i6+0q#3LdW(JfK>K*RK;IKCLY7Dc&e+z~a%r6*D z!0ciC!n6nMGqB4TVxbUZ0y6^_D2y0b7%ads#KFMCz_d1ZGsEsbS7ShNfM5qr_hocp z*IEX3JJenVb_PBMQ3e?XWrR3LAK5&Rxf~2>Q2mSy{4ifIFfp(*@I%E}ki^*-#2CaF zm>C#ZI2jlj + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + KoreanFont Test + + + Regular + + + KoreanFont Test + + + KoreanFontTest-Regular + + + KoreanFont Test + + + Regular + + + KoreanFont Test + + + KoreanFontTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/MultiAxis.ttf b/engine/src/flutter/third_party/fonts/MultiAxis.ttf new file mode 100644 index 0000000000000000000000000000000000000000..1d687cb367d740ad61bf6e3c633ac76732d05c91 GIT binary patch literal 844 zcmZQzWME+6W@unwW-#y%);G$COP|ZYz-Yn1z>tufn^?fW!vNwhU|?X-Nh?b%dUx;M zKL!S75e5bZi}akzG_ZaK#w!dA3^Ez1i7Bkjb+Z^481^tQFqmazq$aW~VLHmd!0?5E zfk7oBx1@q8kRg_VfpG={0|Q%5esUrM9|JoB1LGMGKR29Oa=MHCI5FY7%?y~fy`3?+s(+pu=-$wc|5<(R|ZDr7Yqyx43|Ww zp9RrZBA31d(NN6JzyxJ6GB7Z|_;10$!1#qBmT@{mEZ8KdB$#3Zi-6RF!iRx@iGhbf zhM}B+fx(u0I#>lWQxM|>237_RrY@!k1_lOi2+bJBV8o~cQo#x$AQ)l>gv}7@9qz~A zz>vt0$gJ?+g5d=73x*R63}E{h7{4%qLQVnVGEhi?WtbVb7#J9M7+4q-7#J8>7+Aon z6aW8bU|>l6|Ns92Fdt+-I|CnB2Z+tUzyMYOw;jx5VBlbY#u@`7gAiOb69XrM5Y!wN zBylzdNd{>KW(GzUP6kE>6$TS1n~6b)Ap*)~K@w+UFk;B^EzK#(bgalMcFWHzQ3y#b zE`f`{86YW;jBZeBdTCB#5rZ#7DMJoJ2}34>BSQs4CPOiU8$&)r9zzL(0z(KxDnl_t z2^KZDb;0!LG6XTCGNgk|Ph==!U|?W|1keAiptJ;GqmZBw6JTIsU}6BJbDr{)k_>3r O!QzRbJUycXT?_y>tcG0x literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/MultiAxis.ttx b/engine/src/flutter/third_party/fonts/MultiAxis.ttx new file mode 100644 index 0000000000..7c17198c5c --- /dev/null +++ b/engine/src/flutter/third_party/fonts/MultiAxis.ttx @@ -0,0 +1,223 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + wdth + -1.0 + 0.0 + 1.0 + 256 + + + wght + -1.0 + 0.0 + 1.0 + 256 + + + + + + MultiAxisFont Test + + + MultiAxis + + + MultiAxisFont Test + + + MultiAxisFontTest-Regular + + + MultiAxisFont Test + + + MultiAxis + + + MultiAxisFont Test + + + MultiAxisFontTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/NoCmapFormat14.ttf b/engine/src/flutter/third_party/fonts/NoCmapFormat14.ttf new file mode 100644 index 0000000000000000000000000000000000000000..2a0c46c7aca19c80833cf8f1a3f0e1e39be7b232 GIT binary patch literal 844 zcmZQzWME+6VrXDsW>D}C);HQ+yK4^v1EU5514BY`ZejrgPcVo-fq{WRCq1V!4XmDl z@dyJ0gG@$hVhYQyzYGiv3~Lw|7|b#jOVxc%D~9{0%Z9m(dlPF^yP^v{vaBP*%_FiEJg+f z<`@4h7#JA8FvK!WXNU!x1eF9+j9?LvdQf;UFfcLjFvu{JGcYjNa!&`VU}g$poWQ`! zz`@kT6v4p2;0>V};~0z>L9Sz91uFv+5Hr9`28K}Ya6blz;D+D^W`+M23@4ahFq~ju z0NcmF_=O1+5(*HPfkFx_!_2_Nz`(%6z`~%wz`(%5zyeYo-0=TD0|SU$(+J{&jb~@z z1M2{D7#Kh*;BpWi0|N&GG}agx8RX%rnHbm^C#ZI2jlj>==BY zY$gUihAt?Z1xcKZ!G~dnU%rBKZeoFgTYgb)Vu^yGi9&E`Qb}S`PO3skYH>+WYIi3|k{3Jh)x`3yy1UI~K&gCTeCLlIeK!A#OcGmC+N84}F@w}R3ngpEuB E0O4zhSpWb4 literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/NoCmapFormat14.ttx b/engine/src/flutter/third_party/fonts/NoCmapFormat14.ttx new file mode 100644 index 0000000000..3c7411b194 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/NoCmapFormat14.ttx @@ -0,0 +1,207 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + No Cmap Format 14 Subtable Test + + + Regular + + + No Cmap Format 14 Subtable Test + + + No Cmap Format 14 SubtableTest-Regular + + + No Cmap Format 14 Subtable Test + + + Regular + + + No Cmap Format 14 Subtable Test + + + No Cmap Format 14 SubtableTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/NoGlyphFont.ttf b/engine/src/flutter/third_party/fonts/NoGlyphFont.ttf new file mode 100644 index 0000000000000000000000000000000000000000..0243f820408af7cd33497de3b01c19e43ab71e67 GIT binary patch literal 712 zcmZQzWME+6VrXDsW>D}C);G$KP2a}Az^K8%z>tufn^?fW!=TT=z}UmUz@U8 z*ulWSz><@noXEhyz|O$HxBygQF@i-vVFAJn3``6>3^EMm3=9mm+|$7-n3;kYCor%w za4>Z-MKCZhctdE$I0hp|9gqrE5COpuGazh+Q15U*1_uTOhAL)-{}v1XeyaO9%5klzZH}oAZ%n309E~MZ2$lO literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/NoGlyphFont.ttx b/engine/src/flutter/third_party/fonts/NoGlyphFont.ttx new file mode 100644 index 0000000000..72c9f292f0 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/NoGlyphFont.ttx @@ -0,0 +1,199 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + EmptyFont Test + + + Regular + + + EmptyFont Test + + + EmptyFontTest-Regular + + + EmptyFont Test + + + Regular + + + EmptyFont Test + + + EmptyFontTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/Regular.ttf b/engine/src/flutter/third_party/fonts/Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..ab638f58de03bb8514e197653aee37795765ad39 GIT binary patch literal 984 zcmZQzWME+6VrXDsW>D}C);G$KYp-BnVANn>U`R;LO)PLXDp|+Cz_@^cfuS%xr!tL! z?f-uU1|}T_28LM~sfj7f8&>NvFfgoPU|=xI$Vg3OS;BObfq~%(0|SFfMs7(3^HC-} z1_s6s1_lO+oc!cOhD!{87#NsDK>XaqiUNkS+*=tK7&#ai7!>jnb5kSsp90CBU|?YQ zP>^3-@_z?|5d#DB4v;+9t&9u|RqYc*;`wd9GB7f~U|?WixFkCLESPS)R12b^n4N(M z%3@?-V1Du6f`NhY3qvg9bcR^4Nl-~J#RwMRW?%r*3=B*RJPa}nd6VcG-s8Q5hEu~;C;Eev48MHrYFxEL513>o+s7#L*1Zv6*hih`^Ga}{hD z7+4q_7#J9M7&sW17+4q-8FU#^nHd#qK+(pa$e_cJ2;u#I{{Pnh1%Em2pM!cCY6yg4 zXW(NHWsqS|X3%0VWUyecXK-WiMJNOt2KE6+`5@qdoWa4626Z7Lg8(= zaTX+THU@D9aRz1vMix#6Mg|22Jt&)rfsert%4R_lXJgP~hzUwfFU?6Ta?8&vQ3y#b zE`jo)6i65(ste^a1TmyCq%)K<%-n Sni=Fd28RDzLHPs1MkWDKM4Cwe literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/Regular.ttx b/engine/src/flutter/third_party/fonts/Regular.ttx new file mode 100644 index 0000000000..a5f3ebac26 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/Regular.ttx @@ -0,0 +1,263 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + RegularFont Test + + + Regular + + + RegularFont Test + + + RegularFontTest-Regular + + + RegularFont Test + + + Regular + + + RegularFont Test + + + RegularFontTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/Roboto-Black.ttf b/engine/src/flutter/third_party/fonts/Roboto-Black.ttf new file mode 100644 index 0000000000000000000000000000000000000000..689fe5cb3c715f2944fec30e43ccb8a2b10625d3 GIT binary patch literal 171480 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ξ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 literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/Roboto-Bold.ttf b/engine/src/flutter/third_party/fonts/Roboto-Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..d3f01ad245b628f386ac95786f53167038720eb2 GIT binary patch literal 170760 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%0Dolti%450{nw}C7 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 VJ(B~IBa;)8Gm{GgXhsJdQveZ|u0{X= literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/Roboto-Italic.ttf b/engine/src/flutter/third_party/fonts/Roboto-Italic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..6a1cee5b2948dbddf8fe6bb050a5cdca1c206dbf GIT binary patch literal 173932 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%0DOIVm@F*0>dVicUs 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 z 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∈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

yC> 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 VJ(B~IBa;)8Gm{GgDCdD=3II>y+06g| literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/Roboto-MediumItalic.ttf b/engine/src/flutter/third_party/fonts/Roboto-MediumItalic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..003029527cc651faa12b18f02ce81d74f5031756 GIT binary patch literal 176864 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 literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/Roboto-Regular.ttf b/engine/src/flutter/third_party/fonts/Roboto-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..2c97eeadffe1a34bd67d3ff1c3887fd53e22c2ca GIT binary patch literal 171676 zcmZQzWME(rVq{=oVNh^)adq3`w4sTCN#hO!15=WFfPe6RDWU5OOxg|%46$e2gF~HO zH$91DVCv*yU=W?)AFOXQy=mhL1_s6z3=9kj$+?LIjO7t>3=Gl{3=BeU$z>%9+AG-S zGB6l`qN#gIaU|`f?U|=xI$Vg4(+Qqewfq^lFfq_9K zBe$etT~YsZ1_mY$1_lv}oc!d(hVuWr85j)yFfee*Z&jB zi08NY${@+X00Kuo2Wncj5W6$}=!@$7l`Ahnr z7pDP81S$unSouIAtb7dp3}Or+46Gm?0|Nse0|OHSlL`YH10w@7OB>?^237_J)>*8^ z3=E9&5SsZSLmJ2$5C$8?@PL8oe*l9*G{^@a5qE!ocLoOrhW~%r82&LZq_NLpVo+dU zoDY&?v0~l8punKOz|7pk0188pAOquX1~6vgXIQ}0&(Oj0mZ6-bjvJq)c(Cm7V2ix^~BIvM;JCo#w}nKGy{Ni$4f_F)iWsbeT+sbg5hQpXU>QpXU- zQpaG*QpYfhrH-M6rH;XurH-M1rH&zm@dHB}<3>C2KK573&s;l}x$}+gY+0Oj%hNRn?S#O%SK!6eVX$sEDpz&wY6g{hLkk|l~Em!+1WhsA&)hNYPyp2e0SmgzWy4NEOU z0!s!%593FMUdEUI_p|UZ^fG>An8VJ@(9M#?(8Dr;AsVc&hasM6D?<;90z*90Tn0{- zOok5T2MmgA%naJh-x)NSPcn!xe`knb+REU-_?cln(^dvy)i;Je7lues__6F_SjKXQp_}a>gCENVhB}ss4DKu)4ACre7^bouXNYH= z#URW0i(xiPF~ckte+DHcO$H^_ZiYoH9SjrM7cyk9yD%g&{$W_a+RhNmwDbQH);fk% zmPriJtP>b|SUxj!Ffsq%!eY*l#C(KdC37!BFY{`KKISZjMo^eCt!1cW(qb@TKE_bZ z^oJpiDT<+vf#J_`28O@+3=Ds|85sV?F);j5XJGhi!Nkk3orRmBkV%|jGD|VTM%E<^ z@~njn>8y4PMl2HlTI$tlSKX*jN~h*qs@q zLFtio3&Td%l??i<>~XO&=xWXWMjWSPV;mpPhY7Rwa|JvIdfQ5FG)2$p#ab6A2H=CCYa&|!VgFqdU6 z!yJ$p^9=?K*0W&$&S8mUNN1~Hn8P-YVIs?S201n}hPf;e40Bn08B*BV8RoL2FzB;n z{C~mX%aG1?l0lvA3Bw$g&i{Ww=CE@x%wf}JXk-cde}`S0VLR&&hM6pv7&KVi82H(_ z8BVfsGwflz$S|4pA;UCI7KUx?7a3-=C^G~w-)8Uu#Rp3_Lo_QFgBS}lgC3aQ!4S>P z$S{XZg`o~+HmeasDT_Np3d>)H5(b7p=?n~i3K3Fpu zFqp8$Fvzp+VVK4;jUk;ipJ5tH7DF>@K0_y)K7&2W-v9T&W=Ap1V*SUU&+?u@hjkOf zMo@ZT6Jl7&@`hm!yFbH9Hamv7pnSlxf+2%t1w$swb_Ofv)eP3GdJL8<4h)(s-x$K# zrZ7aZJz+>;3u7>2)n+hc@ni^MVP~jhKgi(1R?1+{{+nSX+d_s3EZ-Q)SY#PeS=TZs zvnnvSv8FIgV`E~_XZggS!>quN&mzLWz@f>&0Hc|9GB7Z4F)%R3Ffg#xGcYh2FfcGK z0#`{43>U%0Jp+>ogDMEKIxs9^vuBvVyp(~LaVA3o<4gtv#_0?yj58VhnXWKoFx_Ub zVLHg5!jj40#?sFa&a{c4i}?t{6xJw)DU5XtLF}s-T$s`ra+uN>BAFL6STnt6Fk?<& zr~;K^Y@rPDY!eukbCfZxV13OX&!)}L!&1i(&w7hNo<)g4i=~7?fz^W{merp@p7l9H z74tcU3=S)XMXZbr>8#=mGuYG^LfEb|q_CZ5NM_4oh-B$!$YSkdSjn=U!Ifna!wQz8 z4E7vW3`tBp|2MESF{Fa)5Zc<85&sl z84OtX8T_Dl1`9t!GK(^UJBv00FG~o68k;DCAxk=g2ulq^35yzo28#lNGm95P7t3yj zNR}8doxt*#p^J@)p^JG7Ll;X3Ll^UT25rU{4AVj4ENd8&nNKrxf%O?P7%(qn;ALLV z&;>SgH$wu5X6|ILV>!pr#r&SZo;95zfmNI#f#nlJDQgjf8cPjB0=pxFI=eqZ7i$TF z2FqE7E|y4!E>;x=JvMFzc@}#Hca}E{T`YbK-7E(g)LG;ilvp(wx>&LpY}o=Cy4cn* zbg{}ZaIk&^tLb8?X7FY!W9VXOX9!>sWZ-6VXOL&9Wawt)Wawr!XHaH6#E`%e&%n#F zfFpv2eLl=t`gB;6Yh7?vGhK;N$44YVl878sXGHhbu zXPCs&z|aNqFG~PJ7fUOHFymi_`OHfg8W|Y=EMb1nkjMP_e;f-RLniYVhD=ZxGS6pd zWS+;+2#Q-!I>lx;Ya>G)>pF%y*2xT;SRXLdu|8&~W4_9;fTf9{nI(dOpXEG*9ZNPt zDvKV27xNN^X2yvO>1<0F5?FRJG%^19zm27y!J4I>p_rwfL7AnVp`4|jp^T-T!JMU@ zp^l}VA)ck4p@5~H;R_Sn|1C@`|FdZN>)jRc(C6=ZUOln4-IOQg5m)u zy@g>VsLjZv`+qy*um5wIbpM}W{PlkmlkWdFjKBV0V$x-hVEp+1HIO19|?+nH}M z^n%*9pmq|teapwt%i_ndkntnKWKdg|@gqYxh-PYMm;eztpn3&{LG=tW z289a@Bl`h~4X&#|ega`o9R|hVeADw^lXc5~b0*#YwyabBKVvoeFT$Gk|0UD(|FgmJ zzoC7zQw(9Cv!fzm8`e+*RKfZ`R@_X3q0AU3!y4r+gQFiZruyJH#p!F>u)-Ujtu z9xy0^`btdG|33w_yTN^{ScZOZyBm}ziy1b8(kRGIu$iF#pbEn#ko~Oe48Cypfzeqn61Ju`GQ(zDUv0>)IXjmSCm2cqosX0Ru zs80sd2RC~Q!$zVH&s(@|s~2 zxbM--5D#+?cKZJ*?BWc$#EQfGhnxQYfyMU!E?n}UumkmTnRFQzGk#=f1(!Kk%2Cz^ z26vVT|Bv95hxLC6(FP1XDCH)!zYOa)=^^-yA7uJUX z)l00b|F3{BOECj8bM*f|tQP;jv#9^y4>Avwo{|+n{04e*yeF1R!&M+NRmV?^)@Nyf}{s)!Gpz=0^K@D8@XfyDF>j_XBUxC3H z)DHlO!|DQ1`y6imdZ-<5ApHlpx#t+Vz76ALRGFfp;Rva)cnv9YnSva+!;v9hs(Iba?K8!Ial3lj?qGgv({ zD=QNdD-#EZ!_3Oe%EHdV!otkN%*MpZ%ErpX2I8}_voNzVGc&WYFflQ+u&}eUvv9Do zv9f|Sv4T`Gv9WS;FtIVSfvsacZg!9e$SO`Si=B;~m6MH=gB=nkAoU<7I~yn{IoLt21DV1O zW^%HFHLv|1jzp&^N}nEi-U3uNDjnd11VsFgcT^=g2YfUB&yh0 z*_hba*qA|K!p6h~%44kH?7+$j&Rmc@22u+OO;Gr-vVv8?rf_wokYFJr7K?lx(tgK9+fPt22EG%qLQILnh=^32x*&!K$l?5~%11f1iScZWa zJf8!ixfmGOx)@m4@)#HxzA!W}uz^N88JHM&8R{4oFsxx%%dnr}7{hsnXAJKd{xR}1 z3NorPsxule1~bMprZd(t)-(1qPGVfhxPkEl<9{Y;CUd4praer@nNBj@W%|s_$jr>l z$;{8J%-qG?!#s(3A@c_2oy;eh&oN(OzQ&@;qR-;W;?I)AlFw4f(#A5MWhKi-mR&68 zSgx}?WckX<$SS}pEXOEkFV`yfQSP(cPkCPjP6ciSK?P9-IRzyJbp-VOf5Ld<{~^XR{|_=SFz#nyVBE#Pz_^WpfpH511LGzJ2F6tk42*03 zi~VQ+&-(Ajzt@cKK%w<7^`8r)^4}YOum3&ycgx=uf0zGV^mp#xE(V7G|Nj34srbvq z!0`XxpMQUTGcf$w#lY}q6J*Zh&q4-}I5d@Dh2gGJ9VVnS+c?PLJ0Gag#jc+pr zfo8867?}DP7?@@;Ffi?7U|>4Oz`*nfqz@f4T|yTD@tF=WFn}B z<|oW+87?ueW4O$`o_PcFM&?ZnR~W7`Tw~tC{FHes!*%9u3^$m!Gw)!y$-I-{7Q=0Z zJIuS7H#6L2-p#y+c`x%m=KahEm=7}CW4OXBQx_^=5x&FnJ+N1FtReTF<)eU z&U}fHosol)lckaQ1@lWraYhM7Nk%E=SIn=O-!i{p)L_(P)MC_TX<*c0)MeCT)Mqqc zX<}(+G-NblG-fnme#iWt(Uj4Q(VWqOrG=%H`2+JumU5N~=1m7=2l4 zS?ZX-Fn?wK#^}fB<cM$QZ;J%oxHL%2LTv#TdpI&KSYM$il$F#KO!1s+rjsBN?Mu zs#$7Sq*-JbqZwluV;SREI#@ax<5^@`x)}2r3m6+2n^<~Sx*4allrhd_-~pvy?mZxq zfq~&Clm=0twI86G3Wj+Z7#KhpRBI_PFo0%V8CVz?7#2V+@4BLf4&aRvs4^9&43Z43+y z7a*9angKEob&Y|6sh@#?;W`5Y!wm)oh9(9EhMNow40jnAn5Hr?Fx+EcV7Sk~z|g|L z!0>>9f#E46Z!#*7~V55FoE3ofq{VmgxeVy7(OyEFnnWRU|Pk%!0?@c zf#C-O0|RIU2q-N6GB7ZKR(t$oU;r(TVCZ6CVEE6#z{t|-`(?13V#smfi z#zY1NW*!Cx#v}#?##9CdW{{uK7#JAS85o#q85kHd7#KjMEwcy%17ke|GfZV*U zij!#!42+W?m|;2t1LFb)21ZaA&tPC+T+hJ32nxSh3=E7PAei|c0|VnP2xe-9tR-Rm z&A`9}()Wjff$={B1G6>*1Cs;;1Ct~J12Y!`1Cta31CulZ12bsN3n*;N85kJmFfcGh zLNLQz1_q`*5X^iZ67Ec(^fZrwf$1a!gVHI}4F(3LyO4Cs^qGMHgc+7IFo2RYGbp{U zU|<0C0YR8y6$1lkH4q3htY%P zGboHe7-T0Xj8-x*FzjStUq24+w#eV&1V`5FX+=B`0S69_XuVPIeZEn#D1U|?R$zyNA}gD}G-1_l;p z2xeZ#z`()+!3>uf7+6>t7+5$M7?{^HFtBhkFtBhlFfd$UU|`{aV9-1o3oio$2s1xr zU|`{cVCJn13@rQ*3@WQw1Q-}Vn0Xrm1B)O8gUT-!AqEB(VFm`~?U1>6(0n|oJYx}M zU;ts}oeT^tVhju{5)2Fsw-^{$Bq10St}Idv3?R(BnSp^t8iGOPAd3tG1B(&^1M_YM z1{P%o1{M`axyYi*zyQL`hd`^?7#LXeA!Q_s0RsaFGaqJPU@>H1U@>7}V0gvAz+wu) z%tsg)Sj-q0SS%oIG8Rh)1`uXG%D}*4#lXN~3n@EU>=+n87!+qL_6!Ul% zpD{471VS+LX$A(CAP8n;VqjnihG6D13=AwG5X=aQ+fW7umIww0=Cce8ERhThEYS=M zjG%Z1t#^oFU|_z;z`zmRmMR7YmNo_kMo=7rRv3cn4GjhcmL4c>U|?YBWnf?dmE}4N3@nov7+5AV zFt9W+FtAKvU|<22wV-&L!N9-*Di_`{FtE&GU|^Zcz`zKK!+8u0Eb|!{SXvkuSQaoa zu&jjCAuOvH7+65%*#`y&mNg6vETBA5&cMI|$^+{e7??jXFtBW3U|`t@aUaVj1_l;T zF9Z~CptJ?T^$ZLwdl(p4_Co3zmVFEiEc+Q4SZWy4|R zVEN0yz!=TI!19lQf#p8~14{=3XyGIngX%?AMg|5DW|3uJU}a)pU-K><`JH!?6Nh(a(Z?I?&dFeu0|FfcYVFeoT6 zFeoT7FfevAFes=pFerf9AAJlA3I-6&IFW%t!H9uD!I*)8`8ETCf+Yikf)%7LSFmAV z0Ac343=9e`5X?A*fkB}Jf*GeWFerfB0csOWV_;BN48bfQyOuC8C@f)MV4Tjtps^fjox#AMuo{9v`9on10|N*%&ShXw*a*Rl^B5Qub}}$1fYRH11_p&a3=9gOG`5g| zL6H@L85c7!C<;R`;}Ql2MKK6wT*|3v9m~jmQgAyAAGi+jDP~wMR#?83?R(7nSntm0fIrjccl~t2BlO62F9%n463Ifm~lG;!#hR>hIdR1 z42(M%7``2bU{J6BHzNbXZx+x>XaTY1w@mAQttQHUv7_p(jMS6pSOQf`-qJry&0|5~m z4!B4wMn>vxV1v6+LBX{)Qv%{zcAX7uTDluJASMJyY;cg?z!2Hh1u`!N-oX*B zF4BsMk-8hWbT(+X>TclH*`VpFyMae%qdH@ULRWCaP6q}ShU6U_3>_g6I~g>XUlc@2 zZ%_`7*r3p{Lx2G;2J$7Z&IX5$9SRIl5gRobT%>n0XfnTWiPYV|qrHJan_&~90FyT3 zCP79fZN}|_RtBol0t_754BHt!to0N{7&x@IGevk*Dmd98rgIFAO=>e8fAQoqctClFxagt&@flMpw%_67z>ylt|VVl3Vi z4!y=E3=wr4J4p257G`5f~H7Iv0UmS&dAtX`~r ztRL6{+3MInvq!TRu(z@=VL!wEn!}6ZJ*O$>RL)mi23$p4E4jtE6S-@+*YmLOXz-Nr zY~tnM4dLCzC(hT*w~p@vzXE?L|0(`o0>%On0{H?{1@;JB7x*q%D0o3gMW|Wmjj+A& zE)fP1OOZB_yCOeCQ$*K`{u4_UJ1WjBo-ck#f>Xj$qFv&gq==-iWS`_x$){4fQi)Rg zqz$E~N`IFTli4ftMs|uEi=2R*p4QQ!yGD1H?lV0$J$t=Uyg+f^h^>>u9!NR&NqE!mTflE?6Y~Y`Bn=7iyVt1 zmK>H|mRqa@ttzZOSi4y7wh_0PWXok+XM5RBz%JA7kiDV(3j4PX77h&#pByzDa~)SZ zesS`3+UWGpxz>f>CEMkWYlv&L>m@fgw}WoK+=JX_xj*u-_sH{@<*DWw<2l#!wwHoe zh1YFwHSd`|3O+SHUwzAc-}%M*9rb7QPw_t*pck+y&@XUS;LD(ppu@qI!7D>dLk@%n zg}x0d2zwQ-A6^>%D8eg}HS%DTW7NTD;poKZY0;aaU&S!Qh{e2$jg75{ogDi&E;8$DA!&Zn|KtTJmMN|&fhmhpo~3+B z`IqXKIw$pBT0q*Nbm{bl^q%w?8A2Id8PhTrWvt8Cm8p{1n)x8}eHL>Tf0lGsX4cv4 z(Cp(mW;wHR{^VxoUdv0!dz|l(KRN$dfknakg53qj3%=oj{|ea(1q!7KjS9mGs|x29 z?kGG`c%g`+$h~M~(b=M#MK6naitiWyE|DnFF0n6ZD-|eRS7u-4U9Mf;U%^|krc$7? zyYgvOU^R1fRt-ZksSio4_<7eZsK`A110z z?3;LC65k|;Nez>pPqv@Da03rk)rSqRH@LI58q2j`= zi>w!2TI{-b>*60vLYJ&xa%XAe(j80BFEd?MwOn<1=km8JY*#d|II@y$rQgcMtGHHq ztx8$7d9}vsg4H|LNUUjFvw1Dk+N8B*YrEFYS-WBFp|v;HzFp_JZufeQ^%?6guK%+k zV8fyf&o+U$y_h{+s(h?f-Xx>ww|`ivxZK(ht-gn0#Q>fx`!G z9{6yO{h;hY^^nXV<3rOA>mPPI9DBIraM$65hj$!4 zfB5O)KSy+rxEzT(Qh21}$owPQjw&2oc69I2%ST@wV>l*$Oz)WMv6y2S$LfzwJGSE3 z{$tmUy*7}taogh_$K#J@A1^=NcYNvbjmP&MzjFNb@$V;?Pe`2bJrQ{#^+e5y z$tUKYSbgHqi5n;0o@6;Gb<*&p$H~N#RVOE&Tyb*C$pa^^pL~0Y<&^X(qf;KILQW-| z$~jeWs{ho|QyWk1J$3Tb)l+XyGo6+^t$*6>bj<1E(_N<*pWbu&>gji9e9mk>bLz~) zGe6GqomD?;cQ*8F&e`U(v(9cfd;ILZvtQ5goYOxSelF`=)6TCwf9(9-^ItA-Ur@SWc_HXR=7oj}(=M#PaO}dJ3!g8BU(CDM za&h*>O&3pGym#@-CGJaQmwGNOy0r7sg-drXeZI_fS@E*PW#`M0mkTb}T%L4!-sR1g z_g}tt`O)Q{R|Kx8Uvan+ekJ)z<&_CnmR;F&<;0aMS6*HDc9rL<(pAf=L07Y{p16Ad z>ep+$*Ho@qUkkhzb1maq$+d=SJ=bPjTXOBdwG-DaT)T1Y!L=9HK3w~8o#8sib%E;= z*A=d7TsOGxc|GZR<@E{ImtWs|{l@hN*I!)!aQ(-P-NIiJ8qx9{o)Se9f>>ocg*kD-|@babSLXh z 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 Q$%)CC$%O$lp979509ku(;s5{u literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/Roboto-Thin.ttf b/engine/src/flutter/third_party/fonts/Roboto-Thin.ttf new file mode 100644 index 0000000000000000000000000000000000000000..b74a4fd1a2ed1960da1d0f8f0e9b8d05a5819000 GIT binary patch literal 171904 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 IoCl660Kxx>IRF3v literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/Roboto-ThinItalic.ttf b/engine/src/flutter/third_party/fonts/Roboto-ThinItalic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..dd0ddb852645db815ce4f3d45ec4a37b601ccb5f GIT binary patch literal 176300 zcmZQzWME(rVq{=oVNh^)adq3`v!RE9$?6FM15=WFfPe5`G0CS4Otu~j46&EogF~HO ze|fTkfoZl31B2)U|6qNiX>T^FGcYi&U|?WKNX|_xU@VW2V_=YuU|&@*B@ z#lT?Tz`(%ZkyenN8~;gaH3Nh00tN=gJ?V+X1q>Vv!VFASHy9Wgc+zt!(?YMR|6pLS zTEW2hJ0&9}w?ar$RiA-D%z=S{RU#ubG38IqrDg^OMjZwQ2D6Ne)I^?Ip;QJ2#uNqy z29=E5l8VmlYJm(4OdJdhA{IIM$%&alPv$c)7<4c&aLMH+Rur(?F>PjGVC-OEU{J_Q z%uPMQ^n#m#$&81Afn{|;esRhFM1~XwCaWDF`GTU<0&TOCdl(q>V;C419)rV*Nm;0? zu-Gx4-{vcWBnJZs9Qh!q2coYs2L1hI_xCENEJrZ|69Xp$6G)VS0i=&T=N}IP1IL$N zcK^aTWjPoaH$&yX6e}M{4J#kRWCk&Ya0XTokAZ=KkAZ=Sf$=y48v`Q)Gm8tuF9ucy z2G&`u#taOM@(`N&B10O;8W08>#qfZE>3;x&LNv$+AQ5+ee|M01|NpWv{9|B9W1q#u zpuoU5A0)?O#kzq(fkAF^eaIAd4r1H|u4Fy(~u< ztQkWXt}=x)6fmXzuV(gOsA5TD2w<%He~Kxb!HIDTgElkc|J5v>4CySMj4CXi3>GY& z43;dO47x0y3|%aq46!Vp3@2DT8MIhD8747iGYB$f|KHET&JfNL$570|&S1uz!?2m% zp23S{&Ho)NI~XEa1sR%IV_CznnPu(& zFN|9l6qtT8oMzneKa1IkA&=Sae;<=DqauqkgD8t9gDvwf24|4FnLjgFGSx72vv@No zvUoDsGcIQEVchlaDDyT5o9#b?DM*~fpTUvE^Z!?n9;QVM_RP;1beZZI@>x6?ikSB^ zl(4>HSj@ct|8?g5|JO3_|NoY$i@}a@3WEky*Z&mO6oyvDDGVGe_6(UUY5#w+?q=X% z{>fm-*ux;evgZFg=1N9YwkU>L=0b*Z%oPlEEM^QHY)K5I%(4u>nVA^=vdA+?GM!;4 zVLHQ5!T5{e5sT;lZ_EoACNW-N*u(hr|01R{48NEg8O}2oFc`AVWcbf|kl`vD55pqn z`v0HU-uyqo!uJ0!t0{vS%L;}lmNo`+wz&-AENu*pEO`uJES?NDFn_W7G8i*XVenv4 zWw2x6XAoxm!l1y~$q)q!FLq^y81@hb8^*;9j;vh_4NTSlIaxayrm}c3n1kaWl%a@m z@xSfNpBdDd`54)m-ZN@|-S5dL#JHGImdT0X1LNiY+nJRZ4ly$^{AQ|TP-S5Fd!B*e zpF0D?Utb1>e;N!7e?BlU{N-f)%jnJA$LI#~ABz`52y62Hi=g;tW%>Vx#gl;*lulSY z|6gF8!jQsR%y5vEn}MGtl_7>@F#{j-euf$rPX=QaF9t*AVl{(lwADh5N=4u)vf;{Ur? zo-+ipPGN9oEoAUv4j>YT$Vb($CGT1Y(XDDP{$q>cj z!QjXu%FxXw!eGZH#9+tDz)-}xn!%k#iNT#ki@}jCn8Aa^j6oi(Pm3XhZRh`8Y&#k3 z!F*2!JGTD}9cROWOahpm=9a zWUy!PUGoKyIENn3RpB4UNgU7SkK<} z|2mt?|9$M)3@L1R42CQh7&@5$F=VkeF|1#N(M;(=I;#Q zjQbe^n3x%Q7>_gXuv9X1gYp6hv$-&IgD^`OLpPflgBmDA*uVT=%3;b7!_>uS#B_#% zk?9OWJJT5kW#)Sf$;|f{B$)3p%wfLA5WswoA)Waig9!6I207+?46@Ak7#=gpTnx1=RSd~2Yz%G8e;7nrk{K*n>KS}k_!(?j>KS}l4l~%Y z9%Zm)u4k}eab>V&-on7cc!D98WjBK@%RGh*=9>(*Abrfo{y$} +j{kinLP>;HDJ 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 ZiWy3n?3o;x9GRS$oS9s}bEn{#0st}%;AH>+ literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/SourceHanSerif-LICENSE.txt b/engine/src/flutter/third_party/fonts/SourceHanSerif-LICENSE.txt new file mode 100644 index 0000000000..d952d62c06 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/SourceHanSerif-LICENSE.txt @@ -0,0 +1,92 @@ +This Font Software is licensed under the SIL Open Font License, +Version 1.1. + +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font +creation efforts of academic and linguistic communities, and to +provide a free and open framework in which fonts may be shared and +improved in partnership with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply to +any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software +components as distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, +deleting, or substituting -- in part or in whole -- any of the +components of the Original Version, by changing formats or by porting +the Font Software to a new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, +modify, redistribute, and sell modified and unmodified copies of the +Font Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, in +Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the +corresponding Copyright Holder. This restriction only applies to the +primary font name as presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created using +the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/engine/src/flutter/third_party/fonts/TextEmojiFont.ttf b/engine/src/flutter/third_party/fonts/TextEmojiFont.ttf new file mode 100644 index 0000000000000000000000000000000000000000..6a5e9d94ec1656eb572a2168b8dfc8d26d8a7dcf GIT binary patch literal 908 zcmZQzWME+6VrXDsW>D}C);G#n)@R1Rz^K8%z>tufn^@o?@=}C>fpG!@1H;broXRw? zdIqKt1_lP1jMT&wmP(8mVtq> zgMop8Ehj%Yk%5naoq>VL2gJ`!tSDeO!o8J&fsuoOfk7cJF*miXKJ5Sl15*J51H+$! z{Nj@TI~a@@7?^WF@?g6e85q=RO`78QZN4%vGQVJ8U|_f;I{hq&zP#d135bSbb_OOW zi;;nW`Ne+=1_s7246%&U8DhaEK_$TyBUl8a9uyu73``6>3^EMm3=9mm+|$7-n3;kY zCor%wa4>Z-MKCZhctdE$I0hp|9gqrE5COpuGazh+Q15U*1_y?fYQLBj{#!7dV1B`H zf`I{S9|PkTrafSvfn5d)DF%?;3=AN{L>QPExEL51EE)J17#KjI%*gN$#1w^^%*>#s z%)p?g#=xL9m4ShUp#c;r3<3OBHlwYdJswu0fscEU{sX3@QsZCY;_5VKu z13uaR5%-VYd45OY=98QEZr;9m{pRJH2XF4bnRAmJ;$*1ZI4E|oTjBl(TZYPGVBlbY zrXmJL1|e8TFfcK&GYCPgU_laRV~}K!WMF1sWZ`6BWKdx+g0h(y_!z>VY!)POHU=Yx zl#tYl64%`PtW3B3yb^_w)Z&t$)b!Gv#3B?4khm^Xf+2( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + TextEmojiFont Test + + + Regular + + + TextEmojiFont Test + + + TextEmojiFontTest-Regular + + + TextEmojiFont Test + + + Regular + + + TextEmojiFont Test + + + TextEmojiFontTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/UnicodeBMPOnly.ttf b/engine/src/flutter/third_party/fonts/UnicodeBMPOnly.ttf new file mode 100644 index 0000000000000000000000000000000000000000..8196669fa18c582e1f9c1520015c8203055912df GIT binary patch literal 696 zcmZQzWME+6VrXDsW>D}C);G$COP|ZYz^K8%z>tufn^?fW$uNb1fpG!@1A|U_PGuSc z7%(0IQ5mU;DV#i3AQRRwFff>9WTYlCzhcy5U|@K{z`&rAky}#16vz + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Sample Font + + + Regular + + + Sample Font + + + SampleFont-Regular + + + Sample Font + + + Regular + + + Sample Font + + + SampleFont-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/UnicodeBMPOnly2.ttf b/engine/src/flutter/third_party/fonts/UnicodeBMPOnly2.ttf new file mode 100644 index 0000000000000000000000000000000000000000..c14b1950054993938d0c6269a651d02a78eaf207 GIT binary patch literal 696 zcmZQzWME+6VrXDsW>D}C);G$COP|ZYz^K8%z>tufn^?fW$uO0HfpG!@1A|U_PGuSc z7%(0IQ5mU;DV#i3stgPaYZw?9%rY`k6PaHz>M<}dJYis9P|3(GsbC6Zh-F}4>|kJE zV9Uu*P6X*=U|`$>;^!t-6fiJ@L>M_37#I}t5_3~a)lyU$7{KOVD#$M``M-m~h=GA= z21p+4Rz?PfGZj6I@%%Pl8JL-0fOKE^=x73>ud?jm1<_E<&cFm^F)}bPzxZ##z`*zg zAp&JVC`Pc^F!c~IRFat~h;ae~D+32p7gGcS1A{k&W{hJnV$=aCWd#us3<^^Si-Cb5 z)H~dd!GR%>A(2_(zXihy<`)bn7#P6zF))5%0)>PE*k!Sxkb=s9T*AY^!l1ywz`(-5 z0#=>)|33o*L*oDc{}+Jya2psH7&sWxpkj;++)y(Z7?>E?8MvY1EJ)&P3_=V-49pCS zESwCC3}Or_P&N|-AA=Q?&4MJ(#-PIB5uBJ?kdvz5mY-J=l$u_elUM{10SV|rMHqq^ z5*czC3K()2QW+E&+!*p1@)$}Of*4X6(iut_au^aBicr+RROq6qVSuCy28RDzLGh35 HRR|jZ%gJAT literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/UnicodeBMPOnly2.ttx b/engine/src/flutter/third_party/fonts/UnicodeBMPOnly2.ttx new file mode 100644 index 0000000000..e43ebf8014 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/UnicodeBMPOnly2.ttx @@ -0,0 +1,177 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Sample Font + + + Regular + + + Sample Font + + + SampleFont-Regular + + + Sample Font + + + Regular + + + Sample Font + + + SampleFont-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/UnicodeUCS4.ttf b/engine/src/flutter/third_party/fonts/UnicodeUCS4.ttf new file mode 100644 index 0000000000000000000000000000000000000000..354e1a370f4bf1c5e7e31ed270729a17731676be GIT binary patch literal 744 zcmZQzWME+6VrXDsW>D}C);G$CPq$`ZVANn>U`R;LO)OxL_`=V?z&L?{fgvV6r!tKJ z3>d$FsEpLa6iyy14+aK?H4F?4W*Hf&iOjDU^%xi!o-i;lsAS}pR4@fH#4<22b}%q7 zu;t_@CxY}bFfhIW@pBU^3K*C{B8(gi3=9f+iMgqzYALD=3}Evw733F}{NKS~#K6FG z0wfQ1D}Rt65HE~W?u1_o~k%^1gE#Ha&O$OXL3<_X2 z3)q#3|Nk>EfXw^90L*7#-~n3;iZc)c%sbFB>U`T`V85y`4 zU~)_h> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Sample Font + + + Regular + + + Sample Font + + + SampleFont-Regular + + + Sample Font + + + Regular + + + Sample Font + + + SampleFont-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/VariationSelectorTest-Regular.ttf b/engine/src/flutter/third_party/fonts/VariationSelectorTest-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..0504c67fb7a6403167ac8b53ae177c7b53d7912c GIT binary patch literal 1008 zcmZQzWME+6VrXDsW>D}C);HQ+^Ljc11EU5514BY`ZeqbKzO)hs2F3{t42-PlIhAQ( z^$bi47#J92GEx&$Sav--$iTp`hJk^>EF&W|k!1DjB&Y6-@#EJrjBivgV7#KMi7#I}t5_40dtixtAFfi?5U|7#J8XiB3NYqAyS669Car%+A0B zWic`^Fu(Y3!N9=yg&~%4IzuejB&Z~qVg!qT)Pur7{_45r~^{L3L+pFVg`iG5b7Q7$KViL-xAHN@ZW;r1oI1q z6ATPs`xqF%fPBiJ0C5>8q!>VUGcbS*6JcOx;9_84xX8fAz`(GVfq{X8;UCD*BoM*y z4`fRggb8vuh*iV~5@e_bvH2K5>}CiPq@bUHfnhcuBQpa7!xB)G@iDS6FfeQdDFC~t zX&H#g$j}lEp$lulj$~wjNHBqEh$J$bkpZp{B8enWSj)h`!e9b+ItM5^f*YEawM75_ z&%h8|4`bCvS1)5=WB?@rh{YgxGcYi)gZ&NVFff2LfgJ==1mS@~1ezil7#YOCz5vNG zF|ad;LDjM#iL)`tGRQJ8GcdAnGB7geFjzs^ObmPsX;3x`k~kZK6+=l_Vo_#dNoIat zaB5C!a!G!XLP% literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/VariationSelectorTest-Regular.ttx b/engine/src/flutter/third_party/fonts/VariationSelectorTest-Regular.ttx new file mode 100644 index 0000000000..f86f008b08 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/VariationSelectorTest-Regular.ttx @@ -0,0 +1,229 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VariationSelector Test + + + Regular + + + VariationSelector Test + + + VariationSelectorTest-Regular + + + VariationSelector Test + + + Regular + + + VariationSelector Test + + + VariationSelectorTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/ZhHans.ttf b/engine/src/flutter/third_party/fonts/ZhHans.ttf new file mode 100644 index 0000000000000000000000000000000000000000..08adc1b300f8013b64519eeeaf1645afaead87b9 GIT binary patch literal 1176 zcmZQzWME+6VrXDsW>D}C);F4=&G>|Yfl-5jfgvF|H?ct2|KwK&2F4W(3=G%Pb1Ksq z*cliY7?>6?Ffbg+NKH&(ep-H!fq`KS0|SFuMn-BP%Mzxe3=9lU7#J8-GIC2QSn8R& z85kHl7#JAja`KZC89Nxm85o!vK>XaqiUNiU+*=tK7&#ai7!>jnb5kvE`8F~zFsCpu zFp3o97nl6s!C=I|z)}H{2fLM#fnm>j-xu-xHeVSSnO}fhb4hgiSunkOz5P6VcG-s8Q5hEu{a^fG>~sVmWVJggI(#&0CKNB$SgjvjiL+;42q!GVK8B0 zU@!&683Pl8={5!)2GgSqybL@bQy8XzNd^XP1_lFN2xeeq0BZqhW8j2n1#9PKU~qAP zU&)~-3%Mij4&5#808%PNV|NlQ^c?=933~8VM z0sBAQj1d+LQ;!Mf>P5-7 KD1SrP$Rq$^X|pi^ literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/ZhHans.ttx b/engine/src/flutter/third_party/fonts/ZhHans.ttx new file mode 100644 index 0000000000..238bd5e6d0 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/ZhHans.ttx @@ -0,0 +1,282 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + SimplifiedChinese Test + + + Regular + + + SimplifiedChinese Test + + + SimplifiedChineseTest-Regular + + + SimplifiedChinese Test + + + Regular + + + SimplifiedChinese Test + + + SimplifiedChineseTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/ZhHant.ttf b/engine/src/flutter/third_party/fonts/ZhHant.ttf new file mode 100644 index 0000000000000000000000000000000000000000..592117d5a782f98cfd9eff5ef390eb4907d07d1f GIT binary patch literal 984 zcmZQzWME+6VrXDsW>D}C);F5NkZ#Suz^K8%z>tufn^<5m>G2c>2F4i-3=DngIhAP) zEdT#AFfds#Ffb%#q$Z{?KP}(Qz`(GEfq}s+BO^7DWeL+!1_p*F3=9k^8M!4D%-oD6 z3=E7N3=9kcIr+(n3?U2!3=B*l^96DfD+(A+a&Ki|VB}z6U{J_Q%uW6O_3dj02BtX- z42)6*`NbvwcQ6<+Ffi``$%Ea>$iVP;rC4@6zs*+$M&=g`3=9mHM5mtx)4S($foLdZ zXJCS|7#SFtU;MXVU|{^h5X(57Ar@>BR1!=vf<@RF7{D|G0}}%egA7AC0|SFC_jIrd zW~Ly<2@I?Z986tI5ey6r-VmBGj=_jg2c&`(L_jboOd%`=28K}Ya6bkI6Q=+FnHBz9 zFq~k1!Egd*591f6Jz$@KUB(cL1VL_KU;r5^!oUo6l@kLW0|SE|NG~7Q22lnE22}yHgq?wpL6kv;L772|!4T{su+gCOKocIwbPk3zsM(AR;vk=c1R0nZ z*crs3;w(twYz%S?a-h&+;bdTB&||QHvY8n87_y*j79?>t1{;QokfOwt%#zIfyu=*m zjLf{$;#7r@)Z&t$)b!Gv#3D>tkfbhDmLY_ph#`?7g&~ungdvk5pCOMSks*h{nIVHA zlOc~Gm7$m+l|g|a1k5U72x3TONM|Tz$YDriC?ZNPOs6iIUQncigW~^IQ2qcjQ3wDq CxtU7< literal 0 HcmV?d00001 diff --git a/engine/src/flutter/third_party/fonts/ZhHant.ttx b/engine/src/flutter/third_party/fonts/ZhHant.ttx new file mode 100644 index 0000000000..31fada9597 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/ZhHant.ttx @@ -0,0 +1,240 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + TraditionalChinese Test + + + Regular + + + TraditionalChinese Test + + + TraditionalChineseTest-Regular + + + TraditionalChinese Test + + + Regular + + + TraditionalChinese Test + + + TraditionalChineseTest-Regular + + + + + + + + + + + + + + + + diff --git a/engine/src/flutter/third_party/fonts/emoji.xml b/engine/src/flutter/third_party/fonts/emoji.xml new file mode 100644 index 0000000000..796a0f1ea0 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/emoji.xml @@ -0,0 +1,31 @@ + + + + + + NoGlyphFont.ttf + + + TextEmojiFont.ttf + + + ColorEmojiFont.ttf + + + ColorTextMixedEmojiFont.ttf + + diff --git a/engine/src/flutter/third_party/fonts/itemize.xml b/engine/src/flutter/third_party/fonts/itemize.xml new file mode 100644 index 0000000000..32a5ab02b7 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/itemize.xml @@ -0,0 +1,39 @@ + + + + + Regular.ttf + Italic.ttf + Bold.ttf + BoldItalic.ttf + + + + ZhHans.ttf + + + Ja.ttf + + + ZhHant.ttf + + + Ko.ttf + + + Emoji.ttf + + From 7e01820ef80e0a8887a57338f29290e9a0b1bb96 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 6 Jul 2017 14:23:59 -0700 Subject: [PATCH 316/364] Prelim ideographic baseline and MinIntrinsicWeight, Arabic test, prepare for RTL language support implementation. Change-Id: I99a6af74aa3607ff9b58ba98426ad3026f02b816 --- engine/src/flutter/src/paragraph.cc | 13 ++--- engine/src/flutter/src/paragraph.h | 1 + engine/src/flutter/src/paragraph_style.h | 5 +- engine/src/flutter/src/styled_runs.h | 1 + .../flutter/tests/txt/paragraph_unittests.cc | 52 +++++++++++++++++++ 5 files changed, 65 insertions(+), 7 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 3b07c4ee70..9c789b9d0b 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -328,7 +328,8 @@ void Paragraph::Layout(double width, bool force) { alphabetic_baseline_ = metrics.fCapHeight * run.style.height; // TODO(garyq): Properly implement ideographic_baseline_. ideographic_baseline_ = - (metrics.fDescent + metrics.fCapHeight) * run.style.height; + (metrics.fUnderlinePosition + metrics.fCapHeight) * + run.style.height; } } if (max_descent < metrics.fDescent * run.style.height) @@ -412,7 +413,7 @@ double Paragraph::GetAlphabeticBaseline() const { } double Paragraph::GetIdeographicBaseline() const { - // TODO(garyq): Implement. + // TODO(garyq): Currently fCapHeight + fUnderlinePosition. Verify this. return ideographic_baseline_; } @@ -421,8 +422,8 @@ double Paragraph::GetMaxIntrinsicWidth() const { } double Paragraph::GetMinIntrinsicWidth() const { - // TODO(garyq): Implement. - return min_intrinsic_width_; + // TODO(garyq): This is a lower bound. Actual value may be slightly higher. + return max_intrinsic_width_ / paragraph_style_.max_lines; } double Paragraph::GetHeight() const { @@ -531,8 +532,8 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, // Overline if (style.decoration & 0x2) { if (style.decoration_style != TextDecorationStyle::kWavy) - canvas->drawLine(x, y + metrics.fAscent + y_offset, x + width, - y + metrics.fAscent + y_offset, paint); + canvas->drawLine(x, y + metrics.fAscent - y_offset, x + width, + y + metrics.fAscent - y_offset, paint); else PaintWavyDecoration(canvas, wave_coords, paint, x, y, metrics.fAscent, width); diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 04ed7e7a60..845d94f3af 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -73,6 +73,7 @@ class Paragraph { FRIEND_TEST(RenderTest, DecorationsParagraph); FRIEND_TEST(RenderTest, ItalicsParagraph); FRIEND_TEST(RenderTest, ChineseParagraph); + FRIEND_TEST(RenderTest, DISABLED_ArabicParagraph); std::vector text_; StyledRuns runs_; diff --git a/engine/src/flutter/src/paragraph_style.h b/engine/src/flutter/src/paragraph_style.h index 45f1dd745d..9f30869a15 100644 --- a/engine/src/flutter/src/paragraph_style.h +++ b/engine/src/flutter/src/paragraph_style.h @@ -34,7 +34,10 @@ class ParagraphStyle { double font_size = 14; size_t max_lines = 1; double line_height = 1.0; - std::string ellipsis; + std::string ellipsis = "..."; + // TODO(garyq): Implement right to left. + // Right to left (Arabic, Hebrew, etc). + bool rtl = false; }; } // namespace txt diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index d61ea1c57f..dbaa111db3 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -67,6 +67,7 @@ class StyledRuns { FRIEND_TEST(RenderTest, DecorationsParagraph); FRIEND_TEST(RenderTest, ItalicsParagraph); FRIEND_TEST(RenderTest, ChineseParagraph); + FRIEND_TEST(RenderTest, DISABLED_ArabicParagraph); struct IndexedRun { size_t style_index = 0; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 5cb2a75bc6..bec51d51b3 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -763,6 +763,7 @@ TEST_F(RenderTest, ChineseParagraph) { txt::ParagraphStyle paragraph_style; paragraph_style.max_lines = 14; + paragraph_style.text_align = TextAlign::right; auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); txt::ParagraphBuilder builder(paragraph_style, &font_collection); @@ -794,4 +795,55 @@ TEST_F(RenderTest, ChineseParagraph) { ASSERT_TRUE(Snapshot()); } +// TODO(garyq): Support RTL languages. +TEST_F(RenderTest, DISABLED_ArabicParagraph) { + const char* text = + "من أسر وإعلان الخاصّة وهولندا،, عل قائمة الضغوط بالمطالبة تلك. الصفحة " + "بمباركة التقليدية قام عن. تصفح"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 14; + paragraph_style.text_align = TextAlign::right; + paragraph_style.rtl = true; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + text_style.font_size = 35; + text_style.letter_spacing = 2; + text_style.font_family = "Katibeh"; + text_style.decoration = txt::TextDecoration(0x1 | 0x2 | 0x4); + text_style.decoration_style = txt::TextDecorationStyle::kSolid; + text_style.decoration_color = SK_ColorBLACK; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth() - 100); + + paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_EQ(paragraph->records_.size(), 2ull); + ASSERT_EQ(paragraph->paragraph_style_.rtl, true); + + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[u16_text.length() - i]); + } + + ASSERT_TRUE(Snapshot()); +} + } // namespace txt From 3a0422f7613cc1d3b5da79a1be20393670aa0db9 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 7 Jul 2017 11:32:34 -0700 Subject: [PATCH 317/364] Implement GetGlyphPositionAtCoordinate(). Change-Id: I78528de9d4fa1611ceb857790a3b3945c0988c9c --- engine/src/flutter/src/paragraph.cc | 83 ++++++++++++++++++- engine/src/flutter/src/paragraph.h | 14 +++- .../flutter/tests/txt/paragraph_unittests.cc | 57 +++++++++++++ 3 files changed, 152 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 9c789b9d0b..3ee9215e3b 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -169,6 +169,13 @@ void Paragraph::Layout(double width, bool force) { // Reset member variables so Layout still works when called more than once max_intrinsic_width_ = 0.0f; lines_ = 0; + line_widths_ = std::vector(); + line_heights_ = std::vector(); + line_heights_.push_back(0); + glyph_position_x_ = std::vector>(); + glyph_position_x_.push_back(std::vector()); + std::vector glyph_single_line_position_x; + glyph_single_line_position_x.push_back(0); SkScalar x = 0.0f; SkScalar y = 0.0f; @@ -210,6 +217,32 @@ void Paragraph::Layout(double width, bool force) { } } } + // Correct positions stored in the member vars. + for (size_t y_index = 0; y_index < lines_; ++y_index) { + switch (paragraph_style_.text_align) { + case TextAlign::left: + break; + case TextAlign::right: { + for (size_t i = 0; i < glyph_position_x_[y_index].size(); ++i) { + glyph_position_x_[y_index][i] += + width_ - breaker_.getWidths()[y_index]; + } + break; + } + case TextAlign::center: { + for (size_t i = 0; i < glyph_position_x_[y_index].size(); ++i) { + glyph_position_x_[y_index][i] += + (width_ - breaker_.getWidths()[y_index]) / 2; + } + break; + } + case TextAlign::justify: { + // TODO(garyq): Track position changes due to justify in justify + // method. + break; + } + } + } x_queue.clear(); }; for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { @@ -261,6 +294,7 @@ void Paragraph::Layout(double width, bool force) { letter_spacing_offset += run.style.letter_spacing; + // TODO(garyq): Implement RTL. // Each Glyph/Letter. bool whitespace_ended = true; for (size_t blob_index = 0; blob_index < blob_length - trailing_length; @@ -283,6 +317,8 @@ void Paragraph::Layout(double width, bool force) { buffers.back()->pos[pos_index] = layout.getX(glyph_index) + letter_spacing_offset; + glyph_single_line_position_x.push_back( + buffers.back()->pos[pos_index]); buffers.back()->pos[pos_index + 1] = layout.getY(glyph_index); letter_spacing_offset += run.style.letter_spacing; @@ -337,6 +373,11 @@ void Paragraph::Layout(double width, bool force) { if (layout_end == next_break) { y += max_line_spacing + prev_max_descent; + line_heights_.push_back( + (line_heights_.empty() ? 0 : line_heights_.back()) + + max_line_spacing + max_descent); + glyph_single_line_position_x.push_back(FLT_MAX); + glyph_position_x_.push_back(glyph_single_line_position_x); prev_max_descent = max_descent; line_widths_.push_back(line_width); postprocess_line(); @@ -350,6 +391,8 @@ void Paragraph::Layout(double width, bool force) { character_index = layout_end; break_index += 1; lines_++; + glyph_single_line_position_x = std::vector(); + glyph_single_line_position_x.push_back(0); } else { x += layout.getAdvance(); } @@ -358,11 +401,14 @@ void Paragraph::Layout(double width, bool force) { } } y += max_line_spacing; + height_ = y + max_descent; postprocess_line(); if (line_width != 0) line_widths_.push_back(line_width); - height_ = y + max_descent; + line_heights_.push_back(FLT_MAX); + glyph_single_line_position_x.push_back(FLT_MAX); + glyph_position_x_.push_back(glyph_single_line_position_x); } // Amends the buffers to incorporate justification. @@ -565,6 +611,41 @@ void Paragraph::PaintWavyDecoration(SkCanvas* canvas, } } +std::vector Paragraph::GetRectsForRange(size_t start, + size_t end) const { + return std::vector(); +} + +size_t Paragraph::GetGlyphPositionAtCoordinate(double dx, double dy) const { + size_t offset = 0; + size_t y_index = 1; + size_t prev_count = 0; + for (y_index = 1; y_index < line_heights_.size(); ++y_index) { + if (dy < line_heights_[y_index]) { + offset += prev_count; + break; + } else { + offset += prev_count; + prev_count = glyph_position_x_[y_index].size() - 2; + } + } + prev_count = 0; + for (size_t x_index = 1; x_index < glyph_position_x_[y_index].size(); + ++x_index) { + if (dx < glyph_position_x_[y_index][x_index]) { + break; + } else { + offset += prev_count; + prev_count = 1; + } + } + return offset; +} + +SkIPoint Paragraph::GetWordBoundary(size_t offset) const { + return SkIPoint::Make(0, 0); +} + int Paragraph::GetLineCount() const { return lines_; } diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 845d94f3af..a23b9e6771 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -27,6 +27,8 @@ #include "lib/txt/src/styled_runs.h" #include "minikin/LineBreaker.h" #include "third_party/gtest/include/gtest/gtest_prod.h" +#include "third_party/skia/include/core/SkPoint.h" +#include "third_party/skia/include/core/SkRect.h" #include "third_party/skia/include/core/SkTextBlob.h" class SkCanvas; @@ -55,6 +57,12 @@ class Paragraph { double GetMinIntrinsicWidth() const; + std::vector GetRectsForRange(size_t start, size_t end) const; + + size_t GetGlyphPositionAtCoordinate(double dx, double dy) const; + + SkIPoint GetWordBoundary(size_t offset) const; + int GetLineCount() const; bool DidExceedMaxLines() const; @@ -80,9 +88,13 @@ class Paragraph { minikin::LineBreaker breaker_; std::vector records_; std::vector line_widths_; + + // TODO(garyq): Can we access this info without redundantly storing it here? + std::vector line_heights_; + std::vector> glyph_position_x_; + ParagraphStyle paragraph_style_; FontCollection* font_collection_; - // TODO(garyq): Height of the paragraph after Layout(). SkScalar height_ = 0.0f; double width_ = 0.0f; size_t lines_ = 0; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index bec51d51b3..9158740594 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -340,6 +340,13 @@ TEST_F(RenderTest, LeftAlignParagraph) { ASSERT_EQ(paragraph_style.text_align, paragraph->GetParagraphStyle().text_align); + // Tests for GetGlyphPositionAtCoordinate() + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(0, 0), 0ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 1), 0ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 30), 74ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 60), 142ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(2000, 30), 141ull); + ASSERT_TRUE(Snapshot()); } @@ -846,4 +853,54 @@ TEST_F(RenderTest, DISABLED_ArabicParagraph) { ASSERT_TRUE(Snapshot()); } +TEST_F(RenderTest, GetGlyphPositionAtCoordinateParagraph) { + const char* text = + "12345 67890 12345 67890 12345 67890 12345 67890 12345 67890 12345 " + "67890"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 10; + paragraph_style.text_align = TextAlign::left; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.font_size = 50; + text_style.letter_spacing = 1; + text_style.word_spacing = 5; + text_style.color = SK_ColorBLACK; + text_style.height = 1.5; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth() - 500); + + paragraph->Paint(GetCanvas(), 0, 0); + + // Tests for GetGlyphPositionAtCoordinate() + // NOTE: resulting values can be a few off from their respective positions in + // the original text because the final trailing whitespaces are sometimes not + // drawn and therefore are not active glyphs. + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(0, 0), 0ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(3, 3), 0ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 1), 1ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 20), 16ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 80), 33ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 80), 17ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 160), 34ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 160), 50ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(70, 160), 36ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 270), 51ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 80), 18ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 10000), 68ull); + ASSERT_TRUE(Snapshot()); +} + } // namespace txt From ba43d1e9898e85728df268564cdee36618fb75ce Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 7 Jul 2017 17:17:34 -0700 Subject: [PATCH 318/364] Take letter spacing into account when linebreaking and initial implementation of GetRectsForRange(). Change-Id: Id7fa1b5b60c988cb73ba182241b3d8b3c998e07c --- .../src/flutter/include/minikin/LineBreaker.h | 3 +- .../src/flutter/libs/minikin/LineBreaker.cpp | 10 ++-- engine/src/flutter/src/paragraph.cc | 47 +++++++++++++++++-- engine/src/flutter/src/paragraph.h | 2 + .../flutter/tests/txt/paragraph_unittests.cc | 40 +++++++++------- 5 files changed, 78 insertions(+), 24 deletions(-) diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index c2f546db76..1a6b1888db 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -166,7 +166,7 @@ class LineBreaker { // is having some kind of callback (or virtual class, or maybe even template), which could // easily be instantiated with Minikin's Layout. Future work for when needed. float addStyleRun(MinikinPaint* paint, const std::shared_ptr& typeface, - FontStyle style, size_t start, size_t end, bool isRtl); + FontStyle style, size_t start, size_t end, bool isRtl, double letterSpacing = 0); void addReplacement(size_t start, size_t end, float width); @@ -230,6 +230,7 @@ class LineBreaker { icu::Locale mLocale; std::vectormTextBuf; std::vectormCharWidths; + std::vectormCharSpacing; Hyphenator* mHyphenator; std::vector mHyphBuf; diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index e75c7bf523..97f4798253 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -113,7 +113,7 @@ static bool isLineEndSpace(uint16_t c) { // This method finds the candidate word breaks (using the ICU break iterator) and sends them // to addCandidate. float LineBreaker::addStyleRun(MinikinPaint* paint, const std::shared_ptr& typeface, - FontStyle style, size_t start, size_t end, bool isRtl) { + FontStyle style, size_t start, size_t end, bool isRtl, double letterSpacing) { float width = 0.0f; int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; @@ -138,6 +138,10 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const std::shared_ptrGetMinikinFontCollectionForFamily( run.style.font_family), - font, run.start, run.end, false); + font, run.start, run.end, false, + run.style.letter_spacing); } } @@ -171,6 +172,8 @@ void Paragraph::Layout(double width, bool force) { lines_ = 0; line_widths_ = std::vector(); line_heights_ = std::vector(); + + // Set padding elements to have a minimum point. line_heights_.push_back(0); glyph_position_x_ = std::vector>(); glyph_position_x_.push_back(std::vector()); @@ -283,6 +286,7 @@ void Paragraph::Layout(double width, bool force) { // Check if we should remove trailing whitespace of blobs. size_t trailing_length = 0; while ( + paragraph_style_.text_align == TextAlign::justify && minikin::isWordSpace( text_[character_index + blob_length - trailing_length - 1]) && layout_end == next_break) { @@ -613,7 +617,43 @@ void Paragraph::PaintWavyDecoration(SkCanvas* canvas, std::vector Paragraph::GetRectsForRange(size_t start, size_t end) const { - return std::vector(); + std::vector rects; + end = fmin(end, text_.size() - 1); + while (start <= end) { + SkIPoint word_bounds = GetWordBoundary(start); + word_bounds.fY = fmin(end + 1, word_bounds.fY); + word_bounds.fX = fmax(start, word_bounds.fX); + start = word_bounds.fY; + SkRect left_limits = GetCoordinatesForGlyphPosition(word_bounds.fX + 1); + SkRect right_limits = GetCoordinatesForGlyphPosition(word_bounds.fY); + if (left_limits.top() < right_limits.top()) { + rects.push_back(SkRect::MakeLTRB( + 0, right_limits.top(), right_limits.right(), right_limits.bottom())); + } else { + rects.push_back(SkRect::MakeLTRB(left_limits.left(), left_limits.top(), + right_limits.right(), + right_limits.bottom())); + } + } + return rects; +} + +SkRect Paragraph::GetCoordinatesForGlyphPosition(size_t pos) const { + size_t remainder = fmin(pos, text_.size()); + size_t line = 1; + for (line = 1; line < line_heights_.size() - 1; ++line) { + if (remainder > glyph_position_x_[line].size() - 2) { + remainder -= glyph_position_x_[line].size() - 2; + } else { + break; + } + } + return SkRect::MakeLTRB(glyph_position_x_[line][remainder], + line_heights_[line - 1], + remainder < glyph_position_x_[line].size() - 2 + ? glyph_position_x_[line][remainder + 1] + : line_widths_[line - 1], + line_heights_[line]); } size_t Paragraph::GetGlyphPositionAtCoordinate(double dx, double dy) const { @@ -643,7 +683,8 @@ size_t Paragraph::GetGlyphPositionAtCoordinate(double dx, double dy) const { } SkIPoint Paragraph::GetWordBoundary(size_t offset) const { - return SkIPoint::Make(0, 0); + // TODO(garyq): Implement. + return SkIPoint::Make(0, offset + 1); } int Paragraph::GetLineCount() const { diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index a23b9e6771..a59398cc56 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -61,6 +61,8 @@ class Paragraph { size_t GetGlyphPositionAtCoordinate(double dx, double dy) const; + SkRect GetCoordinatesForGlyphPosition(size_t pos) const; + SkIPoint GetWordBoundary(size_t offset) const; int GetLineCount() const; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 9158740594..4d19aa453c 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -303,6 +303,9 @@ TEST_F(RenderTest, LeftAlignParagraph) { paragraph->Layout(GetTestCanvasWidth() - 100); paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_TRUE(Snapshot()); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); @@ -343,11 +346,9 @@ TEST_F(RenderTest, LeftAlignParagraph) { // Tests for GetGlyphPositionAtCoordinate() ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(0, 0), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 1), 0ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 30), 74ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 60), 142ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(2000, 30), 141ull); - - ASSERT_TRUE(Snapshot()); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 30), 68ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 60), 134ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(2000, 30), 133ull); } TEST_F(RenderTest, RightAlignParagraph) { @@ -856,7 +857,7 @@ TEST_F(RenderTest, DISABLED_ArabicParagraph) { TEST_F(RenderTest, GetGlyphPositionAtCoordinateParagraph) { const char* text = "12345 67890 12345 67890 12345 67890 12345 67890 12345 67890 12345 " - "67890"; + "67890 12345"; auto icu_text = icu::UnicodeString::fromUTF8(text); std::u16string u16_text(icu_text.getBuffer(), icu_text.getBuffer() + icu_text.length()); @@ -880,27 +881,32 @@ TEST_F(RenderTest, GetGlyphPositionAtCoordinateParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth() - 500); + paragraph->Layout(550); paragraph->Paint(GetCanvas(), 0, 0); + ASSERT_TRUE(Snapshot()); + // Tests for GetGlyphPositionAtCoordinate() // NOTE: resulting values can be a few off from their respective positions in // the original text because the final trailing whitespaces are sometimes not // drawn and therefore are not active glyphs. + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(-10000, -10000), 0ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(-1, -1), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(0, 0), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(3, 3), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 1), 1ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 20), 16ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 80), 33ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 80), 17ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 160), 34ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 160), 50ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(70, 160), 36ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 270), 51ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 80), 18ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 10000), 68ull); - ASSERT_TRUE(Snapshot()); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 20), 17ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 80), 35ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(-100000, 80), 18ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(20, -80), 0ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 80), 18ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 160), 36ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 160), 53ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(70, 160), 38ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 270), 54ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 80), 19ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 10000), 77ull); } } // namespace txt From 04950b0e3ca7ec7025cb5b73dd59d736d2b6e184 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 10 Jul 2017 12:27:13 -0700 Subject: [PATCH 319/364] Implement GetGlyphPositionAtCoordinate() Change-Id: I65580c33efe6fbcf086f444f53fc59fb0dea2c56 --- engine/src/flutter/src/paragraph.cc | 10 +- engine/src/flutter/src/paragraph.h | 2 + .../flutter/tests/txt/paragraph_unittests.cc | 116 +++++++++++++++++- 3 files changed, 125 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index face33d23d..bf07472d9f 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -476,6 +476,10 @@ double Paragraph::GetMinIntrinsicWidth() const { return max_intrinsic_width_ / paragraph_style_.max_lines; } +size_t Paragraph::TextSize() const { + return text_.size(); +} + double Paragraph::GetHeight() const { return height_; } @@ -683,8 +687,10 @@ size_t Paragraph::GetGlyphPositionAtCoordinate(double dx, double dy) const { } SkIPoint Paragraph::GetWordBoundary(size_t offset) const { - // TODO(garyq): Implement. - return SkIPoint::Make(0, offset + 1); + // TODO(garyq): Consider punctuation as separate words. + return SkIPoint::Make( + minikin::getPrevWordBreakForCache(text_.data(), offset, text_.size()), + minikin::getNextWordBreakForCache(text_.data(), offset, text_.size())); } int Paragraph::GetLineCount() const { diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index a59398cc56..7b5278fc91 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -47,6 +47,8 @@ class Paragraph { const ParagraphStyle& GetParagraphStyle() const; + size_t TextSize() const; + double GetHeight() const; double GetAlphabeticBaseline() const; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 4d19aa453c..3d72c9199c 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -890,7 +890,8 @@ TEST_F(RenderTest, GetGlyphPositionAtCoordinateParagraph) { // Tests for GetGlyphPositionAtCoordinate() // NOTE: resulting values can be a few off from their respective positions in // the original text because the final trailing whitespaces are sometimes not - // drawn and therefore are not active glyphs. + // drawn (namely, when using "justify" alignment) and therefore are not active + // glyphs. ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(-10000, -10000), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(-1, -1), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(0, 0), 0ull); @@ -909,4 +910,117 @@ TEST_F(RenderTest, GetGlyphPositionAtCoordinateParagraph) { ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 10000), 77ull); } +TEST_F(RenderTest, GetRectsForRangeParagraph) { + const char* text = + "12345, \"67890\" 12345 67890 12345 67890 12345 67890 12345 67890 12345 " + "67890 12345"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 10; + paragraph_style.text_align = TextAlign::left; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.font_size = 50; + text_style.letter_spacing = 0; + text_style.word_spacing = 0; + text_style.color = SK_ColorBLACK; + text_style.height = 1; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(550); + + paragraph->Paint(GetCanvas(), 0, 0); + + SkPaint paint; + paint.setStyle(SkPaint::kStroke_Style); + paint.setAntiAlias(true); + paint.setStrokeWidth(1); + + // Tests for GetRectsForRange() + // NOTE: The base truth values may still need adjustment as the specifics + // are adjusted. + paint.setColor(SK_ColorRED); + std::vector rects = paragraph->GetRectsForRange(0, 0); + for (size_t i = 0; i < rects.size(); ++i) { + GetCanvas()->drawRect(rects[i], paint); + } + EXPECT_EQ(rects.size(), 1ull); + EXPECT_FLOAT_EQ(rects[0].left(), 0); + EXPECT_FLOAT_EQ(rects[0].top(), 0); + EXPECT_FLOAT_EQ(rects[0].right(), 28); + EXPECT_FLOAT_EQ(rects[0].bottom(), 47.7539); + + paint.setColor(SK_ColorBLUE); + rects = paragraph->GetRectsForRange(2, 7); + for (size_t i = 0; i < rects.size(); ++i) { + GetCanvas()->drawRect(rects[i], paint); + } + ASSERT_EQ(rects.size(), 3ull); + EXPECT_FLOAT_EQ(rects[0].left(), 56); + EXPECT_FLOAT_EQ(rects[0].top(), 0); + EXPECT_FLOAT_EQ(rects[0].right(), 151); + EXPECT_FLOAT_EQ(rects[0].bottom(), 47.7539); + + EXPECT_FLOAT_EQ(rects[1].left(), 151); + EXPECT_FLOAT_EQ(rects[1].top(), 0); + EXPECT_FLOAT_EQ(rects[1].right(), 163); + EXPECT_FLOAT_EQ(rects[1].bottom(), 47.7539); + + EXPECT_FLOAT_EQ(rects[2].left(), 163); + EXPECT_FLOAT_EQ(rects[2].top(), 0); + EXPECT_FLOAT_EQ(rects[2].right(), 175); + EXPECT_FLOAT_EQ(rects[2].bottom(), 47.7539); + + paint.setColor(SK_ColorGREEN); + rects = paragraph->GetRectsForRange(8, 20); + for (size_t i = 0; i < rects.size(); ++i) { + GetCanvas()->drawRect(rects[i], paint); + } + ASSERT_EQ(rects.size(), 3ull); + EXPECT_FLOAT_EQ(rects[0].left(), 175); + EXPECT_FLOAT_EQ(rects[0].top(), 0); + EXPECT_FLOAT_EQ(rects[0].right(), 347); + EXPECT_FLOAT_EQ(rects[0].bottom(), 47.7539); + + EXPECT_FLOAT_EQ(rects[1].left(), 347); + EXPECT_FLOAT_EQ(rects[1].top(), 0); + EXPECT_FLOAT_EQ(rects[1].right(), 359); + EXPECT_FLOAT_EQ(rects[1].bottom(), 47.7539); + + EXPECT_FLOAT_EQ(rects[2].left(), 359); + EXPECT_FLOAT_EQ(rects[2].top(), 0); + EXPECT_FLOAT_EQ(rects[2].right(), 499); + EXPECT_FLOAT_EQ(rects[2].bottom(), 47.7539); + + paint.setColor(SK_ColorRED); + rects = paragraph->GetRectsForRange(30, 100); + for (size_t i = 0; i < rects.size(); ++i) { + GetCanvas()->drawRect(rects[i], paint); + } + ASSERT_EQ(rects.size(), 17ull); + EXPECT_FLOAT_EQ(rects[0].left(), 208); + EXPECT_FLOAT_EQ(rects[0].top(), 47.753906); + EXPECT_FLOAT_EQ(rects[0].right(), 292); + EXPECT_FLOAT_EQ(rects[0].bottom(), 106.34766); + + // TODO(garyq): The following set of vals are definetly wrong and + // end of paragraph handling needs to be fixed in a later patch. + EXPECT_FLOAT_EQ(rects[16].left(), 0); + EXPECT_FLOAT_EQ(rects[16].top(), 223.53516); + EXPECT_FLOAT_EQ(rects[16].right(), 133.875); + EXPECT_FLOAT_EQ(rects[16].bottom(), 282.12891); + + ASSERT_TRUE(Snapshot()); +} + } // namespace txt From 967e80b96c64f06df79305fd058a8225681bf4cf Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 11 Jul 2017 18:38:14 -0700 Subject: [PATCH 320/364] Fix and smooth justifications to properly handle ligatures with whitespace mapping. Change-Id: I15bc093ed61f0540644ce31110769ee419dd7ac2 --- .../benchmarks/paragraph_benchmarks.cc | 44 +++++++++- engine/src/flutter/src/paragraph.cc | 85 ++++++++++++------- engine/src/flutter/src/paragraph.h | 10 ++- .../flutter/tests/txt/paragraph_unittests.cc | 2 +- 4 files changed, 108 insertions(+), 33 deletions(-) diff --git a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc index 7bbfaacba5..e92715ff1a 100644 --- a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc @@ -98,6 +98,48 @@ static void BM_ParagraphLongLayout(benchmark::State& state) { } BENCHMARK(BM_ParagraphLongLayout); +static void BM_ParagraphJustifyLayout(benchmark::State& state) { + const char* text = + "This is a very long sentence to test if the text will properly wrap " + "around and go to the next line. Sometimes, short sentence. Longer " + "sentences are okay too because they are necessary. Very short. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum. " + "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod " + "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " + "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea " + "commodo consequat. Duis aute irure dolor in reprehenderit in voluptate " + "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint " + "occaecat cupidatat non proident, sunt in culpa qui officia deserunt " + "mollit anim id est laborum."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.text_align = TextAlign::justify; + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + while (state.KeepRunning()) { + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + auto paragraph = builder.Build(); + + paragraph->Layout(300, true); + } +} +BENCHMARK(BM_ParagraphJustifyLayout); + static void BM_ParagraphManyStylesLayout(benchmark::State& state) { const char* text = "A short sentence. "; auto icu_text = icu::UnicodeString::fromUTF8(text); @@ -145,7 +187,7 @@ static void BM_ParagraphTextBigO(benchmark::State& state) { state.SetComplexityN(state.range(0)); } BENCHMARK(BM_ParagraphTextBigO) - ->RangeMultiplier(20) + ->RangeMultiplier(10) ->Range(1 << 6, 1 << 14) ->Complexity(benchmark::oN); diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index bf07472d9f..1fcad9ee75 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -16,6 +16,7 @@ #include "lib/txt/src/paragraph.h" +#include #include #include #include @@ -24,6 +25,7 @@ #include #include "lib/ftl/logging.h" +#include "lib/txt/libs/minikin/HbFontCache.h" #include "lib/txt/libs/minikin/LayoutUtils.h" #include "lib/txt/src/font_collection.h" #include "lib/txt/src/font_skia.h" @@ -140,6 +142,18 @@ void Paragraph::AddRunsToLineBreaker( } } +void Paragraph::FillWhitespaceSet(size_t start, + size_t end, + hb_font_t* hb_font) { + uint32_t unusedGlyph; + for (size_t i = start; i < end; ++i) { + if (minikin::isWordSpace(text_[i])) { + hb_font_get_glyph(hb_font, text_[i], 0, &unusedGlyph); + whitespace_set_.insert(unusedGlyph); + } + } +} + void Paragraph::Layout(double width, bool force) { // Do not allow calling layout multiple times without changing anything. if (!needs_layout_ && !force) @@ -189,7 +203,12 @@ void Paragraph::Layout(double width, bool force) { double prev_max_descent = 0.0f; double line_width = 0.0f; std::vector x_queue; - size_t character_index = 0; + double justify_spacing = 0; + + // Each blob. + std::vector buffers; + std::vector buffer_sizes; + int word_count = 0; auto postprocess_line = [this, &x_queue, &y]() -> void { size_t record_index = 0; @@ -271,12 +290,17 @@ void Paragraph::Layout(double width, bool force) { text_.size(), bidiFlags, font, minikin_paint, font_collection_->GetMinikinFontCollectionForFamily( run.style.font_family)); + + FillWhitespaceSet(run.start, run.end, + minikin::getHbFontLocked(layout.getFont(run_index))); + const size_t glyph_count = layout.nGlyphs(); size_t blob_start = 0; + // Each blob. - std::vector buffers; - std::vector buffer_sizes; - int word_count = 0; + buffers = std::vector(); + buffer_sizes = std::vector(); + word_count = 0; while (blob_start < glyph_count) { const size_t blob_length = GetBlobLength(layout, blob_start); buffer_sizes.push_back(blob_length); @@ -285,11 +309,10 @@ void Paragraph::Layout(double width, bool force) { // Check if we should remove trailing whitespace of blobs. size_t trailing_length = 0; - while ( - paragraph_style_.text_align == TextAlign::justify && - minikin::isWordSpace( - text_[character_index + blob_length - trailing_length - 1]) && - layout_end == next_break) { + while (paragraph_style_.text_align == TextAlign::justify && + minikin::isWordSpace( + text_[blob_start + blob_length - trailing_length - 1]) && + layout_end == next_break) { ++trailing_length; } @@ -307,7 +330,7 @@ void Paragraph::Layout(double width, bool force) { buffers.back()->glyphs[blob_index] = layout.getGlyphId(glyph_index); // Check if the current Glyph is a whitespace and handle multiple // whitespaces in a row. - if (minikin::isWordSpace(text_[character_index])) { + if (whitespace_set_.count(layout.getGlyphId(glyph_index)) > 0) { // Only increment word_count if it is the first in a series of // whitespaces. if (whitespace_ended) @@ -316,7 +339,7 @@ void Paragraph::Layout(double width, bool force) { } else { whitespace_ended = true; } - ++character_index; + const size_t pos_index = 2 * blob_index; buffers.back()->pos[pos_index] = @@ -328,7 +351,6 @@ void Paragraph::Layout(double width, bool force) { letter_spacing_offset += run.style.letter_spacing; } blob_start += blob_length; - character_index += trailing_length; // Subtract letter offset to avoid big gap at end of run. This my be // removed depending on the specifications for letter spacing. @@ -344,8 +366,8 @@ void Paragraph::Layout(double width, bool force) { paint.getFontMetrics(&metrics); // Apply additional word spacing if the text is justified. if (paragraph_style_.text_align == TextAlign::justify && - buffer_sizes.size() > 0 && character_index != text_.size()) { - JustifyLine(buffers, buffer_sizes, word_count, character_index); + buffer_sizes.size() > 0) { + JustifyLine(buffers, buffer_sizes, word_count, justify_spacing); } records_.push_back( PaintRecord{run.style, builder.make(), metrics, lines_}); @@ -390,9 +412,8 @@ void Paragraph::Layout(double width, bool force) { max_descent = 0.0f; x = 0.0f; letter_spacing_offset = 0.0f; - word_count = 0; + // word_count = 0; line_width = 0.0f; - character_index = layout_end; break_index += 1; lines_++; glyph_single_line_position_x = std::vector(); @@ -413,6 +434,12 @@ void Paragraph::Layout(double width, bool force) { line_heights_.push_back(FLT_MAX); glyph_single_line_position_x.push_back(FLT_MAX); glyph_position_x_.push_back(glyph_single_line_position_x); + + // Remove justification on the last line. + if (paragraph_style_.text_align == TextAlign::justify && + buffer_sizes.size() > 0) { + JustifyLine(buffers, buffer_sizes, word_count, justify_spacing, -1); + } } // Amends the buffers to incorporate justification. @@ -420,36 +447,34 @@ void Paragraph::JustifyLine( std::vector& buffers, std::vector& buffer_sizes, int word_count, - size_t character_index) { - // TODO(garyq): Add letter_spacing_offset back in. It is Temporarily - // removed. - double justify_spacing = - (width_ - breaker_.getWidths()[lines_]) / (word_count - 1); + double& justify_spacing, + double multiplier) { + // We will use the previous justification spacing when undoing justification. + if (multiplier > 0) { + justify_spacing = + (width_ - breaker_.getWidths()[lines_]) / (word_count - 1); + } word_count = 0; - // Set up index to properly access text_ because minikin::isWordSpace() - // takes uint_16 instead of GlyphIDs. - size_t line_character_index = character_index; - for (size_t i = 0; i < buffers.size(); ++i) - line_character_index -= buffer_sizes[i]; bool whitespace_ended = true; for (size_t i = 0; i < buffers.size(); ++i) { for (size_t glyph_index = 0; glyph_index < buffer_sizes[i]; ++glyph_index) { // Check if the current Glyph is a whitespace and handle multiple // whitespaces in a row. - if (minikin::isWordSpace(text_[line_character_index])) { + if (whitespace_set_.count(buffers[i]->glyphs[glyph_index]) > 0) { // Only increment word_count and add justification spacing to // whitespace if it is the first in a series of whitespaces. if (whitespace_ended) { ++word_count; - buffers[i]->pos[glyph_index * 2] += justify_spacing * word_count; + buffers[i]->pos[glyph_index * 2] += + justify_spacing * multiplier * word_count; } whitespace_ended = false; } else { // Add justification spacing for all non-whitespace glyphs. - buffers[i]->pos[glyph_index * 2] += justify_spacing * word_count; + buffers[i]->pos[glyph_index * 2] += + justify_spacing * multiplier * word_count; whitespace_ended = true; } - ++line_character_index; } } } diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 7b5278fc91..87398f126d 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -35,6 +35,8 @@ class SkCanvas; namespace txt { +using GlyphID = uint32_t; + class Paragraph { public: Paragraph(); @@ -97,6 +99,9 @@ class Paragraph { std::vector line_heights_; std::vector> glyph_position_x_; + // Set of glyph IDs that correspond to whitespace. + std::set whitespace_set_; + ParagraphStyle paragraph_style_; FontCollection* font_collection_; SkScalar height_ = 0.0f; @@ -128,10 +133,13 @@ class Paragraph { std::unordered_map>& collection_map); + void FillWhitespaceSet(size_t start, size_t end, hb_font_t* hb_font); + void JustifyLine(std::vector& buffers, std::vector& buffer_sizes, int word_count, - size_t character_index); + double& justify_spacing, + double multiplier = 1); void PaintDecorations(SkCanvas* canvas, double x, diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 3d72c9199c..3b9a5f5c7e 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -588,7 +588,7 @@ TEST_F(RenderTest, JustifyAlignParagraph) { txt::TextStyle text_style; text_style.font_size = 26; - text_style.letter_spacing = 1; + text_style.letter_spacing = 0; text_style.word_spacing = 5; text_style.color = SK_ColorBLACK; text_style.height = 1; From 97e0ba1bdf1c90afee5092329209eeb347aed549 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 12 Jul 2017 14:52:40 -0700 Subject: [PATCH 321/364] Fix crash bug and add spacing tests. Change-Id: Idc3eaeaf6ff6230ea6b804b3d4ed8819eb5a7a7d --- engine/src/flutter/src/paragraph.cc | 3 +- engine/src/flutter/src/paragraph.h | 1 + .../flutter/tests/txt/paragraph_unittests.cc | 92 ++++++++++++++++++- 3 files changed, 93 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 1fcad9ee75..e1c599df2f 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -290,9 +290,8 @@ void Paragraph::Layout(double width, bool force) { text_.size(), bidiFlags, font, minikin_paint, font_collection_->GetMinikinFontCollectionForFamily( run.style.font_family)); - FillWhitespaceSet(run.start, run.end, - minikin::getHbFontLocked(layout.getFont(run_index))); + minikin::getHbFontLocked(layout.getFont(0))); const size_t glyph_count = layout.nGlyphs(); size_t blob_start = 0; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 87398f126d..5bfe723ad4 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -88,6 +88,7 @@ class Paragraph { FRIEND_TEST(RenderTest, ItalicsParagraph); FRIEND_TEST(RenderTest, ChineseParagraph); FRIEND_TEST(RenderTest, DISABLED_ArabicParagraph); + FRIEND_TEST(RenderTest, SpacingParagraph); std::vector text_; StyledRuns runs_; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 3b9a5f5c7e..2bbde91192 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -1015,7 +1015,7 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { // TODO(garyq): The following set of vals are definetly wrong and // end of paragraph handling needs to be fixed in a later patch. - EXPECT_FLOAT_EQ(rects[16].left(), 0); + EXPECT_FLOAT_EQ(rects[16].left(), 0); EXPECT_FLOAT_EQ(rects[16].top(), 223.53516); EXPECT_FLOAT_EQ(rects[16].right(), 133.875); EXPECT_FLOAT_EQ(rects[16].bottom(), 282.12891); @@ -1023,4 +1023,94 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { ASSERT_TRUE(Snapshot()); } +TEST_F(RenderTest, SpacingParagraph) { + const char* text = "H"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 10; + paragraph_style.text_align = TextAlign::left; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.font_size = 50; + text_style.letter_spacing = 20; + text_style.word_spacing = 0; + text_style.color = SK_ColorBLACK; + text_style.height = 1; + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + + text_style.font_size = 50; + text_style.letter_spacing = 10; + text_style.word_spacing = 0; + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + + text_style.font_size = 50; + text_style.letter_spacing = 20; + text_style.word_spacing = 0; + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + + text_style.font_size = 50; + text_style.letter_spacing = 0; + text_style.word_spacing = 0; + builder.PushStyle(text_style); + builder.AddText("|"); + builder.Pop(); + + text_style.font_size = 50; + text_style.letter_spacing = 0; + text_style.word_spacing = 20; + builder.PushStyle(text_style); + builder.AddText("H "); + builder.Pop(); + + text_style.font_size = 50; + text_style.letter_spacing = 0; + text_style.word_spacing = 0; + builder.PushStyle(text_style); + builder.AddText("H "); + builder.Pop(); + + text_style.font_size = 50; + text_style.letter_spacing = 0; + text_style.word_spacing = 20; + builder.PushStyle(text_style); + builder.AddText("H "); + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(550); + + paragraph->Paint(GetCanvas(), 0, 0); + + SkPaint paint; + paint.setStyle(SkPaint::kStroke_Style); + paint.setAntiAlias(true); + paint.setStrokeWidth(1); + paint.setColor(SK_ColorRED); + + ASSERT_TRUE(Snapshot()); + + ASSERT_EQ(paragraph->records_.size(), 7ull); + ASSERT_EQ(paragraph->records_[0].style().letter_spacing, 20); + ASSERT_EQ(paragraph->records_[1].style().letter_spacing, 10); + ASSERT_EQ(paragraph->records_[2].style().letter_spacing, 20); + + ASSERT_EQ(paragraph->records_[4].style().word_spacing, 20); + ASSERT_EQ(paragraph->records_[5].style().word_spacing, 0); + ASSERT_EQ(paragraph->records_[6].style().word_spacing, 20); + + + +} + } // namespace txt From 8c0962d728a27fd751bfd8b120ce64d631ca64d2 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 12 Jul 2017 17:06:59 -0700 Subject: [PATCH 322/364] Fix/enable proper font weight selection. Change-Id: I3cd1eb7758708d90a6c99384cb336c65c1e5c5c3 --- engine/src/flutter/src/font_collection.cc | 2 +- engine/src/flutter/src/paragraph.cc | 1 - engine/src/flutter/src/text_style.cc | 2 -- engine/src/flutter/src/text_style.h | 1 - engine/src/flutter/tests/txt/paragraph_unittests.cc | 8 ++++---- 5 files changed, 5 insertions(+), 9 deletions(-) diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index ca8132e7c6..cf9bdb9281 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -169,7 +169,7 @@ FontCollection::GetMinikinFontCollectionForFamily(const std::string& family) { // Create the minikin font from the skia typeface. minikin::Font minikin_font( std::make_shared(skia_typeface), - minikin::FontStyle{skia_typeface->fontStyle().weight(), + minikin::FontStyle{skia_typeface->fontStyle().weight() / 100, skia_typeface->isItalic()}); minikin_fonts.emplace_back(std::move(minikin_font)); diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index e1c599df2f..dce596447c 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -104,7 +104,6 @@ void GetFontAndMinikinPaint(const TextStyle& style, void GetPaint(const TextStyle& style, SkPaint* paint) { paint->setTextSize(style.font_size); - paint->setFakeBoldText(style.fake_bold); } } // namespace diff --git a/engine/src/flutter/src/text_style.cc b/engine/src/flutter/src/text_style.cc index 7965318cd6..fa9e510cff 100644 --- a/engine/src/flutter/src/text_style.cc +++ b/engine/src/flutter/src/text_style.cc @@ -36,8 +36,6 @@ bool TextStyle::equals(const TextStyle& other) const { return false; if (font_style != other.font_style) return false; - if (fake_bold != other.fake_bold) - return false; if (font_family != other.font_family) return false; if (letter_spacing != other.letter_spacing) diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index 8ed552dd80..249b0f4699 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -36,7 +36,6 @@ class TextStyle { double decoration_thickness = 1.0; FontWeight font_weight = FontWeight::w400; FontStyle font_style = FontStyle::normal; - bool fake_bold = false; TextBaseline text_baseline = TextBaseline::kAlphabetic; std::string font_family = ""; double font_size = 14.0; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 2bbde91192..54f64c58ca 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -136,7 +136,6 @@ TEST_F(RenderTest, RainbowParagraph) { text_style2.letter_spacing = 10; text_style2.word_spacing = 30; text_style2.font_weight = txt::FontWeight::w600; - text_style2.fake_bold = true; text_style2.color = SK_ColorGREEN; text_style2.decoration = txt::TextDecoration(0x1 | 0x2 | 0x4); text_style2.decoration_color = SK_ColorBLACK; @@ -229,10 +228,10 @@ TEST_F(RenderTest, BoldParagraph) { txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; + text_style.font_family = "Roboto"; text_style.font_size = 60; - text_style.letter_spacing = 10; - text_style.font_weight = txt::FontWeight::w700; - text_style.fake_bold = true; + text_style.letter_spacing = 0; + text_style.font_weight = txt::FontWeight::w900; text_style.color = SK_ColorRED; builder.PushStyle(text_style); @@ -927,6 +926,7 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { txt::TextStyle text_style; text_style.font_size = 50; text_style.letter_spacing = 0; + text_style.font_weight = FontWeight::w500; text_style.word_spacing = 0; text_style.color = SK_ColorBLACK; text_style.height = 1; From 18ed4e65c98621f2af2157bf5509714642206f88 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 13 Jul 2017 10:24:41 -0700 Subject: [PATCH 323/364] Rework the height and spacing, add comments. Change-Id: I5ad517b0e1aa3938da63c4069880768477b788ac --- engine/src/flutter/src/font_collection.h | 12 ++++++++++++ engine/src/flutter/src/font_weight.h | 18 +++++++++--------- engine/src/flutter/src/paragraph.cc | 18 ++++++++++-------- engine/src/flutter/src/paragraph.h | 10 ++++++++++ engine/src/flutter/src/paragraph_builder.h | 17 +++++++++++++++++ engine/src/flutter/src/styled_runs.h | 2 ++ .../flutter/tests/txt/paragraph_unittests.cc | 8 ++++++++ 7 files changed, 68 insertions(+), 17 deletions(-) diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index 865af8b380..ac09bc7eca 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -36,6 +36,8 @@ namespace txt { +// FontCollection holds a vector of Skia Font Managers and handles font +// fallback. class FontCollection { public: enum CacheMethod { @@ -52,6 +54,10 @@ class FontCollection { // Will be deprecated when full compatibility with Flutter Engine is complete. static FontCollection& GetFontCollection(std::vector dirs); + // Provides a pointer to the minikin FontCollection for the given font family. + // If the famly is not in any font manager, this will return a nullptr. Once a + // font is loaded, it is cached and future calls will be very efficient (until + // the font is flushed). std::shared_ptr GetMinikinFontCollectionForFamily( const std::string& family); @@ -70,10 +76,16 @@ class FontCollection { // Provides a set of all available family names. std::set GetFamilyNames(); + // Returns true when the supplied font family exists in any of the font + // managers. bool HasFamily(const std::string family) const; + // Removes all fonts that do not fit in the cache capacity from memory. void FlushCache(); + // When in LRU mode, the cache will only hold the most recently used + // fonts. This may be used when the application becomes low on memory or a + // very large number of fonts are used. void SetCacheCapacity(const size_t cap); // Call this to limit memory usage by cached fonts. SetLowMemoryMode() will diff --git a/engine/src/flutter/src/font_weight.h b/engine/src/flutter/src/font_weight.h index cd1811e14d..c3d6745b7a 100644 --- a/engine/src/flutter/src/font_weight.h +++ b/engine/src/flutter/src/font_weight.h @@ -20,15 +20,15 @@ namespace txt { enum class FontWeight { - w100, - w200, - w300, - w400, - w500, - w600, - w700, - w800, - w900, + w100, // Thin + w200, // Extra-Light + w300, // Light + w400, // Normal/Regular + w500, // Medium + w600, // Semi-bold + w700, // Bold + w800, // Extra-Bold + w900, // Black }; } // namespace txt diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index dce596447c..e1506ea127 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -299,6 +299,7 @@ void Paragraph::Layout(double width, bool force) { buffers = std::vector(); buffer_sizes = std::vector(); word_count = 0; + double temp_line_spacing = 0; while (blob_start < glyph_count) { const size_t blob_length = GetBlobLength(layout, blob_start); buffer_sizes.push_back(blob_length); @@ -378,11 +379,11 @@ void Paragraph::Layout(double width, bool force) { // finished. x_queue.push_back(x); - if (max_line_spacing < - (-metrics.fAscent + metrics.fLeading) * run.style.height) { - max_line_spacing = lines_ == 0 ? metrics.fCapHeight * run.style.height - : (-metrics.fAscent + metrics.fLeading) * - run.style.height; + temp_line_spacing = lines_ == 0 ? metrics.fCapHeight * run.style.height + : (-metrics.fAscent + metrics.fLeading) * + run.style.height; + if (max_line_spacing < temp_line_spacing) { + max_line_spacing = temp_line_spacing; // Record the alphabetic_baseline_: if (lines_ == 0) { alphabetic_baseline_ = metrics.fCapHeight * run.style.height; @@ -392,8 +393,9 @@ void Paragraph::Layout(double width, bool force) { run.style.height; } } - if (max_descent < metrics.fDescent * run.style.height) - max_descent = metrics.fDescent * run.style.height; + temp_line_spacing = metrics.fDescent * run.style.height; + if (max_descent < temp_line_spacing) + max_descent = temp_line_spacing; if (layout_end == next_break) { y += max_line_spacing + prev_max_descent; @@ -504,7 +506,7 @@ size_t Paragraph::TextSize() const { } double Paragraph::GetHeight() const { - return height_; + return line_heights_[line_heights_.size() - 2]; } void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 5bfe723ad4..a0785e647a 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -61,12 +61,19 @@ class Paragraph { double GetMinIntrinsicWidth() const; + // Returns a vector of bounding boxes that enclose all text between start and + // end glyph indexes. std::vector GetRectsForRange(size_t start, size_t end) const; + // Returns the index of the glyph that corresponds to the provided coordinate, + // with the top left corner as the origin, and +y direction as down. size_t GetGlyphPositionAtCoordinate(double dx, double dy) const; + // Returns a bounding box that encloses the glyph at the index pos. SkRect GetCoordinatesForGlyphPosition(size_t pos) const; + // Finds the first and last glyphs that define a word containing the glyph at + // index offset. SkIPoint GetWordBoundary(size_t offset) const; int GetLineCount() const; @@ -134,6 +141,9 @@ class Paragraph { std::unordered_map>& collection_map); + // Calculates the GlyphIDs of all whitespace characters present in the text + // between start and end. THis is used to correctly add extra whitespace when + // justifying. void FillWhitespaceSet(size_t start, size_t end, hb_font_t* hb_font); void JustifyLine(std::vector& buffers, diff --git a/engine/src/flutter/src/paragraph_builder.h b/engine/src/flutter/src/paragraph_builder.h index 07d92e69d6..4fbd07b187 100644 --- a/engine/src/flutter/src/paragraph_builder.h +++ b/engine/src/flutter/src/paragraph_builder.h @@ -39,8 +39,21 @@ class ParagraphBuilder { ~ParagraphBuilder(); + // Push a style to the stack. The corresponding text added with AddText will + // use the top-most style. void PushStyle(const TextStyle& style); + // Remove a style from the stack. Useful to apply different styles to chunks + // of text such as bolding. + // Example: + // builder.PushStyle(normal_style); + // builder.AddText("Hello this is normal. "); + // + // builder.PushStyle(bold_style); + // builder.AddText("And this is BOLD. "); + // + // builder.Pop(); + // builder.AddText(" Back to normal again."); void Pop(); void AddText(const std::u16string& text); @@ -51,8 +64,12 @@ class ParagraphBuilder { void SetParagraphStyle(const ParagraphStyle& style); + // It is recommended to initialize the ParagraphBuilder with a font collection + // as default font collection fallback will be deprecated. void SetFontCollection(FontCollection* font_collection); + // Constructs a Paragraph object that can be used to layout and paint the text + // to a SkCanvas. std::unique_ptr Build(); private: diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index dbaa111db3..d88306d704 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -24,6 +24,8 @@ namespace txt { +// This holds and handles the start/end positions of discrete chunks of text +// that use different styles (a 'run'). class StyledRuns { public: struct Run { diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 54f64c58ca..0f2b0ac244 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -348,6 +348,8 @@ TEST_F(RenderTest, LeftAlignParagraph) { ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 30), 68ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 60), 134ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(2000, 30), 133ull); + + ASSERT_TRUE(Snapshot()); } TEST_F(RenderTest, RightAlignParagraph) { @@ -397,6 +399,8 @@ TEST_F(RenderTest, RightAlignParagraph) { paragraph->Layout(GetTestCanvasWidth() - 100); paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_TRUE(Snapshot()); ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); @@ -499,6 +503,8 @@ TEST_F(RenderTest, CenterAlignParagraph) { paragraph->Layout(GetTestCanvasWidth() - 100); paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_TRUE(Snapshot()); ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); @@ -603,6 +609,8 @@ TEST_F(RenderTest, JustifyAlignParagraph) { paragraph->Layout(GetTestCanvasWidth() - 100); paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_TRUE(Snapshot()); ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); From 13f2e067c6f0bf88ce7573ea54c80dbd176051f8 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 13 Jul 2017 18:40:39 -0700 Subject: [PATCH 324/364] Use source_set instead of static_library, fix a segfault crash, and fix text positioning. Change-Id: I1bc5f1076c25a757aa8550732a4ae0c4fc36b127 --- engine/src/flutter/BUILD.gn | 2 +- engine/src/flutter/libs/minikin/BUILD.gn | 2 +- .../src/flutter/libs/minikin/LineBreaker.cpp | 2 +- engine/src/flutter/src/paragraph.cc | 8 +-- engine/src/flutter/src/text_style.h | 4 +- .../flutter/tests/txt/paragraph_unittests.cc | 50 +++++++++---------- 6 files changed, 35 insertions(+), 33 deletions(-) diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn index 11ff6440bd..9aabc9ec04 100644 --- a/engine/src/flutter/BUILD.gn +++ b/engine/src/flutter/BUILD.gn @@ -20,7 +20,7 @@ config("txt_config") { ] } -static_library("txt") { +source_set("txt") { if (current_toolchain == host_toolchain) { defines = [ "DIRECTORY_FONT_MANAGER_AVAILABLE" ] } diff --git a/engine/src/flutter/libs/minikin/BUILD.gn b/engine/src/flutter/libs/minikin/BUILD.gn index f723d0a8e1..f622712d22 100644 --- a/engine/src/flutter/libs/minikin/BUILD.gn +++ b/engine/src/flutter/libs/minikin/BUILD.gn @@ -16,7 +16,7 @@ config("minikin_config") { include_dirs = [ "../../include" ] } -static_library("minikin") { +source_set("minikin") { defines = [ "WIP_NEEDS_ICU_UPDATE" ] sources = [ diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 97f4798253..62dbd830bb 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -367,7 +367,7 @@ float LineBreaker::currentLineWidth() const { void LineBreaker::computeBreaksGreedy() { // All breaks but the last have been added in addCandidate already. size_t nCand = mCandidates.size(); - if (nCand == 1 || mLastBreak != nCand - 1) { + if (nCand > 0 && (nCand == 1 || mLastBreak != nCand - 1)) { pushBreak(mCandidates[nCand - 1].offset, mCandidates[nCand - 1].postBreak - mPreBreak, mLastHyphenation); // don't need to update mBestScore, because we're done diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index e1506ea127..f59dde05f2 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -379,7 +379,7 @@ void Paragraph::Layout(double width, bool force) { // finished. x_queue.push_back(x); - temp_line_spacing = lines_ == 0 ? metrics.fCapHeight * run.style.height + temp_line_spacing = lines_ == 0 ? -metrics.fAscent * run.style.height : (-metrics.fAscent + metrics.fLeading) * run.style.height; if (max_line_spacing < temp_line_spacing) { @@ -521,14 +521,16 @@ void Paragraph::SetFontCollection(FontCollection* font_collection) { // The x,y coordinates will be the very top left corner of the rendered // paragraph. void Paragraph::Paint(SkCanvas* canvas, double x, double y) { + canvas->translate(x, y); for (const auto& record : records_) { SkPaint paint; paint.setColor(record.style().color); SkPoint offset = record.offset(); - canvas->drawTextBlob(record.text(), x + offset.x(), y + offset.y(), paint); - PaintDecorations(canvas, x + offset.x(), y + offset.y(), record.style(), + canvas->drawTextBlob(record.text(), offset.x(), offset.y(), paint); + PaintDecorations(canvas, offset.x(), offset.y(), record.style(), record.metrics(), record.text()); } + canvas->translate(-x, -y); } void Paragraph::PaintDecorations(SkCanvas* canvas, diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index 249b0f4699..a6ff1b53ed 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -29,9 +29,9 @@ namespace txt { class TextStyle { public: - SkColor color = SK_ColorWHITE; + SkColor color = SK_ColorBLACK; TextDecoration decoration = TextDecoration::kNone; - SkColor decoration_color = SK_ColorWHITE; + SkColor decoration_color = SK_ColorTRANSPARENT; TextDecorationStyle decoration_style = TextDecorationStyle::kSolid; double decoration_thickness = 1.0; FontWeight font_weight = FontWeight::w400; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 0f2b0ac244..7ac89151be 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -313,7 +313,7 @@ TEST_F(RenderTest, LeftAlignParagraph) { ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); - double expected_y = 18.484375; + double expected_y = 24.12109375; ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); @@ -345,9 +345,9 @@ TEST_F(RenderTest, LeftAlignParagraph) { // Tests for GetGlyphPositionAtCoordinate() ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(0, 0), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 1), 0ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 30), 68ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 60), 134ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(2000, 30), 133ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 35), 68ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 70), 134ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(2000, 35), 133ull); ASSERT_TRUE(Snapshot()); } @@ -409,7 +409,7 @@ TEST_F(RenderTest, RightAlignParagraph) { ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); - double expected_y = 18.484375; + double expected_y = 24.12109375; ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); @@ -513,7 +513,7 @@ TEST_F(RenderTest, CenterAlignParagraph) { ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); - double expected_y = 18.484375; + double expected_y = 24.12109375; ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); @@ -619,7 +619,7 @@ TEST_F(RenderTest, JustifyAlignParagraph) { ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); - double expected_y = 18.484375; + double expected_y = 24.12109375; ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); @@ -905,15 +905,15 @@ TEST_F(RenderTest, GetGlyphPositionAtCoordinateParagraph) { ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(3, 3), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 1), 1ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 20), 17ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 80), 35ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(-100000, 80), 18ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 90), 35ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(-100000, 90), 18ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(20, -80), 0ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 80), 18ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 160), 36ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 160), 53ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(70, 160), 38ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 90), 18ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 180), 36ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 180), 53ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(70, 180), 38ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 270), 54ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 80), 19ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 90), 19ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 10000), 77ull); } @@ -966,7 +966,7 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[0].left(), 0); EXPECT_FLOAT_EQ(rects[0].top(), 0); EXPECT_FLOAT_EQ(rects[0].right(), 28); - EXPECT_FLOAT_EQ(rects[0].bottom(), 47.7539); + EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); paint.setColor(SK_ColorBLUE); rects = paragraph->GetRectsForRange(2, 7); @@ -977,17 +977,17 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[0].left(), 56); EXPECT_FLOAT_EQ(rects[0].top(), 0); EXPECT_FLOAT_EQ(rects[0].right(), 151); - EXPECT_FLOAT_EQ(rects[0].bottom(), 47.7539); + EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); EXPECT_FLOAT_EQ(rects[1].left(), 151); EXPECT_FLOAT_EQ(rects[1].top(), 0); EXPECT_FLOAT_EQ(rects[1].right(), 163); - EXPECT_FLOAT_EQ(rects[1].bottom(), 47.7539); + EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); EXPECT_FLOAT_EQ(rects[2].left(), 163); EXPECT_FLOAT_EQ(rects[2].top(), 0); EXPECT_FLOAT_EQ(rects[2].right(), 175); - EXPECT_FLOAT_EQ(rects[2].bottom(), 47.7539); + EXPECT_FLOAT_EQ(rects[2].bottom(), 58.59375); paint.setColor(SK_ColorGREEN); rects = paragraph->GetRectsForRange(8, 20); @@ -998,17 +998,17 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[0].left(), 175); EXPECT_FLOAT_EQ(rects[0].top(), 0); EXPECT_FLOAT_EQ(rects[0].right(), 347); - EXPECT_FLOAT_EQ(rects[0].bottom(), 47.7539); + EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); EXPECT_FLOAT_EQ(rects[1].left(), 347); EXPECT_FLOAT_EQ(rects[1].top(), 0); EXPECT_FLOAT_EQ(rects[1].right(), 359); - EXPECT_FLOAT_EQ(rects[1].bottom(), 47.7539); + EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); EXPECT_FLOAT_EQ(rects[2].left(), 359); EXPECT_FLOAT_EQ(rects[2].top(), 0); EXPECT_FLOAT_EQ(rects[2].right(), 499); - EXPECT_FLOAT_EQ(rects[2].bottom(), 47.7539); + EXPECT_FLOAT_EQ(rects[2].bottom(), 58.59375); paint.setColor(SK_ColorRED); rects = paragraph->GetRectsForRange(30, 100); @@ -1017,16 +1017,16 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { } ASSERT_EQ(rects.size(), 17ull); EXPECT_FLOAT_EQ(rects[0].left(), 208); - EXPECT_FLOAT_EQ(rects[0].top(), 47.753906); + EXPECT_FLOAT_EQ(rects[0].top(), 58.59375); EXPECT_FLOAT_EQ(rects[0].right(), 292); - EXPECT_FLOAT_EQ(rects[0].bottom(), 106.34766); + EXPECT_FLOAT_EQ(rects[0].bottom(), 117.1875); // TODO(garyq): The following set of vals are definetly wrong and // end of paragraph handling needs to be fixed in a later patch. EXPECT_FLOAT_EQ(rects[16].left(), 0); - EXPECT_FLOAT_EQ(rects[16].top(), 223.53516); + EXPECT_FLOAT_EQ(rects[16].top(), 234.375); EXPECT_FLOAT_EQ(rects[16].right(), 133.875); - EXPECT_FLOAT_EQ(rects[16].bottom(), 282.12891); + EXPECT_FLOAT_EQ(rects[16].bottom(), 292.96875); ASSERT_TRUE(Snapshot()); } From 1a68f70b47721940dbb6781aafcdc974241fa7fe Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 14 Jul 2017 18:22:20 -0700 Subject: [PATCH 325/364] Setup methods and variables to accommodate actual intrinsic width algorithms. Change-Id: I7295a970488052f9b471617518afd7a757d8f5c0 --- engine/src/flutter/src/paragraph.cc | 53 +++++++++++++++++++++-------- engine/src/flutter/src/paragraph.h | 9 +++-- 2 files changed, 46 insertions(+), 16 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index f59dde05f2..a2d2e03a77 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -203,8 +203,8 @@ void Paragraph::Layout(double width, bool force) { double line_width = 0.0f; std::vector x_queue; double justify_spacing = 0; + double prev_word_pos = 0; - // Each blob. std::vector buffers; std::vector buffer_sizes; int word_count = 0; @@ -327,17 +327,6 @@ void Paragraph::Layout(double width, bool force) { ++blob_index) { const size_t glyph_index = blob_start + blob_index; buffers.back()->glyphs[blob_index] = layout.getGlyphId(glyph_index); - // Check if the current Glyph is a whitespace and handle multiple - // whitespaces in a row. - if (whitespace_set_.count(layout.getGlyphId(glyph_index)) > 0) { - // Only increment word_count if it is the first in a series of - // whitespaces. - if (whitespace_ended) - ++word_count; - whitespace_ended = false; - } else { - whitespace_ended = true; - } const size_t pos_index = 2 * blob_index; @@ -347,10 +336,36 @@ void Paragraph::Layout(double width, bool force) { buffers.back()->pos[pos_index]); buffers.back()->pos[pos_index + 1] = layout.getY(glyph_index); + // Check if the current Glyph is a whitespace and handle multiple + // whitespaces in a row. + if (whitespace_set_.count(layout.getGlyphId(glyph_index)) > 0) { + // Only increment word_count if it is the first in a series of + // whitespaces. + if (whitespace_ended) { + ++word_count; + word_widths_.push_back(buffers.back()->pos[pos_index] + + layout.getCharAdvance(glyph_index) - + prev_word_pos); + prev_word_pos = buffers.back()->pos[pos_index] + + layout.getCharAdvance(glyph_index); + } + whitespace_ended = false; + } else { + whitespace_ended = true; + } + letter_spacing_offset += run.style.letter_spacing; } blob_start += blob_length; + // Add on the last word if the blob break was not on whitespace. + if (whitespace_ended) { + word_widths_.push_back( + layout.getX(blob_start - 1) + letter_spacing_offset - + run.style.letter_spacing + layout.getCharAdvance(blob_start - 1) - + prev_word_pos); + } + // Subtract letter offset to avoid big gap at end of run. This my be // removed depending on the specifications for letter spacing. // letter_spacing_offset -= run.style.letter_spacing; @@ -412,7 +427,7 @@ void Paragraph::Layout(double width, bool force) { max_descent = 0.0f; x = 0.0f; letter_spacing_offset = 0.0f; - // word_count = 0; + prev_word_pos = 0; line_width = 0.0f; break_index += 1; lines_++; @@ -440,6 +455,7 @@ void Paragraph::Layout(double width, bool force) { buffer_sizes.size() > 0) { JustifyLine(buffers, buffer_sizes, word_count, justify_spacing, -1); } + CalculateIntrinsicWidths(); } // Amends the buffers to incorporate justification. @@ -492,13 +508,22 @@ double Paragraph::GetIdeographicBaseline() const { return ideographic_baseline_; } +void Paragraph::CalculateIntrinsicWidths() { + for (size_t i = 0; i < word_widths_.size(); ++i) { + max_intrinsic_width_ += word_widths_[i]; + } + + // TODO(garyq): Implement the DP algorithm version instead of this stand in! + min_intrinsic_width_ = max_intrinsic_width_ / paragraph_style_.max_lines; +} + double Paragraph::GetMaxIntrinsicWidth() const { return max_intrinsic_width_; } double Paragraph::GetMinIntrinsicWidth() const { // TODO(garyq): This is a lower bound. Actual value may be slightly higher. - return max_intrinsic_width_ / paragraph_style_.max_lines; + return min_intrinsic_width_; } size_t Paragraph::TextSize() const { diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index a0785e647a..870e64f431 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -115,8 +115,11 @@ class Paragraph { SkScalar height_ = 0.0f; double width_ = 0.0f; size_t lines_ = 0; - double max_intrinsic_width_ = 0.0f; - double min_intrinsic_width_ = 0.0f; + double max_intrinsic_width_ = -1; + double min_intrinsic_width_ = -1; + // TODO(garyq): Instead of using whitespace to delimit "words", use the + // results of minikin breaker. + std::vector word_widths_; double alphabetic_baseline_ = FLT_MAX; double ideographic_baseline_ = FLT_MAX; bool needs_layout_ = true; @@ -167,6 +170,8 @@ class Paragraph { double y_offset, double width); + void CalculateIntrinsicWidths(); + FTL_DISALLOW_COPY_AND_ASSIGN(Paragraph); }; From 69b2d8180ac9aba66bd4e1bb58ec16cc5b6efeee Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 17 Jul 2017 14:40:43 -0700 Subject: [PATCH 326/364] Min and Max Intrinsic Widths look mostly correct now. Change-Id: I0201c88bab4a46baf5164def8cccd51f4c5486c1 --- engine/src/flutter/src/paragraph.cc | 40 +++++++++++++++---- engine/src/flutter/src/paragraph.h | 10 ++++- engine/src/flutter/src/paragraph_style.h | 3 +- .../flutter/tests/txt/paragraph_unittests.cc | 2 +- 4 files changed, 44 insertions(+), 11 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index a2d2e03a77..ba8f5ac663 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -401,11 +401,10 @@ void Paragraph::Layout(double width, bool force) { max_line_spacing = temp_line_spacing; // Record the alphabetic_baseline_: if (lines_ == 0) { - alphabetic_baseline_ = metrics.fCapHeight * run.style.height; + alphabetic_baseline_ = -metrics.fAscent * run.style.height; // TODO(garyq): Properly implement ideographic_baseline_. ideographic_baseline_ = - (metrics.fUnderlinePosition + metrics.fCapHeight) * - run.style.height; + (metrics.fUnderlinePosition - metrics.fAscent) * run.style.height; } } temp_line_spacing = metrics.fDescent * run.style.height; @@ -455,6 +454,8 @@ void Paragraph::Layout(double width, bool force) { buffer_sizes.size() > 0) { JustifyLine(buffers, buffer_sizes, word_count, justify_spacing, -1); } + line_widths_ = + std::vector(breaker_.getWidths(), breaker_.getWidths() + lines_); CalculateIntrinsicWidths(); } @@ -509,12 +510,25 @@ double Paragraph::GetIdeographicBaseline() const { } void Paragraph::CalculateIntrinsicWidths() { - for (size_t i = 0; i < word_widths_.size(); ++i) { - max_intrinsic_width_ += word_widths_[i]; + // TODO(garyq): Investigate correctness of the following implementation of max + // intrinsic width. This is currently the sum of all the widths of each line + // after layout. + max_intrinsic_width_ = 0; + for (size_t i = 0; i < line_widths_.size(); ++i) { + max_intrinsic_width_ += line_widths_[i]; } - // TODO(garyq): Implement the DP algorithm version instead of this stand in! - min_intrinsic_width_ = max_intrinsic_width_ / paragraph_style_.max_lines; + // TODO(garyq): Investigate correctness of the following implementation of max + // intrinsic width. This is currently the longest line in the text after + // layout. + min_intrinsic_width_ = 0; + for (size_t i = 0; i < line_widths_.size(); ++i) { + min_intrinsic_width_ = std::max(min_intrinsic_width_, line_widths_[i]); + } + + // Ensure that min < max widths. + min_intrinsic_width_ = std::min(max_intrinsic_width_, min_intrinsic_width_); + max_intrinsic_width_ = std::max(max_intrinsic_width_, min_intrinsic_width_); } double Paragraph::GetMaxIntrinsicWidth() const { @@ -534,6 +548,18 @@ double Paragraph::GetHeight() const { return line_heights_[line_heights_.size() - 2]; } +double Paragraph::GetLayoutWidth() const { + double w = 0; + for (size_t i = 0; i < line_widths_.size(); ++i) { + w = std::max(w, line_widths_[i]); + } + return w; +} + +double Paragraph::GetMaxWidth() const { + return width_; +} + void Paragraph::SetParagraphStyle(const ParagraphStyle& style) { needs_layout_ = true; paragraph_style_ = style; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 870e64f431..0e16de48ec 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -53,6 +53,12 @@ class Paragraph { double GetHeight() const; + // Returns the actual max width of the longest line after Layout(). + double GetLayoutWidth() const; + + // Returns the width provided in the Layout() method. + double GetMaxWidth() const; + double GetAlphabeticBaseline() const; double GetIdeographicBaseline() const; @@ -115,8 +121,8 @@ class Paragraph { SkScalar height_ = 0.0f; double width_ = 0.0f; size_t lines_ = 0; - double max_intrinsic_width_ = -1; - double min_intrinsic_width_ = -1; + double max_intrinsic_width_ = 0; + double min_intrinsic_width_ = 0; // TODO(garyq): Instead of using whitespace to delimit "words", use the // results of minikin breaker. std::vector word_widths_; diff --git a/engine/src/flutter/src/paragraph_style.h b/engine/src/flutter/src/paragraph_style.h index 9f30869a15..b6ae31e060 100644 --- a/engine/src/flutter/src/paragraph_style.h +++ b/engine/src/flutter/src/paragraph_style.h @@ -17,6 +17,7 @@ #ifndef LIB_TXT_SRC_PARAGRAPH_STYLE_H_ #define LIB_TXT_SRC_PARAGRAPH_STYLE_H_ +#include #include #include "lib/txt/src/font_style.h" @@ -32,7 +33,7 @@ class ParagraphStyle { FontStyle font_style = FontStyle::normal; std::string font_family = ""; double font_size = 14; - size_t max_lines = 1; + size_t max_lines = UINT_MAX; double line_height = 1.0; std::string ellipsis = "..."; // TODO(garyq): Implement right to left. diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 7ac89151be..719eeb9103 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -1025,7 +1025,7 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { // end of paragraph handling needs to be fixed in a later patch. EXPECT_FLOAT_EQ(rects[16].left(), 0); EXPECT_FLOAT_EQ(rects[16].top(), 234.375); - EXPECT_FLOAT_EQ(rects[16].right(), 133.875); + EXPECT_FLOAT_EQ(rects[16].right(), 140); EXPECT_FLOAT_EQ(rects[16].bottom(), 292.96875); ASSERT_TRUE(Snapshot()); From 570ccc49f4511d237ef9b9fa4277cfc790f11edb Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 18 Jul 2017 15:30:00 -0700 Subject: [PATCH 327/364] Support text alignment in decorations, other decorations fixes, satistics fixes. Change-Id: I4b9537b040c4d729e895e85487c8e98e1ac7ef78 --- engine/src/flutter/src/font_collection.cc | 9 +- engine/src/flutter/src/paint_record.cc | 12 ++ engine/src/flutter/src/paint_record.h | 11 ++ engine/src/flutter/src/paragraph.cc | 127 +++++++++++++----- engine/src/flutter/src/paragraph.h | 4 +- engine/src/flutter/src/text_style.h | 2 +- .../flutter/tests/txt/paragraph_unittests.cc | 33 ++++- 7 files changed, 153 insertions(+), 45 deletions(-) diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index cf9bdb9281..38825b6217 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -129,11 +129,13 @@ const std::string FontCollection::ProcessFamilyName(const std::string& family) { #ifdef DIRECTORY_FONT_MANAGER_AVAILABLE return family.length() == 0 ? DEFAULT_FAMILY_NAME : family; #else - if (family.length() == 0) { - return *GetFamilyNames().begin(); - } else if (GetFamilyNames().count(family) > 0) { // Ensure family exists. + if (family.length() > 0 && + GetFamilyNames().count(family) > 0) { // Ensure family exists. return family; } else { + if (GetFamilyNames().count(DEFAULT_FAMILY_NAME) > 0) { + return DEFAULT_FAMILY_NAME; + } return *GetFamilyNames().begin(); // First family available. } #endif @@ -167,6 +169,7 @@ FontCollection::GetMinikinFontCollectionForFamily(const std::string& family) { } // Create the minikin font from the skia typeface. + // Divide by 100 because the weights are given as "100", "200", etc. minikin::Font minikin_font( std::make_shared(skia_typeface), minikin::FontStyle{skia_typeface->fontStyle().weight() / 100, diff --git a/engine/src/flutter/src/paint_record.cc b/engine/src/flutter/src/paint_record.cc index 07322ce05a..8f7d5c4a1b 100644 --- a/engine/src/flutter/src/paint_record.cc +++ b/engine/src/flutter/src/paint_record.cc @@ -44,6 +44,8 @@ PaintRecord::PaintRecord(PaintRecord&& other) { text_ = std::move(other.text_); metrics_ = other.metrics_; line_ = other.line_; + width_modifier_ = other.width_modifier_; + letter_spacing_offset_ = other.letter_spacing_offset_; } PaintRecord& PaintRecord::operator=(PaintRecord&& other) { @@ -52,6 +54,8 @@ PaintRecord& PaintRecord::operator=(PaintRecord&& other) { text_ = std::move(other.text_); metrics_ = other.metrics_; line_ = other.line_; + width_modifier_ = other.width_modifier_; + letter_spacing_offset_ = other.letter_spacing_offset_; return *this; } @@ -59,4 +63,12 @@ void PaintRecord::SetOffset(SkPoint pt) { offset_ = pt; } +void PaintRecord::SetWidthModifier(double val) { + width_modifier_ = val; +} + +void PaintRecord::SetLetterSpacingOffset(double val) { + letter_spacing_offset_ = val; +} + } // namespace txt diff --git a/engine/src/flutter/src/paint_record.h b/engine/src/flutter/src/paint_record.h index c34fd9d162..950bfa3284 100644 --- a/engine/src/flutter/src/paint_record.h +++ b/engine/src/flutter/src/paint_record.h @@ -50,6 +50,14 @@ class PaintRecord { void SetOffset(SkPoint pt); + void SetWidthModifier(double val); + + double GetWidthModifier() const { return width_modifier_; } + + void SetLetterSpacingOffset(double val); + + double GetLetterSpacingOffset() const { return letter_spacing_offset_; } + SkTextBlob* text() const { return text_.get(); } const SkPaint::FontMetrics& metrics() const { return metrics_; } @@ -64,6 +72,9 @@ class PaintRecord { sk_sp text_; SkPaint::FontMetrics metrics_; size_t line_; + // Change in width when using a non-left text alignment. + double width_modifier_ = 0.0f; + double letter_spacing_offset_ = 0.0f; FTL_DISALLOW_COPY_AND_ASSIGN(PaintRecord); }; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index ba8f5ac663..6880c43e4c 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -108,6 +108,8 @@ void GetPaint(const TextStyle& style, SkPaint* paint) { } // namespace +static const float kDoubleDecorationSpacing = 3.0f; + Paragraph::Paragraph() = default; Paragraph::~Paragraph() = default; @@ -202,8 +204,9 @@ void Paragraph::Layout(double width, bool force) { double prev_max_descent = 0.0f; double line_width = 0.0f; std::vector x_queue; - double justify_spacing = 0; - double prev_word_pos = 0; + double justify_spacing = 0.0f; + double prev_word_pos = 0.0f; + double prev_char_advance = 0.0f; std::vector buffers; std::vector buffer_sizes; @@ -214,6 +217,7 @@ void Paragraph::Layout(double width, bool force) { for (size_t i = 0; i < x_queue.size(); ++i) { record_index = records_.size() - (x_queue.size() - i); records_[record_index].SetOffset(SkPoint::Make(x_queue[i], y)); + // Adjust the offsets for each of the different alignments. switch (paragraph_style_.text_align) { case TextAlign::left: break; @@ -222,6 +226,9 @@ void Paragraph::Layout(double width, bool force) { records_[record_index].offset().x() + width_ - breaker_.getWidths()[records_[record_index].line()], records_[record_index].offset().y())); + records_[record_index].SetWidthModifier( + records_[record_index].GetWidthModifier() + width_ - + breaker_.getWidths()[records_[record_index].line()]); break; } case TextAlign::center: { @@ -231,9 +238,18 @@ void Paragraph::Layout(double width, bool force) { breaker_.getWidths()[records_[record_index].line()]) / 2, records_[record_index].offset().y())); + + records_[record_index].SetWidthModifier( + records_[record_index].GetWidthModifier() + + (width_ - breaker_.getWidths()[records_[record_index].line()]) / + 2); break; } case TextAlign::justify: { + records_[record_index].SetWidthModifier( + records_[record_index].GetWidthModifier() + + records_[record_index].GetWidthModifier() + width_ - + breaker_.getWidths()[records_[record_index].line()]); break; } } @@ -300,6 +316,7 @@ void Paragraph::Layout(double width, bool force) { buffer_sizes = std::vector(); word_count = 0; double temp_line_spacing = 0; + double prev_letter_spacing_offset = letter_spacing_offset; while (blob_start < glyph_count) { const size_t blob_length = GetBlobLength(layout, blob_start); buffer_sizes.push_back(blob_length); @@ -354,6 +371,8 @@ void Paragraph::Layout(double width, bool force) { whitespace_ended = true; } + prev_char_advance = layout.getCharAdvance(glyph_index); + letter_spacing_offset += run.style.letter_spacing; } blob_start += blob_length; @@ -388,7 +407,7 @@ void Paragraph::Layout(double width, bool force) { line_width += std::abs(records_[records_.size() - 1].text()->bounds().fRight + records_[records_.size() - 1].text()->bounds().fLeft); - + records_.back().SetLetterSpacingOffset(prev_letter_spacing_offset); // Must adjust each line to the largest text in the line, so cannot // directly push the offset property of PaintRecord until line is // finished. @@ -416,17 +435,23 @@ void Paragraph::Layout(double width, bool force) { line_heights_.push_back( (line_heights_.empty() ? 0 : line_heights_.back()) + max_line_spacing + max_descent); + glyph_single_line_position_x.push_back( + glyph_single_line_position_x.back() + prev_char_advance); glyph_single_line_position_x.push_back(FLT_MAX); glyph_position_x_.push_back(glyph_single_line_position_x); prev_max_descent = max_descent; line_widths_.push_back(line_width); postprocess_line(); + records_.back().SetLetterSpacingOffset(0); + + // Reset Variables for next line. max_line_spacing = 0.0f; max_descent = 0.0f; x = 0.0f; letter_spacing_offset = 0.0f; prev_word_pos = 0; + prev_char_advance = 0.0f; line_width = 0.0f; break_index += 1; lines_++; @@ -439,6 +464,7 @@ void Paragraph::Layout(double width, bool force) { layout_start = layout_end; } } + // Handle last line tasks. y += max_line_spacing; height_ = y + max_descent; postprocess_line(); @@ -446,6 +472,8 @@ void Paragraph::Layout(double width, bool force) { line_widths_.push_back(line_width); line_heights_.push_back(FLT_MAX); + glyph_single_line_position_x.push_back(glyph_single_line_position_x.back() + + prev_char_advance); glyph_single_line_position_x.push_back(FLT_MAX); glyph_position_x_.push_back(glyph_single_line_position_x); @@ -453,6 +481,12 @@ void Paragraph::Layout(double width, bool force) { if (paragraph_style_.text_align == TextAlign::justify && buffer_sizes.size() > 0) { JustifyLine(buffers, buffer_sizes, word_count, justify_spacing, -1); + // Remove decoration extra width if the last line. + size_t i = records_.size() - 1; + while (records_[i].line() == lines_ - 1) { + records_[i].SetWidthModifier(0); + --i; + } } line_widths_ = std::vector(breaker_.getWidths(), breaker_.getWidths() + lines_); @@ -536,7 +570,6 @@ double Paragraph::GetMaxIntrinsicWidth() const { } double Paragraph::GetMinIntrinsicWidth() const { - // TODO(garyq): This is a lower bound. Actual value may be slightly higher. return min_intrinsic_width_; } @@ -573,13 +606,13 @@ void Paragraph::SetFontCollection(FontCollection* font_collection) { // paragraph. void Paragraph::Paint(SkCanvas* canvas, double x, double y) { canvas->translate(x, y); - for (const auto& record : records_) { + for (size_t index = 0; index < records_.size(); ++index) { + PaintRecord& record = records_[index]; SkPaint paint; paint.setColor(record.style().color); SkPoint offset = record.offset(); canvas->drawTextBlob(record.text(), offset.x(), offset.y(), paint); - PaintDecorations(canvas, offset.x(), offset.y(), record.style(), - record.metrics(), record.text()); + PaintDecorations(canvas, offset.x(), offset.y(), index); } canvas->translate(-x, -y); } @@ -587,13 +620,13 @@ void Paragraph::Paint(SkCanvas* canvas, double x, double y) { void Paragraph::PaintDecorations(SkCanvas* canvas, double x, double y, - TextStyle style, - SkPaint::FontMetrics metrics, - SkTextBlob* blob) { - if (style.decoration != TextDecoration::kNone) { + size_t record_index) { + PaintRecord& record = records_[record_index]; + if (record.style().decoration != TextDecoration::kNone) { + const SkPaint::FontMetrics& metrics = record.metrics(); SkPaint paint; paint.setStyle(SkPaint::kStroke_Style); - paint.setColor(style.decoration_color); + paint.setColor(record.style().decoration_color); paint.setAntiAlias(true); // This is set to 2 for the double line style @@ -602,12 +635,25 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, // Filled when drawing wavy decorations. std::vector wave_coords; - double width = blob->bounds().fRight + blob->bounds().fLeft; + x += + (record_index != 0 ? records_[record_index - 1].GetLetterSpacingOffset() + : 0); + + double width = 0; + if (record_index == records_.size() - 1 || + record.line() < records_[record_index + 1].line()) { + width = line_widths_[record.line()] - x; + } else { + width = record.text()->bounds().fRight + record.text()->bounds().fLeft; + } + + width += record.GetWidthModifier(); paint.setStrokeWidth(metrics.fUnderlineThickness * - style.decoration_thickness); + record.style().decoration_thickness); - switch (style.decoration_style) { + // Setup the decorations. + switch (record.style().decoration_style) { case TextDecorationStyle::kSolid: { break; } @@ -615,16 +661,28 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, decoration_count = 2; break; } + // Note: the intervals are scaled by the thickness of the line, so it is + // possible to change spacing by changing the decoration_thickness + // property of TextStyle. case TextDecorationStyle::kDotted: { - const SkScalar intervals[] = {3.0f, 5.0f, 3.0f, 5.0f}; + // Divide by 14pt as it is the default size. + const float scale = record.style().font_size / 14.0f; + const SkScalar intervals[] = {1.0f * scale, 2.0f * scale, 1.0f * scale, + 2.0f * scale}; size_t count = sizeof(intervals) / sizeof(intervals[0]); paint.setPathEffect(SkPathEffect::MakeCompose( SkDashPathEffect::Make(intervals, count, 0.0f), SkDiscretePathEffect::Make(0, 0))); break; } + // Note: the intervals are scaled by the thickness of the line, so it is + // possible to change spacing by changing the decoration_thickness + // property of TextStyle. case TextDecorationStyle::kDashed: { - const SkScalar intervals[] = {10.0f, 5.0f, 10.0f, 5.0f}; + // Divide by 14pt as it is the default size. + const float scale = record.style().font_size / 14.0f; + const SkScalar intervals[] = {6.0f * scale, 3.0f * scale, 6.0f * scale, + 3.0f * scale}; size_t count = sizeof(intervals) / sizeof(intervals[0]); paint.setPathEffect(SkPathEffect::MakeCompose( SkDashPathEffect::Make(intervals, count, 0.0f), @@ -636,7 +694,7 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, double x_start = 0; double y_top = -metrics.fUnderlineThickness; double y_bottom = metrics.fUnderlineThickness; - while (x_start + metrics.fUnderlineThickness * 2 < x + width) { + while (x_start + metrics.fUnderlineThickness * 2 < width) { wave_coords.push_back( WaveCoordinates(x_start, wave_count % 2 == 0 ? y_bottom : y_top, x_start + metrics.fUnderlineThickness * 2, @@ -648,12 +706,14 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, } } + // Draw the decorations. // Use a for loop for "kDouble" decoration style for (int i = 0; i < decoration_count; i++) { - double y_offset = i * metrics.fUnderlineThickness * 3.0f; + double y_offset = + i * metrics.fUnderlineThickness * kDoubleDecorationSpacing; // Underline - if (style.decoration & 0x1) { - if (style.decoration_style != TextDecorationStyle::kWavy) + if (record.style().decoration & 0x1) { + if (record.style().decoration_style != TextDecorationStyle::kWavy) canvas->drawLine(x, y + metrics.fUnderlinePosition + y_offset, x + width, y + metrics.fUnderlinePosition + y_offset, paint); @@ -662,8 +722,8 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, metrics.fUnderlineThickness, width); } // Overline - if (style.decoration & 0x2) { - if (style.decoration_style != TextDecorationStyle::kWavy) + if (record.style().decoration & 0x2) { + if (record.style().decoration_style != TextDecorationStyle::kWavy) canvas->drawLine(x, y + metrics.fAscent - y_offset, x + width, y + metrics.fAscent - y_offset, paint); else @@ -671,13 +731,16 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, width); } // Strikethrough - if (style.decoration & 0x4) { - if (style.decoration_style != TextDecorationStyle::kWavy) - canvas->drawLine(x, y - metrics.fXHeight / 2 + y_offset, x + width, - y - metrics.fXHeight / 2 + y_offset, paint); + if (record.style().decoration & 0x4) { + // Make sure the double line is "centered" vertically. + y_offset -= (decoration_count - 1.0) * metrics.fUnderlineThickness * + kDoubleDecorationSpacing / 2.0; + if (record.style().decoration_style != TextDecorationStyle::kWavy) + canvas->drawLine(x, y - metrics.fXHeight / 2.0 + y_offset, x + width, + y - metrics.fXHeight / 2.0 + y_offset, paint); else PaintWavyDecoration(canvas, wave_coords, paint, x, y, - -metrics.fXHeight / 2, width); + -metrics.fXHeight / 2.0, width); } } } @@ -724,8 +787,8 @@ SkRect Paragraph::GetCoordinatesForGlyphPosition(size_t pos) const { size_t remainder = fmin(pos, text_.size()); size_t line = 1; for (line = 1; line < line_heights_.size() - 1; ++line) { - if (remainder > glyph_position_x_[line].size() - 2) { - remainder -= glyph_position_x_[line].size() - 2; + if (remainder > glyph_position_x_[line].size() - 3) { + remainder -= glyph_position_x_[line].size() - 3; } else { break; } @@ -748,11 +811,11 @@ size_t Paragraph::GetGlyphPositionAtCoordinate(double dx, double dy) const { break; } else { offset += prev_count; - prev_count = glyph_position_x_[y_index].size() - 2; + prev_count = glyph_position_x_[y_index].size() - 3; } } prev_count = 0; - for (size_t x_index = 1; x_index < glyph_position_x_[y_index].size(); + for (size_t x_index = 1; x_index < glyph_position_x_[y_index].size() - 2; ++x_index) { if (dx < glyph_position_x_[y_index][x_index]) { break; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 0e16de48ec..178062aed0 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -164,9 +164,7 @@ class Paragraph { void PaintDecorations(SkCanvas* canvas, double x, double y, - TextStyle style, - SkPaint::FontMetrics metrics, - SkTextBlob* blob); + size_t record_index); void PaintWavyDecoration(SkCanvas* canvas, std::vector wave_coords, diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index a6ff1b53ed..c4ef169aaf 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -31,7 +31,7 @@ class TextStyle { public: SkColor color = SK_ColorBLACK; TextDecoration decoration = TextDecoration::kNone; - SkColor decoration_color = SK_ColorTRANSPARENT; + SkColor decoration_color = SK_ColorBLACK; TextDecorationStyle decoration_style = TextDecorationStyle::kSolid; double decoration_thickness = 1.0; FontWeight font_weight = FontWeight::w400; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 719eeb9103..9ddf2a7097 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -150,9 +150,11 @@ TEST_F(RenderTest, RainbowParagraph) { builder.AddText(u16_text3); txt::TextStyle text_style4; - text_style4.font_size = 10; + text_style4.font_size = 14; text_style4.color = SK_ColorBLUE; text_style4.font_family = "Roboto"; + text_style4.decoration = txt::TextDecoration(0x1 | 0x2 | 0x4); + text_style4.decoration_color = SK_ColorBLACK; builder.PushStyle(text_style4); builder.AddText(u16_text4); @@ -166,7 +168,7 @@ TEST_F(RenderTest, RainbowParagraph) { auto paragraph = builder.Build(); paragraph->Layout(GetTestCanvasWidth()); - paragraph->Paint(GetCanvas(), 10.0, 50.0); + paragraph->Paint(GetCanvas(), 0, 0); u16_text1 += u16_text2 + u16_text3 + u16_text4; for (size_t i = 0; i < u16_text1.length(); i++) { @@ -290,7 +292,7 @@ TEST_F(RenderTest, LeftAlignParagraph) { text_style.word_spacing = 5; text_style.color = SK_ColorBLACK; text_style.height = 1; - text_style.decoration = txt::TextDecoration(0x0); + text_style.decoration = txt::TextDecoration(0x1); text_style.decoration_color = SK_ColorBLACK; builder.PushStyle(text_style); @@ -387,7 +389,7 @@ TEST_F(RenderTest, RightAlignParagraph) { text_style.word_spacing = 5; text_style.color = SK_ColorBLACK; text_style.height = 1; - text_style.decoration = txt::TextDecoration(0x0); + text_style.decoration = txt::TextDecoration(0x1); text_style.decoration_color = SK_ColorBLACK; builder.PushStyle(text_style); @@ -491,7 +493,7 @@ TEST_F(RenderTest, CenterAlignParagraph) { text_style.word_spacing = 5; text_style.color = SK_ColorBLACK; text_style.height = 1; - text_style.decoration = txt::TextDecoration(0x0); + text_style.decoration = txt::TextDecoration(0x1); text_style.decoration_color = SK_ColorBLACK; builder.PushStyle(text_style); @@ -597,7 +599,7 @@ TEST_F(RenderTest, JustifyAlignParagraph) { text_style.word_spacing = 5; text_style.color = SK_ColorBLACK; text_style.height = 1; - text_style.decoration = txt::TextDecoration(0x0); + text_style.decoration = txt::TextDecoration(0x1); text_style.decoration_color = SK_ColorBLACK; builder.PushStyle(text_style); @@ -905,6 +907,7 @@ TEST_F(RenderTest, GetGlyphPositionAtCoordinateParagraph) { ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(3, 3), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 1), 1ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 20), 17ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(450, 20), 16ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 90), 35ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(-100000, 90), 18ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(20, -80), 0ull); @@ -1028,6 +1031,24 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[16].right(), 140); EXPECT_FLOAT_EQ(rects[16].bottom(), 292.96875); + paint.setColor(SK_ColorBLUE); + rects = paragraph->GetRectsForRange(19, 21); + for (size_t i = 0; i < rects.size(); ++i) { + GetCanvas()->drawRect(rects[i], paint); + } + ASSERT_EQ(rects.size(), 2ull); + EXPECT_FLOAT_EQ(rects[1].left(), 499); + EXPECT_FLOAT_EQ(rects[1].top(), 0); + EXPECT_FLOAT_EQ(rects[1].right(), 511); + EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); + + paint.setColor(SK_ColorRED); + rects = paragraph->GetRectsForRange(21, 21); + for (size_t i = 0; i < rects.size(); ++i) { + GetCanvas()->drawRect(rects[i], paint); + } + ASSERT_EQ(rects.size(), 1ull); + ASSERT_TRUE(Snapshot()); } From 61418fd845fa4522a6532c3342ad402a3240c501 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 19 Jul 2017 11:54:25 -0700 Subject: [PATCH 328/364] Align GetRectsForRange, GetCoords..., GetGlyphPos..., and GetWordBoundary with Blink results. Change-Id: I9f4e30d1f0a35ca0b2fc2a38492670e58ba0fad7 --- engine/src/flutter/src/paragraph.cc | 17 ++-- engine/src/flutter/src/paragraph.h | 2 +- engine/src/flutter/src/paragraph_builder.cc | 2 - .../flutter/tests/txt/paragraph_unittests.cc | 89 ++++++++++++++++--- 4 files changed, 88 insertions(+), 22 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 6880c43e4c..1ca9d12be9 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -762,13 +762,18 @@ void Paragraph::PaintWavyDecoration(SkCanvas* canvas, std::vector Paragraph::GetRectsForRange(size_t start, size_t end) const { + FTL_DCHECK(end >= start && end >= 0 && start >= 0); std::vector rects; - end = fmin(end, text_.size() - 1); - while (start <= end) { + end = fmax(start, end); + start = fmin(start, end); + if (end == start) + end = start + 1; + end = fmin(end, text_.size()); + while (start < end) { SkIPoint word_bounds = GetWordBoundary(start); - word_bounds.fY = fmin(end + 1, word_bounds.fY); word_bounds.fX = fmax(start, word_bounds.fX); - start = word_bounds.fY; + word_bounds.fY = fmin(end, word_bounds.fY); + start = fmax(word_bounds.fY, start + 1); SkRect left_limits = GetCoordinatesForGlyphPosition(word_bounds.fX + 1); SkRect right_limits = GetCoordinatesForGlyphPosition(word_bounds.fY); if (left_limits.top() < right_limits.top()) { @@ -815,7 +820,7 @@ size_t Paragraph::GetGlyphPositionAtCoordinate(double dx, double dy) const { } } prev_count = 0; - for (size_t x_index = 1; x_index < glyph_position_x_[y_index].size() - 2; + for (size_t x_index = 1; x_index < glyph_position_x_[y_index].size() - 1; ++x_index) { if (dx < glyph_position_x_[y_index][x_index]) { break; @@ -830,7 +835,7 @@ size_t Paragraph::GetGlyphPositionAtCoordinate(double dx, double dy) const { SkIPoint Paragraph::GetWordBoundary(size_t offset) const { // TODO(garyq): Consider punctuation as separate words. return SkIPoint::Make( - minikin::getPrevWordBreakForCache(text_.data(), offset, text_.size()), + minikin::getPrevWordBreakForCache(text_.data(), offset + 1, text_.size()), minikin::getNextWordBreakForCache(text_.data(), offset, text_.size())); } diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 178062aed0..3b0f4683a5 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -68,7 +68,7 @@ class Paragraph { double GetMinIntrinsicWidth() const; // Returns a vector of bounding boxes that enclose all text between start and - // end glyph indexes. + // end glyph indexes, including start and excluding end. std::vector GetRectsForRange(size_t start, size_t end) const; // Returns the index of the glyph that corresponds to the provided coordinate, diff --git a/engine/src/flutter/src/paragraph_builder.cc b/engine/src/flutter/src/paragraph_builder.cc index d307677458..31d18ad95f 100644 --- a/engine/src/flutter/src/paragraph_builder.cc +++ b/engine/src/flutter/src/paragraph_builder.cc @@ -82,8 +82,6 @@ std::unique_ptr ParagraphBuilder::Build() { if (font_collection_ == nullptr) { // Will be deprecated when full compatibility with Flutter Engine is // complete. - FTL_LOG(WARNING) << "No font collection provided. Falling back to default " - "fonts."; font_collection_ = &FontCollection::GetFontCollection(""); } diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 9ddf2a7097..24556675d3 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -349,7 +349,7 @@ TEST_F(RenderTest, LeftAlignParagraph) { ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 1), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 35), 68ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 70), 134ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(2000, 35), 133ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(2000, 35), 134ull); ASSERT_TRUE(Snapshot()); } @@ -906,14 +906,14 @@ TEST_F(RenderTest, GetGlyphPositionAtCoordinateParagraph) { ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(0, 0), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(3, 3), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 1), 1ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 20), 17ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 20), 18ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(450, 20), 16ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 90), 35ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 90), 36ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(-100000, 90), 18ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(20, -80), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 90), 18ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 180), 36ull); - ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 180), 53ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 180), 54ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(70, 180), 38ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 270), 54ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 90), 19ull); @@ -971,12 +971,22 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[0].right(), 28); EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); - paint.setColor(SK_ColorBLUE); - rects = paragraph->GetRectsForRange(2, 7); + rects = paragraph->GetRectsForRange(0, 1); for (size_t i = 0; i < rects.size(); ++i) { GetCanvas()->drawRect(rects[i], paint); } - ASSERT_EQ(rects.size(), 3ull); + EXPECT_EQ(rects.size(), 1ull); + EXPECT_FLOAT_EQ(rects[0].left(), 0); + EXPECT_FLOAT_EQ(rects[0].top(), 0); + EXPECT_FLOAT_EQ(rects[0].right(), 28); + EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); + + paint.setColor(SK_ColorBLUE); + rects = paragraph->GetRectsForRange(2, 8); + for (size_t i = 0; i < rects.size(); ++i) { + GetCanvas()->drawRect(rects[i], paint); + } + EXPECT_EQ(rects.size(), 3ull); EXPECT_FLOAT_EQ(rects[0].left(), 56); EXPECT_FLOAT_EQ(rects[0].top(), 0); EXPECT_FLOAT_EQ(rects[0].right(), 151); @@ -993,11 +1003,11 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[2].bottom(), 58.59375); paint.setColor(SK_ColorGREEN); - rects = paragraph->GetRectsForRange(8, 20); + rects = paragraph->GetRectsForRange(8, 21); for (size_t i = 0; i < rects.size(); ++i) { GetCanvas()->drawRect(rects[i], paint); } - ASSERT_EQ(rects.size(), 3ull); + EXPECT_EQ(rects.size(), 3ull); EXPECT_FLOAT_EQ(rects[0].left(), 175); EXPECT_FLOAT_EQ(rects[0].top(), 0); EXPECT_FLOAT_EQ(rects[0].right(), 347); @@ -1018,7 +1028,7 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { for (size_t i = 0; i < rects.size(); ++i) { GetCanvas()->drawRect(rects[i], paint); } - ASSERT_EQ(rects.size(), 17ull); + EXPECT_EQ(rects.size(), 17ull); EXPECT_FLOAT_EQ(rects[0].left(), 208); EXPECT_FLOAT_EQ(rects[0].top(), 58.59375); EXPECT_FLOAT_EQ(rects[0].right(), 292); @@ -1032,11 +1042,11 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[16].bottom(), 292.96875); paint.setColor(SK_ColorBLUE); - rects = paragraph->GetRectsForRange(19, 21); + rects = paragraph->GetRectsForRange(19, 22); for (size_t i = 0; i < rects.size(); ++i) { GetCanvas()->drawRect(rects[i], paint); } - ASSERT_EQ(rects.size(), 2ull); + EXPECT_EQ(rects.size(), 2ull); EXPECT_FLOAT_EQ(rects[1].left(), 499); EXPECT_FLOAT_EQ(rects[1].top(), 0); EXPECT_FLOAT_EQ(rects[1].right(), 511); @@ -1047,11 +1057,64 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { for (size_t i = 0; i < rects.size(); ++i) { GetCanvas()->drawRect(rects[i], paint); } - ASSERT_EQ(rects.size(), 1ull); + EXPECT_EQ(rects.size(), 1ull); ASSERT_TRUE(Snapshot()); } +TEST_F(RenderTest, GetWordBoundaryParagraph) { + const char* text = + "12345 67890 12345 67890 12345 67890 12345 67890 12345 67890 12345 " + "67890 12345"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.max_lines = 10; + paragraph_style.text_align = TextAlign::left; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.font_size = 50; + text_style.letter_spacing = 1; + text_style.word_spacing = 5; + text_style.color = SK_ColorBLACK; + text_style.height = 1.5; + builder.PushStyle(text_style); + + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(550); + + paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_TRUE(Snapshot()); + + EXPECT_EQ(paragraph->GetWordBoundary(0), SkIPoint::Make(0, 5)); + EXPECT_EQ(paragraph->GetWordBoundary(1), SkIPoint::Make(0, 5)); + EXPECT_EQ(paragraph->GetWordBoundary(2), SkIPoint::Make(0, 5)); + EXPECT_EQ(paragraph->GetWordBoundary(3), SkIPoint::Make(0, 5)); + EXPECT_EQ(paragraph->GetWordBoundary(4), SkIPoint::Make(0, 5)); + + EXPECT_EQ(paragraph->GetWordBoundary(5), SkIPoint::Make(5, 6)); + EXPECT_EQ(paragraph->GetWordBoundary(6), SkIPoint::Make(6, 7)); + + EXPECT_EQ(paragraph->GetWordBoundary(7), SkIPoint::Make(7, 12)); + EXPECT_EQ(paragraph->GetWordBoundary(8), SkIPoint::Make(7, 12)); + EXPECT_EQ(paragraph->GetWordBoundary(9), SkIPoint::Make(7, 12)); + EXPECT_EQ(paragraph->GetWordBoundary(10), SkIPoint::Make(7, 12)); + EXPECT_EQ(paragraph->GetWordBoundary(11), SkIPoint::Make(7, 12)); + + EXPECT_EQ(paragraph->GetWordBoundary(12), SkIPoint::Make(12, 13)); + + EXPECT_EQ(paragraph->GetWordBoundary(13), SkIPoint::Make(13, 18)); +} + TEST_F(RenderTest, SpacingParagraph) { const char* text = "H"; auto icu_text = icu::UnicodeString::fromUTF8(text); From 40252675372df45241a0d80c03939631afec269b Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 19 Jul 2017 17:25:11 -0700 Subject: [PATCH 329/364] Use SkCanvasAutoRestore. Change-Id: I35a7c65303e17132af86f552a657d226d9576850 --- .../src/flutter/benchmarks/paragraph_benchmarks.cc | 14 +++++++++----- engine/src/flutter/src/paragraph.cc | 3 +-- engine/src/flutter/src/paragraph.h | 2 ++ 3 files changed, 12 insertions(+), 7 deletions(-) diff --git a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc index e92715ff1a..ca547764b7 100644 --- a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc @@ -141,7 +141,7 @@ static void BM_ParagraphJustifyLayout(benchmark::State& state) { BENCHMARK(BM_ParagraphJustifyLayout); static void BM_ParagraphManyStylesLayout(benchmark::State& state) { - const char* text = "A short sentence. "; + const char* text = "-"; auto icu_text = icu::UnicodeString::fromUTF8(text); std::u16string u16_text(icu_text.getBuffer(), icu_text.getBuffer() + icu_text.length()); @@ -189,7 +189,7 @@ static void BM_ParagraphTextBigO(benchmark::State& state) { BENCHMARK(BM_ParagraphTextBigO) ->RangeMultiplier(10) ->Range(1 << 6, 1 << 14) - ->Complexity(benchmark::oN); + ->Complexity(benchmark::oNSquared); static void BM_ParagraphStylesBigO(benchmark::State& state) { const char* text = "A short sentence. "; @@ -217,7 +217,7 @@ static void BM_ParagraphStylesBigO(benchmark::State& state) { BENCHMARK(BM_ParagraphStylesBigO) ->RangeMultiplier(20) ->Range(1 << 4, 1 << 12) - ->Complexity(benchmark::oN); + ->Complexity(benchmark::oNSquared); // ----------------------------------------------------------------------------- // @@ -228,7 +228,7 @@ BENCHMARK(BM_ParagraphStylesBigO) static void BM_ParagraphMinikinDoLayout(benchmark::State& state) { std::vector text; - for (uint16_t i = 0; i < 100; ++i) { + for (uint16_t i = 0; i < state.range(0); ++i) { text.push_back(i); } minikin::FontStyle font; @@ -250,8 +250,12 @@ static void BM_ParagraphMinikinDoLayout(benchmark::State& state) { layout.doLayout(text.data(), 0, 50, text.size(), 0, font, paint, collection); } + state.SetComplexityN(state.range(0)); } -BENCHMARK(BM_ParagraphMinikinDoLayout); +BENCHMARK(BM_ParagraphMinikinDoLayout) + ->RangeMultiplier(10) + ->Range(1 << 7, 1 << 14) + ->Complexity(benchmark::oN); static void BM_ParagraphSkTextBlobAlloc(benchmark::State& state) { SkPaint paint; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 1ca9d12be9..d7cd417c5f 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -292,7 +292,6 @@ void Paragraph::Layout(double width, bool force) { letter_spacing_offset -= run.style.letter_spacing; size_t layout_start = run.start; - // Layout until the end of the run or too many lines. while (layout_start < run.end && lines_ < paragraph_style_.max_lines) { const size_t next_break = (break_index > breaks_count - 1) @@ -605,6 +604,7 @@ void Paragraph::SetFontCollection(FontCollection* font_collection) { // The x,y coordinates will be the very top left corner of the rendered // paragraph. void Paragraph::Paint(SkCanvas* canvas, double x, double y) { + SkAutoCanvasRestore canvas_restore(canvas, true); canvas->translate(x, y); for (size_t index = 0; index < records_.size(); ++index) { PaintRecord& record = records_[index]; @@ -614,7 +614,6 @@ void Paragraph::Paint(SkCanvas* canvas, double x, double y) { canvas->drawTextBlob(record.text(), offset.x(), offset.y(), paint); PaintDecorations(canvas, offset.x(), offset.y(), index); } - canvas->translate(-x, -y); } void Paragraph::PaintDecorations(SkCanvas* canvas, diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 3b0f4683a5..bc2281ca21 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -45,6 +45,8 @@ class Paragraph { void Layout(double width, bool force = false); + // Paints the Laid out text onto the supplied SkCanvas at (x, y) offset from + // the origin. Only valid after Layout() is called. void Paint(SkCanvas* canvas, double x, double y); const ParagraphStyle& GetParagraphStyle() const; From 85bd669eac867b32d774f3ed7ba305e48776b803 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 20 Jul 2017 12:19:57 -0700 Subject: [PATCH 330/364] Benchmark rework to better reflect real usage and slight performance improvements. Change-Id: I3979c725ff9058fc208626ffb5fce95c2e03ac19 --- .../benchmarks/paragraph_benchmarks.cc | 114 +++++++++--------- engine/src/flutter/src/paragraph.cc | 8 +- engine/src/flutter/src/paragraph.h | 5 + 3 files changed, 70 insertions(+), 57 deletions(-) diff --git a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc index ca547764b7..4286ac9019 100644 --- a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc @@ -44,14 +44,14 @@ static void BM_ParagraphShortLayout(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + auto paragraph = builder.Build(); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style, &font_collection); - - builder.PushStyle(text_style); - builder.AddText(u16_text); - builder.Pop(); - auto paragraph = builder.Build(); - + paragraph->SetDirty(); paragraph->Layout(300, true); } } @@ -85,14 +85,14 @@ static void BM_ParagraphLongLayout(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + auto paragraph = builder.Build(); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style, &font_collection); - - builder.PushStyle(text_style); - builder.AddText(u16_text); - builder.Pop(); - auto paragraph = builder.Build(); - + paragraph->SetDirty(); paragraph->Layout(300, true); } } @@ -127,14 +127,14 @@ static void BM_ParagraphJustifyLayout(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + auto paragraph = builder.Build(); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style, &font_collection); - - builder.PushStyle(text_style); - builder.AddText(u16_text); - builder.Pop(); - auto paragraph = builder.Build(); - + paragraph->SetDirty(); paragraph->Layout(300, true); } } @@ -151,48 +151,51 @@ static void BM_ParagraphManyStylesLayout(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + for (int i = 0; i < 1000; ++i) { + builder.PushStyle(text_style); + builder.AddText(u16_text); + } + auto paragraph = builder.Build(); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style, &font_collection); - for (int i = 0; i < 1000; ++i) { - builder.PushStyle(text_style); - builder.AddText(u16_text); - } - auto paragraph = builder.Build(); + paragraph->SetDirty(); paragraph->Layout(300, true); } } BENCHMARK(BM_ParagraphManyStylesLayout); static void BM_ParagraphTextBigO(benchmark::State& state) { - std::string text(state.range(0), '-'); - auto icu_text = icu::UnicodeString::fromUTF8(text); - std::u16string u16_text(icu_text.getBuffer(), - icu_text.getBuffer() + icu_text.length()); + std::vector text; + for (uint16_t i = 0; i < state.range(0); ++i) { + text.push_back(i % 5 == 0 ? ' ' : i); + } + std::u16string u16_text(text.data(), text.data() + text.size()); txt::ParagraphStyle paragraph_style; txt::TextStyle text_style; text_style.color = SK_ColorBLACK; auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + builder.PushStyle(text_style); + builder.AddText(u16_text); + builder.Pop(); + auto paragraph = builder.Build(); while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style, &font_collection); - - builder.PushStyle(text_style); - builder.AddText(u16_text); - builder.Pop(); - auto paragraph = builder.Build(); - + paragraph->SetDirty(); paragraph->Layout(300, true); } state.SetComplexityN(state.range(0)); } BENCHMARK(BM_ParagraphTextBigO) - ->RangeMultiplier(10) + ->RangeMultiplier(4) ->Range(1 << 6, 1 << 14) - ->Complexity(benchmark::oNSquared); + ->Complexity(benchmark::oN); static void BM_ParagraphStylesBigO(benchmark::State& state) { - const char* text = "A short sentence. "; + const char* text = "vry shrt "; auto icu_text = icu::UnicodeString::fromUTF8(text); std::u16string u16_text(icu_text.getBuffer(), icu_text.getBuffer() + icu_text.length()); @@ -202,22 +205,23 @@ static void BM_ParagraphStylesBigO(benchmark::State& state) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); - while (state.KeepRunning()) { - txt::ParagraphBuilder builder(paragraph_style, &font_collection); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); - for (int i = 0; i < state.range(0); ++i) { - builder.PushStyle(text_style); - builder.AddText(u16_text); - } - auto paragraph = builder.Build(); + for (int i = 0; i < state.range(0); ++i) { + builder.PushStyle(text_style); + builder.AddText(u16_text); + } + auto paragraph = builder.Build(); + while (state.KeepRunning()) { + paragraph->SetDirty(); paragraph->Layout(300, true); } state.SetComplexityN(state.range(0)); } BENCHMARK(BM_ParagraphStylesBigO) - ->RangeMultiplier(20) - ->Range(1 << 4, 1 << 12) - ->Complexity(benchmark::oNSquared); + ->RangeMultiplier(4) + ->Range(1 << 3, 1 << 12) + ->Complexity(benchmark::oN); // ----------------------------------------------------------------------------- // @@ -228,8 +232,8 @@ BENCHMARK(BM_ParagraphStylesBigO) static void BM_ParagraphMinikinDoLayout(benchmark::State& state) { std::vector text; - for (uint16_t i = 0; i < state.range(0); ++i) { - text.push_back(i); + for (uint16_t i = 0; i < state.range(0) * 3; ++i) { + text.push_back(i % 5 == 0 ? ' ' : i); } minikin::FontStyle font; txt::TextStyle text_style; @@ -247,13 +251,13 @@ static void BM_ParagraphMinikinDoLayout(benchmark::State& state) { while (state.KeepRunning()) { minikin::Layout layout; - layout.doLayout(text.data(), 0, 50, text.size(), 0, font, paint, + layout.doLayout(text.data(), 0, state.range(0), text.size(), 0, font, paint, collection); } state.SetComplexityN(state.range(0)); } BENCHMARK(BM_ParagraphMinikinDoLayout) - ->RangeMultiplier(10) + ->RangeMultiplier(4) ->Range(1 << 7, 1 << 14) ->Complexity(benchmark::oN); diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index d7cd417c5f..4cb609530c 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -299,12 +299,12 @@ void Paragraph::Layout(double width, bool force) { : breaks[break_index]; const size_t layout_end = std::min(run.end, next_break); - int bidiFlags = 0; + bool bidiFlags = paragraph_style_.rtl; layout.doLayout(text_.data(), layout_start, layout_end - layout_start, text_.size(), bidiFlags, font, minikin_paint, font_collection_->GetMinikinFontCollectionForFamily( run.style.font_family)); - FillWhitespaceSet(run.start, run.end, + FillWhitespaceSet(layout_start, layout_end, minikin::getHbFontLocked(layout.getFont(0))); const size_t glyph_count = layout.nGlyphs(); @@ -848,4 +848,8 @@ bool Paragraph::DidExceedMaxLines() const { return false; } +void Paragraph::SetDirty(bool dirty) { + needs_layout_ = dirty; +} + } // namespace txt diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index bc2281ca21..e148f01992 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -88,6 +88,11 @@ class Paragraph { bool DidExceedMaxLines() const; + // Sets the needs_layout_ to dirty. When Layout() is called, a new Layout will + // be performed when this is set to true. Can also be used to prevent a new + // Layout from being calculated by setting to false. + void SetDirty(bool dirty = true); + private: friend class ParagraphBuilder; FRIEND_TEST(RenderTest, SimpleParagraph); From 264a66f3f35a354f22de4ceb2026cb1723794da8 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 20 Jul 2017 13:10:35 -0700 Subject: [PATCH 331/364] Do not pass full buffer to minikin for big performance improvements. Change-Id: I411d6168e45204774d4776aa241feeaf19dad818 --- engine/src/flutter/benchmarks/paragraph_benchmarks.cc | 8 ++++++-- engine/src/flutter/src/paragraph.cc | 4 ++-- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc index 4286ac9019..29589f99e9 100644 --- a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc @@ -270,9 +270,13 @@ static void BM_ParagraphSkTextBlobAlloc(benchmark::State& state) { while (state.KeepRunning()) { SkTextBlobBuilder builder; - builder.allocRunPos(paint, 100); + builder.allocRunPos(paint, state.range(0)); } + state.SetComplexityN(state.range(0)); } -BENCHMARK(BM_ParagraphSkTextBlobAlloc); +BENCHMARK(BM_ParagraphSkTextBlobAlloc) + ->RangeMultiplier(4) + ->Range(1 << 7, 1 << 14) + ->Complexity(benchmark::oN); } // namespace txt diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 4cb609530c..58885cc361 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -300,8 +300,8 @@ void Paragraph::Layout(double width, bool force) { const size_t layout_end = std::min(run.end, next_break); bool bidiFlags = paragraph_style_.rtl; - layout.doLayout(text_.data(), layout_start, layout_end - layout_start, - text_.size(), bidiFlags, font, minikin_paint, + layout.doLayout(text_.data() + layout_start, 0, layout_end - layout_start, + layout_end - layout_start, bidiFlags, font, minikin_paint, font_collection_->GetMinikinFontCollectionForFamily( run.style.font_family)); FillWhitespaceSet(layout_start, layout_end, From 1fca345a7776e989c56d036165017536ae16d84d Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 20 Jul 2017 16:50:18 -0700 Subject: [PATCH 332/364] Benchmark improvements and additions. Document n^2 benchmark findings. Change-Id: I697acad51082151e6614abffe6bebbbe73f31a75 --- .../benchmarks/paragraph_benchmarks.cc | 44 +++++++++++++++++-- engine/src/flutter/src/paragraph.cc | 10 +++++ engine/src/flutter/src/paragraph.h | 8 ++++ 3 files changed, 59 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc index 29589f99e9..e497168b08 100644 --- a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc @@ -232,7 +232,7 @@ BENCHMARK(BM_ParagraphStylesBigO) static void BM_ParagraphMinikinDoLayout(benchmark::State& state) { std::vector text; - for (uint16_t i = 0; i < state.range(0) * 3; ++i) { + for (uint16_t i = 0; i < 16000 * 2; ++i) { text.push_back(i % 5 == 0 ? ' ' : i); } minikin::FontStyle font; @@ -251,8 +251,8 @@ static void BM_ParagraphMinikinDoLayout(benchmark::State& state) { while (state.KeepRunning()) { minikin::Layout layout; - layout.doLayout(text.data(), 0, state.range(0), text.size(), 0, font, paint, - collection); + layout.doLayout(text.data(), 0, state.range(0), state.range(0), 0, font, + paint, collection); } state.SetComplexityN(state.range(0)); } @@ -261,6 +261,44 @@ BENCHMARK(BM_ParagraphMinikinDoLayout) ->Range(1 << 7, 1 << 14) ->Complexity(benchmark::oN); +static void BM_ParagraphMinikinAddStyleRun(benchmark::State& state) { + std::vector text; + for (uint16_t i = 0; i < 16000 * 2; ++i) { + text.push_back(i % 5 == 0 ? ' ' : i); + } + minikin::FontStyle font; + txt::TextStyle text_style; + text_style.font_family = "Roboto"; + minikin::MinikinPaint paint; + + font = minikin::FontStyle(4, false); + paint.size = text_style.font_size; + paint.letterSpacing = text_style.letter_spacing; + paint.wordSpacing = text_style.word_spacing; + + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + + minikin::LineBreaker breaker; + breaker.setLocale(icu::Locale(), nullptr); + breaker.resize(text.size()); + memcpy(breaker.buffer(), text.data(), text.size() * sizeof(text[0])); + breaker.setText(); + + while (state.KeepRunning()) { + for (int i = 0; i < 20; ++i) { + breaker.addStyleRun( + &paint, font_collection.GetMinikinFontCollectionForFamily("Roboto"), + font, state.range(0) / 20 * i, state.range(0) / 20 * (i + 1), false, + 0); + } + } + state.SetComplexityN(state.range(0)); +} +BENCHMARK(BM_ParagraphMinikinAddStyleRun) + ->RangeMultiplier(4) + ->Range(1 << 7, 1 << 14) + ->Complexity(benchmark::oN); + static void BM_ParagraphSkTextBlobAlloc(benchmark::State& state) { SkPaint paint; paint.setAntiAlias(true); diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 58885cc361..e300e58b00 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -127,6 +127,11 @@ void Paragraph::SetText(std::vector text, StyledRuns runs) { breaker_.setText(); } +// NOTE: Minikin LineBreaker addStyleRun() has an O(N^2) (according to +// benchmarks) time complexity where N is the total number of characters. +// However, this is not significant for reasonably sized paragraphs. It is +// currently recommended to break up very long paragraphs (10k+ characters) to +// ensure speedy layout. void Paragraph::AddRunsToLineBreaker( std::unordered_map>& collection_map) { @@ -300,6 +305,11 @@ void Paragraph::Layout(double width, bool force) { const size_t layout_end = std::min(run.end, next_break); bool bidiFlags = paragraph_style_.rtl; + // NOTE: Minikin Layout doLayout() has an O(N^2) (according to + // benchmarks) time complexity where N is the total number of characters. + // However, this is not significant for reasonably sized paragraphs. It is + // currently recommended to break up very long paragraphs (10k+ + // characters) to ensure speedy layout. layout.doLayout(text_.data() + layout_start, 0, layout_end - layout_start, layout_end - layout_start, bidiFlags, font, minikin_paint, font_collection_->GetMinikinFontCollectionForFamily( diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index e148f01992..74d5a7ba40 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -43,6 +43,14 @@ class Paragraph { ~Paragraph(); + // NOTE: Minikin Layout doLayout() and LineBreaker addStyleRun() has an + // O(N^2) (according to benchmarks) time complexity where N is the total + // number of characters. However, this is not significant for reasonably sized + // paragraphs. It is currently recommended to break up very long paragraphs + // (10k+ characters) to ensure speedy layout. + // + // Layout calculates the positioning of all the glyphs. Must call this method + // before Painting and getting any statistics from this class. void Layout(double width, bool force = false); // Paints the Laid out text onto the supplied SkCanvas at (x, y) offset from From 09d3505e3b2592e6e20ab74ac3513270161cac58 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 21 Jul 2017 12:08:17 -0700 Subject: [PATCH 333/364] Switch to using minikin letter spacing. Change-Id: I0e0908eea3f79bf0a6a5eb9842956d4077bb9dd3 --- .../src/flutter/include/minikin/LineBreaker.h | 1 - .../src/flutter/libs/minikin/LineBreaker.cpp | 6 +-- engine/src/flutter/src/paint_record.cc | 6 --- engine/src/flutter/src/paint_record.h | 5 -- engine/src/flutter/src/paragraph.cc | 47 +++---------------- engine/src/flutter/src/paragraph.h | 3 -- .../flutter/tests/txt/paragraph_unittests.cc | 2 - 7 files changed, 8 insertions(+), 62 deletions(-) diff --git a/engine/src/flutter/include/minikin/LineBreaker.h b/engine/src/flutter/include/minikin/LineBreaker.h index 1a6b1888db..32374e1b12 100644 --- a/engine/src/flutter/include/minikin/LineBreaker.h +++ b/engine/src/flutter/include/minikin/LineBreaker.h @@ -230,7 +230,6 @@ class LineBreaker { icu::Locale mLocale; std::vectormTextBuf; std::vectormCharWidths; - std::vectormCharSpacing; Hyphenator* mHyphenator; std::vector mHyphBuf; diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 62dbd830bb..661a8fc30e 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -138,10 +138,6 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const std::shared_ptrsize = style.font_size; - paint->letterSpacing = style.letter_spacing; + // Divide by font size so letter spacing is pixels, not proportional to font + // size. + paint->letterSpacing = style.letter_spacing / style.font_size; paint->wordSpacing = style.word_spacing; + paint->scaleX = 1; + // Prevent spacing rounding in Minikin. + paint->paintFlags = 0xFF; } void GetPaint(const TextStyle& style, SkPaint* paint) { @@ -203,7 +208,6 @@ void Paragraph::Layout(double width, bool force) { SkScalar x = 0.0f; SkScalar y = 0.0f; size_t break_index = 0; - double letter_spacing_offset = 0.0f; double max_line_spacing = 0.0f; double max_descent = 0.0f; double prev_max_descent = 0.0f; @@ -293,9 +297,6 @@ void Paragraph::Layout(double width, bool force) { GetFontAndMinikinPaint(run.style, &font, &minikin_paint); GetPaint(run.style, &paint); - // Subtract inital offset to avoid big gap at start of run. - letter_spacing_offset -= run.style.letter_spacing; - size_t layout_start = run.start; // Layout until the end of the run or too many lines. while (layout_start < run.end && lines_ < paragraph_style_.max_lines) { @@ -325,7 +326,6 @@ void Paragraph::Layout(double width, bool force) { buffer_sizes = std::vector(); word_count = 0; double temp_line_spacing = 0; - double prev_letter_spacing_offset = letter_spacing_offset; while (blob_start < glyph_count) { const size_t blob_length = GetBlobLength(layout, blob_start); buffer_sizes.push_back(blob_length); @@ -344,8 +344,6 @@ void Paragraph::Layout(double width, bool force) { buffers.push_back( &builder.allocRunPos(paint, blob_length - trailing_length)); - letter_spacing_offset += run.style.letter_spacing; - // TODO(garyq): Implement RTL. // Each Glyph/Letter. bool whitespace_ended = true; @@ -356,8 +354,7 @@ void Paragraph::Layout(double width, bool force) { const size_t pos_index = 2 * blob_index; - buffers.back()->pos[pos_index] = - layout.getX(glyph_index) + letter_spacing_offset; + buffers.back()->pos[pos_index] = layout.getX(glyph_index); glyph_single_line_position_x.push_back( buffers.back()->pos[pos_index]); buffers.back()->pos[pos_index + 1] = layout.getY(glyph_index); @@ -369,11 +366,6 @@ void Paragraph::Layout(double width, bool force) { // whitespaces. if (whitespace_ended) { ++word_count; - word_widths_.push_back(buffers.back()->pos[pos_index] + - layout.getCharAdvance(glyph_index) - - prev_word_pos); - prev_word_pos = buffers.back()->pos[pos_index] + - layout.getCharAdvance(glyph_index); } whitespace_ended = false; } else { @@ -381,25 +373,8 @@ void Paragraph::Layout(double width, bool force) { } prev_char_advance = layout.getCharAdvance(glyph_index); - - letter_spacing_offset += run.style.letter_spacing; } blob_start += blob_length; - - // Add on the last word if the blob break was not on whitespace. - if (whitespace_ended) { - word_widths_.push_back( - layout.getX(blob_start - 1) + letter_spacing_offset - - run.style.letter_spacing + layout.getCharAdvance(blob_start - 1) - - prev_word_pos); - } - - // Subtract letter offset to avoid big gap at end of run. This my be - // removed depending on the specifications for letter spacing. - // letter_spacing_offset -= run.style.letter_spacing; - - max_intrinsic_width_ += - layout.getX(blob_start - 1) + letter_spacing_offset; } // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the @@ -416,7 +391,6 @@ void Paragraph::Layout(double width, bool force) { line_width += std::abs(records_[records_.size() - 1].text()->bounds().fRight + records_[records_.size() - 1].text()->bounds().fLeft); - records_.back().SetLetterSpacingOffset(prev_letter_spacing_offset); // Must adjust each line to the largest text in the line, so cannot // directly push the offset property of PaintRecord until line is // finished. @@ -452,13 +426,10 @@ void Paragraph::Layout(double width, bool force) { line_widths_.push_back(line_width); postprocess_line(); - records_.back().SetLetterSpacingOffset(0); - // Reset Variables for next line. max_line_spacing = 0.0f; max_descent = 0.0f; x = 0.0f; - letter_spacing_offset = 0.0f; prev_word_pos = 0; prev_char_advance = 0.0f; line_width = 0.0f; @@ -644,10 +615,6 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, // Filled when drawing wavy decorations. std::vector wave_coords; - x += - (record_index != 0 ? records_[record_index - 1].GetLetterSpacingOffset() - : 0); - double width = 0; if (record_index == records_.size() - 1 || record.line() < records_[record_index + 1].line()) { diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 74d5a7ba40..773cc6bb9a 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -138,9 +138,6 @@ class Paragraph { size_t lines_ = 0; double max_intrinsic_width_ = 0; double min_intrinsic_width_ = 0; - // TODO(garyq): Instead of using whitespace to delimit "words", use the - // results of minikin breaker. - std::vector word_widths_; double alphabetic_baseline_ = FLT_MAX; double ideographic_baseline_ = FLT_MAX; bool needs_layout_ = true; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 24556675d3..8067118035 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -1201,8 +1201,6 @@ TEST_F(RenderTest, SpacingParagraph) { ASSERT_EQ(paragraph->records_[5].style().word_spacing, 0); ASSERT_EQ(paragraph->records_[6].style().word_spacing, 20); - - } } // namespace txt From 34dfd6c602ee7bdd2e1b3d26c4e5dec1de2d26af Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 21 Jul 2017 16:11:54 -0700 Subject: [PATCH 334/364] Add support for multiple break strategies to better support edge case situations. Change-Id: I61fc4d95a57b34f59073e99ad834c9a0d7ec7c76 --- engine/src/flutter/src/paragraph.cc | 8 ++++ engine/src/flutter/src/paragraph.h | 1 + engine/src/flutter/src/paragraph_style.h | 7 ++++ engine/src/flutter/src/styled_runs.h | 1 + .../flutter/tests/txt/paragraph_unittests.cc | 42 +++++++++++++++++++ 5 files changed, 59 insertions(+) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index e93645935b..65d6f4060e 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -177,8 +177,16 @@ void Paragraph::Layout(double width, bool force) { collection_map; breaker_.setLineWidths(0.0f, 0, width_); + // TODO(garyq): Get hyphenator working. Hyphenator should be created with + // a pattern binary dataset. Should be something along these lines: + // + // minikin::Hyphenator* hyph = + // minikin::Hyphenator::loadBinary(); + // breaker_.setLocale(icu::Locale::getRoot(), &hyph); + // AddRunsToLineBreaker(collection_map); breaker_.setJustified(paragraph_style_.text_align == TextAlign::justify); + breaker_.setStrategy(paragraph_style_.break_strategy); size_t breaks_count = breaker_.computeBreaks(); const int* breaks = breaker_.getBreaks(); diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 773cc6bb9a..b3bc991447 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -117,6 +117,7 @@ class Paragraph { FRIEND_TEST(RenderTest, ChineseParagraph); FRIEND_TEST(RenderTest, DISABLED_ArabicParagraph); FRIEND_TEST(RenderTest, SpacingParagraph); + FRIEND_TEST(RenderTest, LongWordParagraph); std::vector text_; StyledRuns runs_; diff --git a/engine/src/flutter/src/paragraph_style.h b/engine/src/flutter/src/paragraph_style.h index b6ae31e060..38f1a2278a 100644 --- a/engine/src/flutter/src/paragraph_style.h +++ b/engine/src/flutter/src/paragraph_style.h @@ -20,6 +20,7 @@ #include #include +#include "lib/txt/include/minikin/LineBreaker.h" #include "lib/txt/src/font_style.h" #include "lib/txt/src/font_weight.h" #include "lib/txt/src/text_align.h" @@ -36,6 +37,12 @@ class ParagraphStyle { size_t max_lines = UINT_MAX; double line_height = 1.0; std::string ellipsis = "..."; + // Default strategy is kBreakStrategy_Greedy. Sometimes, + // kBreakStrategy_HighQuality will produce more desireable layouts (eg, very + // long words are more likely to be reasonably placed). + // kBreakStrategy_Balanced will balance between the two. + minikin::BreakStrategy break_strategy = + minikin::BreakStrategy::kBreakStrategy_Greedy; // TODO(garyq): Implement right to left. // Right to left (Arabic, Hebrew, etc). bool rtl = false; diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index d88306d704..4159bc01c0 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -70,6 +70,7 @@ class StyledRuns { FRIEND_TEST(RenderTest, ItalicsParagraph); FRIEND_TEST(RenderTest, ChineseParagraph); FRIEND_TEST(RenderTest, DISABLED_ArabicParagraph); + FRIEND_TEST(RenderTest, LongWordParagraph); struct IndexedRun { size_t style_index = 0; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 8067118035..998843b17d 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -1200,7 +1200,49 @@ TEST_F(RenderTest, SpacingParagraph) { ASSERT_EQ(paragraph->records_[4].style().word_spacing, 20); ASSERT_EQ(paragraph->records_[5].style().word_spacing, 0); ASSERT_EQ(paragraph->records_[6].style().word_spacing, 20); +} +TEST_F(RenderTest, LongWordParagraph) { + const char* text = + "A " + "veryverylongwordtoseewherethiswillwraporifitwillatallandifitdoesthenthat" + "wouldbeagoodthingbecausethebreakingisworking."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.break_strategy = minikin::kBreakStrategy_HighQuality; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.font_size = 30; + text_style.letter_spacing = 0; + text_style.word_spacing = 0; + text_style.color = SK_ColorBLACK; + text_style.height = 1; + builder.PushStyle(text_style); + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth() / 2); + + paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_TRUE(Snapshot()); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_EQ(paragraph->GetLineCount(), 4); + ASSERT_TRUE(Snapshot()); } } // namespace txt From 1ccc959d00448ac9ed7fa9d7b5f80ad3cb791a3c Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 24 Jul 2017 15:06:37 -0700 Subject: [PATCH 335/364] Add unittests for kerning. Change-Id: I494bbd3993cde76cabc9dfc042dcee4b0fb6af4d --- engine/src/flutter/src/paragraph.h | 1 + engine/src/flutter/src/styled_runs.h | 1 + .../flutter/tests/txt/paragraph_unittests.cc | 43 ++++++++++++++++++- 3 files changed, 44 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index b3bc991447..df90a916a3 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -118,6 +118,7 @@ class Paragraph { FRIEND_TEST(RenderTest, DISABLED_ArabicParagraph); FRIEND_TEST(RenderTest, SpacingParagraph); FRIEND_TEST(RenderTest, LongWordParagraph); + FRIEND_TEST(RenderTest, KernParagraph); std::vector text_; StyledRuns runs_; diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index 4159bc01c0..3fd52ad78c 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -71,6 +71,7 @@ class StyledRuns { FRIEND_TEST(RenderTest, ChineseParagraph); FRIEND_TEST(RenderTest, DISABLED_ArabicParagraph); FRIEND_TEST(RenderTest, LongWordParagraph); + FRIEND_TEST(RenderTest, KernParagraph); struct IndexedRun { size_t style_index = 0; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 998843b17d..174c86ac6c 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -1217,7 +1217,8 @@ TEST_F(RenderTest, LongWordParagraph) { txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; - text_style.font_size = 30; + text_style.font_family = "Roboto"; + text_style.font_size = 31; text_style.letter_spacing = 0; text_style.word_spacing = 0; text_style.color = SK_ColorBLACK; @@ -1245,4 +1246,44 @@ TEST_F(RenderTest, LongWordParagraph) { ASSERT_TRUE(Snapshot()); } +TEST_F(RenderTest, KernParagraph) { + txt::ParagraphStyle paragraph_style; + paragraph_style.break_strategy = minikin::kBreakStrategy_HighQuality; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.font_family = "Roboto"; + text_style.font_size = 100; + text_style.letter_spacing = 0; + text_style.word_spacing = 0; + text_style.color = SK_ColorBLACK; + text_style.height = 1; + builder.PushStyle(text_style); + builder.AddText("AVAVAWAH A0 V0 VA To The Lo"); + builder.PushStyle(text_style); + builder.AddText("A"); + builder.PushStyle(text_style); + builder.AddText("V"); + builder.PushStyle(text_style); + builder.AddText(" Dialog"); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth()); + + paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_TRUE(Snapshot()); + + EXPECT_DOUBLE_EQ(paragraph->records_[0].offset().x(), 0); + EXPECT_DOUBLE_EQ(paragraph->records_[1].offset().x(), 0); + EXPECT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 441.16796875f); + EXPECT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 506.16796875); + EXPECT_DOUBLE_EQ(paragraph->records_[4].offset().x(), 570.16796875); + + ASSERT_TRUE(Snapshot()); +} + } // namespace txt From 20914d0e91cf024e4927c2c60aa31ae0e385a48e Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 24 Jul 2017 16:36:25 -0700 Subject: [PATCH 336/364] Fix GetCoordinatesForGlyphPosition() and adjust other methods to match. Tests to back it up. Change-Id: I2ea9065f043c752bebc1a16e1e0c2c2fec59d87c --- engine/src/flutter/src/paragraph.cc | 5 +- .../flutter/tests/txt/paragraph_unittests.cc | 48 ++++++++++++++++++- 2 files changed, 50 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 65d6f4060e..7b53ba2af4 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -758,8 +758,8 @@ std::vector Paragraph::GetRectsForRange(size_t start, word_bounds.fX = fmax(start, word_bounds.fX); word_bounds.fY = fmin(end, word_bounds.fY); start = fmax(word_bounds.fY, start + 1); - SkRect left_limits = GetCoordinatesForGlyphPosition(word_bounds.fX + 1); - SkRect right_limits = GetCoordinatesForGlyphPosition(word_bounds.fY); + SkRect left_limits = GetCoordinatesForGlyphPosition(word_bounds.fX); + SkRect right_limits = GetCoordinatesForGlyphPosition(word_bounds.fY - 1); if (left_limits.top() < right_limits.top()) { rects.push_back(SkRect::MakeLTRB( 0, right_limits.top(), right_limits.right(), right_limits.bottom())); @@ -774,6 +774,7 @@ std::vector Paragraph::GetRectsForRange(size_t start, SkRect Paragraph::GetCoordinatesForGlyphPosition(size_t pos) const { size_t remainder = fmin(pos, text_.size()); + remainder++; size_t line = 1; for (line = 1; line < line_heights_.size() - 1; ++line) { if (remainder > glyph_position_x_[line].size() - 3) { diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 174c86ac6c..98d855f3b9 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -1093,26 +1093,72 @@ TEST_F(RenderTest, GetWordBoundaryParagraph) { paragraph->Paint(GetCanvas(), 0, 0); - ASSERT_TRUE(Snapshot()); + + SkPaint paint; + paint.setStyle(SkPaint::kStroke_Style); + paint.setAntiAlias(true); + paint.setStrokeWidth(1); + paint.setColor(SK_ColorRED); + + SkRect rect = paragraph->GetCoordinatesForGlyphPosition(0); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); EXPECT_EQ(paragraph->GetWordBoundary(0), SkIPoint::Make(0, 5)); EXPECT_EQ(paragraph->GetWordBoundary(1), SkIPoint::Make(0, 5)); EXPECT_EQ(paragraph->GetWordBoundary(2), SkIPoint::Make(0, 5)); EXPECT_EQ(paragraph->GetWordBoundary(3), SkIPoint::Make(0, 5)); EXPECT_EQ(paragraph->GetWordBoundary(4), SkIPoint::Make(0, 5)); + rect = paragraph->GetCoordinatesForGlyphPosition(5); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); EXPECT_EQ(paragraph->GetWordBoundary(5), SkIPoint::Make(5, 6)); + rect = paragraph->GetCoordinatesForGlyphPosition(6); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); + EXPECT_EQ(paragraph->GetWordBoundary(6), SkIPoint::Make(6, 7)); + rect = paragraph->GetCoordinatesForGlyphPosition(7); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); EXPECT_EQ(paragraph->GetWordBoundary(7), SkIPoint::Make(7, 12)); EXPECT_EQ(paragraph->GetWordBoundary(8), SkIPoint::Make(7, 12)); EXPECT_EQ(paragraph->GetWordBoundary(9), SkIPoint::Make(7, 12)); EXPECT_EQ(paragraph->GetWordBoundary(10), SkIPoint::Make(7, 12)); EXPECT_EQ(paragraph->GetWordBoundary(11), SkIPoint::Make(7, 12)); + rect = paragraph->GetCoordinatesForGlyphPosition(12); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); EXPECT_EQ(paragraph->GetWordBoundary(12), SkIPoint::Make(12, 13)); + rect = paragraph->GetCoordinatesForGlyphPosition(13); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); EXPECT_EQ(paragraph->GetWordBoundary(13), SkIPoint::Make(13, 18)); + rect = paragraph->GetCoordinatesForGlyphPosition(18); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); + + rect = paragraph->GetCoordinatesForGlyphPosition(19); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); + + rect = paragraph->GetCoordinatesForGlyphPosition(24); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); + + rect = paragraph->GetCoordinatesForGlyphPosition(25); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); + + rect = paragraph->GetCoordinatesForGlyphPosition(30); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); + + EXPECT_EQ(paragraph->GetWordBoundary(30), SkIPoint::Make(30, 31)); + rect = paragraph->GetCoordinatesForGlyphPosition(31); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); + + rect = paragraph->GetCoordinatesForGlyphPosition(icu_text.length() - 5); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); + + EXPECT_EQ(paragraph->GetWordBoundary(icu_text.length() - 1), SkIPoint::Make(icu_text.length() - 5, icu_text.length())); + rect = paragraph->GetCoordinatesForGlyphPosition(icu_text.length()); + GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); + + ASSERT_TRUE(Snapshot()); } TEST_F(RenderTest, SpacingParagraph) { From 13af3dc89cf3040097a0f15da2c40721df308797 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 24 Jul 2017 18:24:04 -0700 Subject: [PATCH 337/364] Add basecase checking to prevent segfault in GetWordBoundary(). Change-Id: I5ca93c0c15ef5dd3dbc6a5937f8b21338acf884d --- engine/src/flutter/src/paragraph.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 7b53ba2af4..bf499b4aea 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -819,6 +819,8 @@ size_t Paragraph::GetGlyphPositionAtCoordinate(double dx, double dy) const { SkIPoint Paragraph::GetWordBoundary(size_t offset) const { // TODO(garyq): Consider punctuation as separate words. + if (text_.size() == 0) + return SkIPoint::Make(0, 0); return SkIPoint::Make( minikin::getPrevWordBreakForCache(text_.data(), offset + 1, text_.size()), minikin::getNextWordBreakForCache(text_.data(), offset, text_.size())); From a537b6cea6c59bbb7068ebdd6744a0201d499f60 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 25 Jul 2017 12:31:36 -0700 Subject: [PATCH 338/364] Fix coord to glyph position function and glyph position tracking. Change-Id: Ib031e9c46b5622a5ff830b602c1fa2fe037ea7f5 --- engine/src/flutter/src/paragraph.cc | 21 ++++++++++++------- .../flutter/tests/txt/paragraph_unittests.cc | 10 ++++++--- 2 files changed, 21 insertions(+), 10 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index bf499b4aea..10c5df6e51 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -181,8 +181,8 @@ void Paragraph::Layout(double width, bool force) { // a pattern binary dataset. Should be something along these lines: // // minikin::Hyphenator* hyph = - // minikin::Hyphenator::loadBinary(); - // breaker_.setLocale(icu::Locale::getRoot(), &hyph); + // minikin::Hyphenator::loadBinary(); + // breaker_.setLocale(icu::Locale::getRoot(), &hyph); // AddRunsToLineBreaker(collection_map); breaker_.setJustified(paragraph_style_.text_align == TextAlign::justify); @@ -201,17 +201,20 @@ void Paragraph::Layout(double width, bool force) { SkTextBlobBuilder builder; // Reset member variables so Layout still works when called more than once - max_intrinsic_width_ = 0.0f; lines_ = 0; + width_ = 0.0f; line_widths_ = std::vector(); line_heights_ = std::vector(); + line_heights_.push_back(0); + records_ = std::vector(); + height_ = 0.0f; // Set padding elements to have a minimum point. - line_heights_.push_back(0); glyph_position_x_ = std::vector>(); glyph_position_x_.push_back(std::vector()); std::vector glyph_single_line_position_x; glyph_single_line_position_x.push_back(0); + double previous_run_x_position = 0.0f; SkScalar x = 0.0f; SkScalar y = 0.0f; @@ -334,6 +337,7 @@ void Paragraph::Layout(double width, bool force) { buffer_sizes = std::vector(); word_count = 0; double temp_line_spacing = 0; + double current_x_position = previous_run_x_position; while (blob_start < glyph_count) { const size_t blob_length = GetBlobLength(layout, blob_start); buffer_sizes.push_back(blob_length); @@ -362,9 +366,10 @@ void Paragraph::Layout(double width, bool force) { const size_t pos_index = 2 * blob_index; - buffers.back()->pos[pos_index] = layout.getX(glyph_index); - glyph_single_line_position_x.push_back( - buffers.back()->pos[pos_index]); + current_x_position = layout.getX(glyph_index); + buffers.back()->pos[pos_index] = current_x_position; + glyph_single_line_position_x.push_back(current_x_position + + previous_run_x_position); buffers.back()->pos[pos_index + 1] = layout.getY(glyph_index); // Check if the current Glyph is a whitespace and handle multiple @@ -383,6 +388,7 @@ void Paragraph::Layout(double width, bool force) { prev_char_advance = layout.getCharAdvance(glyph_index); } blob_start += blob_length; + previous_run_x_position += current_x_position + prev_char_advance; } // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the @@ -440,6 +446,7 @@ void Paragraph::Layout(double width, bool force) { x = 0.0f; prev_word_pos = 0; prev_char_advance = 0.0f; + previous_run_x_position = 0.0f; line_width = 0.0f; break_index += 1; lines_++; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 98d855f3b9..615619cd5e 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -906,6 +906,10 @@ TEST_F(RenderTest, GetGlyphPositionAtCoordinateParagraph) { ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(0, 0), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(3, 3), 0ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 1), 1ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(300, 2), 10ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(301, 2.2), 10ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(302, 2.6), 10ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(301, 2.1), 10ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 20), 18ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(450, 20), 16ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(100000, 90), 36ull); @@ -1093,7 +1097,6 @@ TEST_F(RenderTest, GetWordBoundaryParagraph) { paragraph->Paint(GetCanvas(), 0, 0); - SkPaint paint; paint.setStyle(SkPaint::kStroke_Style); paint.setAntiAlias(true); @@ -1154,7 +1157,8 @@ TEST_F(RenderTest, GetWordBoundaryParagraph) { rect = paragraph->GetCoordinatesForGlyphPosition(icu_text.length() - 5); GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); - EXPECT_EQ(paragraph->GetWordBoundary(icu_text.length() - 1), SkIPoint::Make(icu_text.length() - 5, icu_text.length())); + EXPECT_EQ(paragraph->GetWordBoundary(icu_text.length() - 1), + SkIPoint::Make(icu_text.length() - 5, icu_text.length())); rect = paragraph->GetCoordinatesForGlyphPosition(icu_text.length()); GetCanvas()->drawLine(rect.fLeft, rect.fTop, rect.fLeft, rect.fBottom, paint); @@ -1320,7 +1324,7 @@ TEST_F(RenderTest, KernParagraph) { paragraph->Layout(GetTestCanvasWidth()); paragraph->Paint(GetCanvas(), 0, 0); - + ASSERT_TRUE(Snapshot()); EXPECT_DOUBLE_EQ(paragraph->records_[0].offset().x(), 0); From 1946e649c726424c72bbfb373cfd1a58f3531383 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 25 Jul 2017 15:40:09 -0700 Subject: [PATCH 339/364] Add middle-of-glyph bounding for coord-to-index system and fix alignment bug. Change-Id: I1f772886949131468407bdc12f1dc6e0ba03b68e --- engine/src/flutter/src/paragraph.cc | 15 ++++++++++++--- engine/src/flutter/src/paragraph.h | 8 +++++++- 2 files changed, 19 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 10c5df6e51..f20ad92c2c 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -202,7 +202,6 @@ void Paragraph::Layout(double width, bool force) { // Reset member variables so Layout still works when called more than once lines_ = 0; - width_ = 0.0f; line_widths_ = std::vector(); line_heights_ = std::vector(); line_heights_.push_back(0); @@ -798,7 +797,10 @@ SkRect Paragraph::GetCoordinatesForGlyphPosition(size_t pos) const { line_heights_[line]); } -size_t Paragraph::GetGlyphPositionAtCoordinate(double dx, double dy) const { +size_t Paragraph::GetGlyphPositionAtCoordinate( + double dx, + double dy, + bool using_glyph_center_as_boundary) const { size_t offset = 0; size_t y_index = 1; size_t prev_count = 0; @@ -814,7 +816,14 @@ size_t Paragraph::GetGlyphPositionAtCoordinate(double dx, double dy) const { prev_count = 0; for (size_t x_index = 1; x_index < glyph_position_x_[y_index].size() - 1; ++x_index) { - if (dx < glyph_position_x_[y_index][x_index]) { + // TODO(garyq): Resolve edge case where second to last glyph position is + // skipped/unreachable. + if (dx < glyph_position_x_[y_index][x_index] - + (using_glyph_center_as_boundary + ? (glyph_position_x_[y_index][x_index + 1] - + glyph_position_x_[y_index][x_index]) / + 2.0f + : 0)) { break; } else { offset += prev_count; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index df90a916a3..b6d8dd6643 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -83,7 +83,13 @@ class Paragraph { // Returns the index of the glyph that corresponds to the provided coordinate, // with the top left corner as the origin, and +y direction as down. - size_t GetGlyphPositionAtCoordinate(double dx, double dy) const; + // + // When using_glyph_center_as_boundary == true, coords to the + direction of + // the center x-position of the glyph will be considered as the next glyph. + size_t GetGlyphPositionAtCoordinate( + double dx, + double dy, + bool using_glyph_center_as_boundary = false) const; // Returns a bounding box that encloses the glyph at the index pos. SkRect GetCoordinatesForGlyphPosition(size_t pos) const; From e2c999263835c76e39e2cfc9a1a680e1ec178eed Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 25 Jul 2017 17:30:56 -0700 Subject: [PATCH 340/364] API comments and reorder vars. Change-Id: I9f73047bc5ad453b05083f019623f553d13bbba4 --- engine/src/flutter/src/font_collection.cc | 10 ++-- engine/src/flutter/src/font_collection.h | 16 ++++--- engine/src/flutter/src/paint_record.h | 12 +++-- engine/src/flutter/src/paragraph.cc | 2 + engine/src/flutter/src/paragraph.h | 53 ++++++++++++++++++++-- engine/src/flutter/src/paragraph_builder.h | 4 ++ 6 files changed, 78 insertions(+), 19 deletions(-) diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index 38825b6217..ae59ddf639 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -31,14 +31,15 @@ #include "third_party/skia/include/ports/SkFontMgr_directory.h" namespace txt { - -// Will be deprecated when full compatibility with Flutter Engine is complete. +// TODO(garyq): Will be deprecated when full compatibility with Flutter Engine +// is complete. FontCollection& FontCollection::GetFontCollection(std::string dir) { std::vector dirs = {dir}; return GetFontCollection(std::move(dirs)); } -// Will be deprecated when full compatibility with Flutter Engine is complete. +// TODO(garyq): Will be deprecated when full compatibility with Flutter Engine +// is complete. FontCollection& FontCollection::GetFontCollection( std::vector dirs) { static FontCollection* collection = nullptr; @@ -47,7 +48,8 @@ FontCollection& FontCollection::GetFontCollection( return *collection; } -// Will be deprecated when full compatibility with Flutter Engine is complete. +// TODO(garyq): Will be deprecated when full compatibility with Flutter Engine +// is complete. FontCollection& FontCollection::GetDefaultFontCollection() { return GetFontCollection(""); } diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index ac09bc7eca..fb3a3be0bd 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -37,7 +37,8 @@ namespace txt { // FontCollection holds a vector of Skia Font Managers and handles font -// fallback. +// fallback. If no additional font directories are provided, then only the +// default font directory will be available. class FontCollection { public: enum CacheMethod { @@ -45,19 +46,22 @@ class FontCollection { kLRU, // Least Recently Used. kUnlimited, }; - // Will be deprecated when full compatibility with Flutter Engine is complete. + // TODO(garyq): Will be deprecated when full compatibility with Flutter Engine + // is complete. static FontCollection& GetDefaultFontCollection(); - // Will be deprecated when full compatibility with Flutter Engine is complete. + // TODO(garyq): Will be deprecated when full compatibility with Flutter Engine + // is complete.. static FontCollection& GetFontCollection(std::string dir = ""); - // Will be deprecated when full compatibility with Flutter Engine is complete. + // TODO(garyq): Will be deprecated when full compatibility with Flutter Engine + // is complete. static FontCollection& GetFontCollection(std::vector dirs); // Provides a pointer to the minikin FontCollection for the given font family. // If the famly is not in any font manager, this will return a nullptr. Once a - // font is loaded, it is cached and future calls will be very efficient (until - // the font is flushed). + // font is loaded, it is cached and future calls will be very efficient + // (until/if the font is flushed). std::shared_ptr GetMinikinFontCollectionForFamily( const std::string& family); diff --git a/engine/src/flutter/src/paint_record.h b/engine/src/flutter/src/paint_record.h index faf133abe5..e6b2d02874 100644 --- a/engine/src/flutter/src/paint_record.h +++ b/engine/src/flutter/src/paint_record.h @@ -25,6 +25,9 @@ namespace txt { +// PaintRecord holds the layout data after Paragraph::Layout() is called. This +// stores all nessecary offsets, blobs, metrics, and more for Skia to draw the +// text. class PaintRecord { public: PaintRecord() = delete; @@ -50,10 +53,6 @@ class PaintRecord { void SetOffset(SkPoint pt); - void SetWidthModifier(double val); - - double GetWidthModifier() const { return width_modifier_; } - SkTextBlob* text() const { return text_.get(); } const SkPaint::FontMetrics& metrics() const { return metrics_; } @@ -62,10 +61,15 @@ class PaintRecord { size_t line() const { return line_; } + size_t GetRunWidth() const { return run_width_; } + private: TextStyle style_; + // offset_ is the overall offset of the origin of the SkTextBlob. SkPoint offset_; + // SkTextBlob stores the glyphs and coordinates to draw them. sk_sp text_; + // FontMetrics stores the measurements of the font used. SkPaint::FontMetrics metrics_; size_t line_; // Change in width when using a non-left text alignment. diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index f20ad92c2c..daaadaac93 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -213,6 +213,8 @@ void Paragraph::Layout(double width, bool force) { glyph_position_x_.push_back(std::vector()); std::vector glyph_single_line_position_x; glyph_single_line_position_x.push_back(0); + // Track the x of the previous run to maintain accurate xposition when + // multiple SkTextBlobs make up a single line. double previous_run_x_position = 0.0f; SkScalar x = 0.0f; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index b6d8dd6643..e6bde8dd57 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -37,8 +37,17 @@ namespace txt { using GlyphID = uint32_t; +// Paragraph provides Layout, metrics, and painting capabilites for text. Once a +// Paragraph is constructed with ParagraphBuilder::Build(), an example basic +// workflow can be this: +// +// std::unique_ptr paragraph = paragraph_builder.Build(); +// paragraph->Layout(); +// paragraph->Paint(, , ); class Paragraph { public: + // Constructor. I is highly recommended to construct a paragrph with a + // ParagraphBuilder. Paragraph(); ~Paragraph(); @@ -57,24 +66,38 @@ class Paragraph { // the origin. Only valid after Layout() is called. void Paint(SkCanvas* canvas, double x, double y); + // Getter for paragraph_style_. const ParagraphStyle& GetParagraphStyle() const; + // Returns the number of characters/unicode characters. AKA text_.size() size_t TextSize() const; + // Returns the height of the laid out paragraph. NOTE this is not a tight + // bounding height of the glyphs, as some glyphs do not reach as low as they + // can. double GetHeight() const; // Returns the actual max width of the longest line after Layout(). double GetLayoutWidth() const; - // Returns the width provided in the Layout() method. + // Returns the width provided in the Layout() method. This is the maximum + // width any line in the laid out paragraph can occupy. We expect that + // GetMaxWidth() >= GetLayoutWidth(). double GetMaxWidth() const; + // Distance from top of paragraph to the Alphabetic baseline of the first + // line. double GetAlphabeticBaseline() const; + // Distance from top of paragraph to the Ideographic baseline of the first + // line. double GetIdeographicBaseline() const; + // Returns the total width covered by the paragraph without linebreaking. double GetMaxIntrinsicWidth() const; + // Currently, calculated similarly to as GetLayoutWidth(), however this is not + // nessecarily 100% correct in all cases. double GetMinIntrinsicWidth() const; // Returns a vector of bounding boxes that enclose all text between start and @@ -98,8 +121,13 @@ class Paragraph { // index offset. SkIPoint GetWordBoundary(size_t offset) const; + // Returns the number of lines the paragraph takes up. If the text exceeds the + // amount width and maxlines provides, Layout() truncates the extra text from + // the layout and this will return the max lines allowed. int GetLineCount() const; + // Checks if the layout extends past the maximum lines and had to be + // truncated. bool DidExceedMaxLines() const; // Sets the needs_layout_ to dirty. When Layout() is called, a new Layout will @@ -126,28 +154,37 @@ class Paragraph { FRIEND_TEST(RenderTest, LongWordParagraph); FRIEND_TEST(RenderTest, KernParagraph); + // Starting data to layout. std::vector text_; StyledRuns runs_; + ParagraphStyle paragraph_style_; + FontCollection* font_collection_; + minikin::LineBreaker breaker_; + + // Stores the result of Layout(). std::vector records_; - std::vector line_widths_; // TODO(garyq): Can we access this info without redundantly storing it here? + std::vector line_widths_; std::vector line_heights_; + // Holds the laid out x positions of each glyph, as well as padding to make + // math on it simpler. std::vector> glyph_position_x_; // Set of glyph IDs that correspond to whitespace. std::set whitespace_set_; - ParagraphStyle paragraph_style_; - FontCollection* font_collection_; - SkScalar height_ = 0.0f; + // The max width of the paragraph as provided in the most recent Layout() + // call. double width_ = 0.0f; + SkScalar height_ = 0.0f; size_t lines_ = 0; double max_intrinsic_width_ = 0; double min_intrinsic_width_ = 0; double alphabetic_baseline_ = FLT_MAX; double ideographic_baseline_ = FLT_MAX; + bool needs_layout_ = true; struct WaveCoordinates { @@ -166,6 +203,9 @@ class Paragraph { void SetFontCollection(FontCollection* font_collection); + // Pass the runs to breaker_. + // NOTE: This is O(N^2) due to minikin breaking being O(N^2) where N = sum of + // all text added using this method. This is insignificant with normal usage. void AddRunsToLineBreaker( std::unordered_map>& collection_map); @@ -175,17 +215,20 @@ class Paragraph { // justifying. void FillWhitespaceSet(size_t start, size_t end, hb_font_t* hb_font); + // Calculates and amends the layout for one line to be justified. void JustifyLine(std::vector& buffers, std::vector& buffer_sizes, int word_count, double& justify_spacing, double multiplier = 1); + // Creates and draws the decorations onto the canvas. void PaintDecorations(SkCanvas* canvas, double x, double y, size_t record_index); + // Calculates wavy decorations and Draws them onto the canvas. void PaintWavyDecoration(SkCanvas* canvas, std::vector wave_coords, SkPaint paint, diff --git a/engine/src/flutter/src/paragraph_builder.h b/engine/src/flutter/src/paragraph_builder.h index 4fbd07b187..7055894e8c 100644 --- a/engine/src/flutter/src/paragraph_builder.h +++ b/engine/src/flutter/src/paragraph_builder.h @@ -56,10 +56,14 @@ class ParagraphBuilder { // builder.AddText(" Back to normal again."); void Pop(); + // Adds text to the builder. Forms the proper runs to use the upper-most style + // on the style_stack_; void AddText(const std::u16string& text); + // Converts to u16string before adding. void AddText(const std::string& text); + // Converts to u16string before adding. void AddText(const char* text); void SetParagraphStyle(const ParagraphStyle& style); From d447e4de83efff1ad7e328ce7d54df5b6c11166a Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 26 Jul 2017 11:34:14 -0700 Subject: [PATCH 341/364] Make decorations respect proper SkPaint::FontMetrics positioning and thickness and improve overall decoration visual quality. Change-Id: Icb5e64a80fbe8a04106125c2dc41e60459b944c0 --- engine/src/flutter/src/paragraph.cc | 63 +++++++++++++------ .../flutter/tests/txt/paragraph_unittests.cc | 3 +- 2 files changed, 44 insertions(+), 22 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index daaadaac93..2d44f5138b 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -641,8 +641,14 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, width += record.GetWidthModifier(); - paint.setStrokeWidth(metrics.fUnderlineThickness * - record.style().decoration_thickness); + paint.setStrokeWidth( + (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: + kUnderlineThicknessIsValid_Flag)) + ? metrics.fUnderlineThickness + // Backup value if the fUnderlineThickness metric is not available: + // Divide by 14pt as it is the default size. + : record.style().font_size / 14.0f * + record.style().decoration_thickness); // Setup the decorations. switch (record.style().decoration_style) { @@ -659,8 +665,8 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, case TextDecorationStyle::kDotted: { // Divide by 14pt as it is the default size. const float scale = record.style().font_size / 14.0f; - const SkScalar intervals[] = {1.0f * scale, 2.0f * scale, 1.0f * scale, - 2.0f * scale}; + const SkScalar intervals[] = {1.0f * scale, 1.5f * scale, 1.0f * scale, + 1.5f * scale}; size_t count = sizeof(intervals) / sizeof(intervals[0]); paint.setPathEffect(SkPathEffect::MakeCompose( SkDashPathEffect::Make(intervals, count, 0.0f), @@ -673,8 +679,8 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, case TextDecorationStyle::kDashed: { // Divide by 14pt as it is the default size. const float scale = record.style().font_size / 14.0f; - const SkScalar intervals[] = {6.0f * scale, 3.0f * scale, 6.0f * scale, - 3.0f * scale}; + const SkScalar intervals[] = {4.0f * scale, 2.0f * scale, 4.0f * scale, + 2.0f * scale}; size_t count = sizeof(intervals) / sizeof(intervals[0]); paint.setPathEffect(SkPathEffect::MakeCompose( SkDashPathEffect::Make(intervals, count, 0.0f), @@ -703,36 +709,53 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, for (int i = 0; i < decoration_count; i++) { double y_offset = i * metrics.fUnderlineThickness * kDoubleDecorationSpacing; + double y_offset_original = y_offset; // Underline if (record.style().decoration & 0x1) { + y_offset += + (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: + kUnderlinePositionIsValid_Flag)) + ? metrics.fUnderlinePosition + : metrics.fUnderlineThickness; if (record.style().decoration_style != TextDecorationStyle::kWavy) - canvas->drawLine(x, y + metrics.fUnderlinePosition + y_offset, - x + width, y + metrics.fUnderlinePosition + y_offset, - paint); + canvas->drawLine(x, y + y_offset, x + width, y + y_offset, paint); else - PaintWavyDecoration(canvas, wave_coords, paint, x, y, - metrics.fUnderlineThickness, width); + PaintWavyDecoration(canvas, wave_coords, paint, x, y, y_offset, + width); + y_offset = y_offset_original; } // Overline if (record.style().decoration & 0x2) { + y_offset -= metrics.fAscent; if (record.style().decoration_style != TextDecorationStyle::kWavy) - canvas->drawLine(x, y + metrics.fAscent - y_offset, x + width, - y + metrics.fAscent - y_offset, paint); + canvas->drawLine(x, y - y_offset, x + width, y - y_offset, paint); else - PaintWavyDecoration(canvas, wave_coords, paint, x, y, metrics.fAscent, + PaintWavyDecoration(canvas, wave_coords, paint, x, y, -y_offset, width); + y_offset = y_offset_original; } // Strikethrough if (record.style().decoration & 0x4) { + if (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: + kStrikeoutThicknessIsValid_Flag)) + paint.setStrokeWidth(metrics.fStrikeoutThickness * + record.style().decoration_thickness); // Make sure the double line is "centered" vertically. - y_offset -= (decoration_count - 1.0) * metrics.fUnderlineThickness * - kDoubleDecorationSpacing / 2.0; + y_offset += (decoration_count - 1.0) * metrics.fUnderlineThickness * + kDoubleDecorationSpacing / -2.0; + y_offset += + (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: + kStrikeoutThicknessIsValid_Flag)) + ? metrics.fStrikeoutPosition + // Backup value if the strikeoutposition metric is not + // available: + : metrics.fXHeight / -2.0; if (record.style().decoration_style != TextDecorationStyle::kWavy) - canvas->drawLine(x, y - metrics.fXHeight / 2.0 + y_offset, x + width, - y - metrics.fXHeight / 2.0 + y_offset, paint); + canvas->drawLine(x, y + y_offset, x + width, y + y_offset, paint); else - PaintWavyDecoration(canvas, wave_coords, paint, x, y, - -metrics.fXHeight / 2.0, width); + PaintWavyDecoration(canvas, wave_coords, paint, x, y, y_offset, + width); + y_offset = y_offset_original; } } } diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 615619cd5e..98762eace3 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -700,6 +700,7 @@ TEST_F(RenderTest, DecorationsParagraph) { paragraph->Paint(GetCanvas(), 0, 0); + ASSERT_TRUE(Snapshot()); ASSERT_EQ(paragraph->runs_.size(), 5ull); ASSERT_EQ(paragraph->records_.size(), 6ull); @@ -727,8 +728,6 @@ TEST_F(RenderTest, DecorationsParagraph) { ASSERT_EQ(paragraph->records_[3].style().decoration_color, SK_ColorBLACK); ASSERT_EQ(paragraph->records_[4].style().decoration_color, SK_ColorBLACK); ASSERT_EQ(paragraph->records_[5].style().decoration_color, SK_ColorRED); - - ASSERT_TRUE(Snapshot()); } TEST_F(RenderTest, ItalicsParagraph) { From 476860da54679697ad9f637a360f6adeb0f75046 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 26 Jul 2017 15:18:50 -0700 Subject: [PATCH 342/364] Default decoration color to text color. Change-Id: I74f1ffc6372ccf952232e9dcbba66029c31a7088 --- engine/src/flutter/src/paragraph.cc | 6 +++++- engine/src/flutter/src/text_style.h | 4 +++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 2d44f5138b..76c4693f28 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -622,7 +622,11 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, const SkPaint::FontMetrics& metrics = record.metrics(); SkPaint paint; paint.setStyle(SkPaint::kStroke_Style); - paint.setColor(record.style().decoration_color); + if (record.style().decoration_color == SK_ColorTRANSPARENT) { + paint.setColor(record.style().color); + } else { + paint.setColor(record.style().decoration_color); + } paint.setAntiAlias(true); // This is set to 2 for the double line style diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index c4ef169aaf..9e0c88da85 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -31,7 +31,9 @@ class TextStyle { public: SkColor color = SK_ColorBLACK; TextDecoration decoration = TextDecoration::kNone; - SkColor decoration_color = SK_ColorBLACK; + // Does not make sense to draw a transparent object, so we use it as a default + // value to indicate no decoration color was set. + SkColor decoration_color = SK_ColorTRANSPARENT; TextDecorationStyle decoration_style = TextDecorationStyle::kSolid; double decoration_thickness = 1.0; FontWeight font_weight = FontWeight::w400; From 8a5babb292699dd412ad2facc5341f6a59b94688 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 26 Jul 2017 16:17:10 -0700 Subject: [PATCH 343/364] Custom width tracking for accurate and consistent underlines and decorations. Change-Id: I8ea703321cefc5cc402bf6d4247cd45eb3e085b2 --- .../benchmarks/paint_record_benchmarks.cc | 2 +- engine/src/flutter/src/paint_record.cc | 23 +++++++------ engine/src/flutter/src/paint_record.h | 9 ++--- engine/src/flutter/src/paragraph.cc | 34 ++++++------------- 4 files changed, 30 insertions(+), 38 deletions(-) diff --git a/engine/src/flutter/benchmarks/paint_record_benchmarks.cc b/engine/src/flutter/benchmarks/paint_record_benchmarks.cc index f5f7143d72..835ee5d571 100644 --- a/engine/src/flutter/benchmarks/paint_record_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paint_record_benchmarks.cc @@ -38,7 +38,7 @@ static void BM_PaintRecordInit(benchmark::State& state) { auto text_blob = builder.make(); while (state.KeepRunning()) { - PaintRecord PaintRecord(style, text_blob, SkPaint::FontMetrics(), 0); + PaintRecord PaintRecord(style, text_blob, SkPaint::FontMetrics(), 0, 0); } } BENCHMARK(BM_PaintRecordInit); diff --git a/engine/src/flutter/src/paint_record.cc b/engine/src/flutter/src/paint_record.cc index eb29efe015..bcb396e6c3 100644 --- a/engine/src/flutter/src/paint_record.cc +++ b/engine/src/flutter/src/paint_record.cc @@ -25,18 +25,25 @@ PaintRecord::PaintRecord(TextStyle style, SkPoint offset, sk_sp text, SkPaint::FontMetrics metrics, - int line) + int line, + double run_width) : style_(style), offset_(offset), text_(std::move(text)), metrics_(metrics), - line_(line) {} + line_(line), + run_width_(run_width) {} PaintRecord::PaintRecord(TextStyle style, sk_sp text, SkPaint::FontMetrics metrics, - int line) - : style_(style), text_(std::move(text)), metrics_(metrics), line_(line) {} + int line, + double run_width) + : style_(style), + text_(std::move(text)), + metrics_(metrics), + line_(line), + run_width_(run_width) {} PaintRecord::PaintRecord(PaintRecord&& other) { style_ = other.style_; @@ -44,7 +51,7 @@ PaintRecord::PaintRecord(PaintRecord&& other) { text_ = std::move(other.text_); metrics_ = other.metrics_; line_ = other.line_; - width_modifier_ = other.width_modifier_; + run_width_ = other.run_width_; } PaintRecord& PaintRecord::operator=(PaintRecord&& other) { @@ -53,7 +60,7 @@ PaintRecord& PaintRecord::operator=(PaintRecord&& other) { text_ = std::move(other.text_); metrics_ = other.metrics_; line_ = other.line_; - width_modifier_ = other.width_modifier_; + run_width_ = other.run_width_; return *this; } @@ -61,8 +68,4 @@ void PaintRecord::SetOffset(SkPoint pt) { offset_ = pt; } -void PaintRecord::SetWidthModifier(double val) { - width_modifier_ = val; -} - } // namespace txt diff --git a/engine/src/flutter/src/paint_record.h b/engine/src/flutter/src/paint_record.h index e6b2d02874..5d60c9425d 100644 --- a/engine/src/flutter/src/paint_record.h +++ b/engine/src/flutter/src/paint_record.h @@ -38,12 +38,14 @@ class PaintRecord { SkPoint offset, sk_sp text, SkPaint::FontMetrics metrics, - int line); + int line, + double run_width); PaintRecord(TextStyle style, sk_sp text, SkPaint::FontMetrics metrics, - int line); + int line, + double run_width); PaintRecord(PaintRecord&& other); @@ -72,8 +74,7 @@ class PaintRecord { // FontMetrics stores the measurements of the font used. SkPaint::FontMetrics metrics_; size_t line_; - // Change in width when using a non-left text alignment. - double width_modifier_ = 0.0f; + double run_width_ = 0.0f; FTL_DISALLOW_COPY_AND_ASSIGN(PaintRecord); }; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 76c4693f28..329d10218c 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -247,9 +247,6 @@ void Paragraph::Layout(double width, bool force) { records_[record_index].offset().x() + width_ - breaker_.getWidths()[records_[record_index].line()], records_[record_index].offset().y())); - records_[record_index].SetWidthModifier( - records_[record_index].GetWidthModifier() + width_ - - breaker_.getWidths()[records_[record_index].line()]); break; } case TextAlign::center: { @@ -259,18 +256,9 @@ void Paragraph::Layout(double width, bool force) { breaker_.getWidths()[records_[record_index].line()]) / 2, records_[record_index].offset().y())); - - records_[record_index].SetWidthModifier( - records_[record_index].GetWidthModifier() + - (width_ - breaker_.getWidths()[records_[record_index].line()]) / - 2); break; } case TextAlign::justify: { - records_[record_index].SetWidthModifier( - records_[record_index].GetWidthModifier() + - records_[record_index].GetWidthModifier() + width_ - - breaker_.getWidths()[records_[record_index].line()]); break; } } @@ -339,6 +327,7 @@ void Paragraph::Layout(double width, bool force) { word_count = 0; double temp_line_spacing = 0; double current_x_position = previous_run_x_position; + double run_width = 0.0f; while (blob_start < glyph_count) { const size_t blob_length = GetBlobLength(layout, blob_start); buffer_sizes.push_back(blob_length); @@ -347,9 +336,10 @@ void Paragraph::Layout(double width, bool force) { // Check if we should remove trailing whitespace of blobs. size_t trailing_length = 0; - while (paragraph_style_.text_align == TextAlign::justify && - minikin::isWordSpace( - text_[blob_start + blob_length - trailing_length - 1]) && + while ((paragraph_style_.text_align == TextAlign::center || + paragraph_style_.text_align == TextAlign::right) && + whitespace_set_.count(layout.getGlyphId( + blob_start + blob_length - trailing_length - 1)) > 0 && layout_end == next_break) { ++trailing_length; } @@ -387,6 +377,7 @@ void Paragraph::Layout(double width, bool force) { } prev_char_advance = layout.getCharAdvance(glyph_index); + run_width += layout.getCharAdvance(glyph_index); } blob_start += blob_length; previous_run_x_position += current_x_position + prev_char_advance; @@ -402,7 +393,7 @@ void Paragraph::Layout(double width, bool force) { JustifyLine(buffers, buffer_sizes, word_count, justify_spacing); } records_.push_back( - PaintRecord{run.style, builder.make(), metrics, lines_}); + PaintRecord{run.style, builder.make(), metrics, lines_, run_width}); line_width += std::abs(records_[records_.size() - 1].text()->bounds().fRight + records_[records_.size() - 1].text()->bounds().fLeft); @@ -480,7 +471,6 @@ void Paragraph::Layout(double width, bool force) { // Remove decoration extra width if the last line. size_t i = records_.size() - 1; while (records_[i].line() == lines_ - 1) { - records_[i].SetWidthModifier(0); --i; } } @@ -636,15 +626,13 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, std::vector wave_coords; double width = 0; - if (record_index == records_.size() - 1 || - record.line() < records_[record_index + 1].line()) { - width = line_widths_[record.line()] - x; + if (paragraph_style_.text_align == TextAlign::justify && + record.line() != lines_ - 1) { + width = width_; } else { - width = record.text()->bounds().fRight + record.text()->bounds().fLeft; + width = record.GetRunWidth(); } - width += record.GetWidthModifier(); - paint.setStrokeWidth( (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: kUnderlineThicknessIsValid_Flag)) From 95bda714a0a15d1609966517e71e0e6a2ff45098 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 27 Jul 2017 13:01:21 -0700 Subject: [PATCH 344/364] Support handling '\n' characters. Change-Id: I9d8c25df97e600ee3679f0bf31b0a4bb8df9eb6d --- .../src/flutter/libs/minikin/LineBreaker.cpp | 1 + engine/src/flutter/src/paragraph.cc | 15 ++++- engine/src/flutter/src/paragraph.h | 1 + engine/src/flutter/src/paragraph_builder.cc | 16 ++++++ engine/src/flutter/src/paragraph_builder.h | 4 ++ engine/src/flutter/src/styled_runs.cc | 38 +++++++++++++ engine/src/flutter/src/styled_runs.h | 4 ++ .../flutter/tests/txt/paragraph_unittests.cc | 56 +++++++++++++++++++ 8 files changed, 132 insertions(+), 3 deletions(-) diff --git a/engine/src/flutter/libs/minikin/LineBreaker.cpp b/engine/src/flutter/libs/minikin/LineBreaker.cpp index 661a8fc30e..2a29989ff9 100644 --- a/engine/src/flutter/libs/minikin/LineBreaker.cpp +++ b/engine/src/flutter/libs/minikin/LineBreaker.cpp @@ -156,6 +156,7 @@ float LineBreaker::addStyleRun(MinikinPaint* paint, const std::shared_ptr text(text_); + SkPaint paint; paint.setAntiAlias(true); paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); @@ -293,6 +297,11 @@ void Paragraph::Layout(double width, bool force) { }; for (size_t run_index = 0; run_index < runs_.size(); ++run_index) { auto run = runs_.GetRun(run_index); + bool is_newline = text_[run.start] == '\n' && run.end - run.start == 1; + // Replace '\n' with a null character so that a 'missing glyph' box is not + // drawn. + if (is_newline) + text[run.start] = '\0'; GetFontAndMinikinPaint(run.style, &font, &minikin_paint); GetPaint(run.style, &paint); @@ -311,7 +320,7 @@ void Paragraph::Layout(double width, bool force) { // However, this is not significant for reasonably sized paragraphs. It is // currently recommended to break up very long paragraphs (10k+ // characters) to ensure speedy layout. - layout.doLayout(text_.data() + layout_start, 0, layout_end - layout_start, + layout.doLayout(text.data() + layout_start, 0, layout_end - layout_start, layout_end - layout_start, bidiFlags, font, minikin_paint, font_collection_->GetMinikinFontCollectionForFamily( run.style.font_family)); @@ -419,7 +428,7 @@ void Paragraph::Layout(double width, bool force) { if (max_descent < temp_line_spacing) max_descent = temp_line_spacing; - if (layout_end == next_break) { + if (layout_end == next_break || is_newline) { y += max_line_spacing + prev_max_descent; line_heights_.push_back( (line_heights_.empty() ? 0 : line_heights_.back()) + @@ -769,10 +778,10 @@ void Paragraph::PaintWavyDecoration(SkCanvas* canvas, std::vector Paragraph::GetRectsForRange(size_t start, size_t end) const { - FTL_DCHECK(end >= start && end >= 0 && start >= 0); std::vector rects; end = fmax(start, end); start = fmin(start, end); + FTL_DCHECK(end >= start && end >= 0 && start >= 0); if (end == start) end = start + 1; end = fmin(end, text_.size()); diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index e6bde8dd57..21bb722716 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -153,6 +153,7 @@ class Paragraph { FRIEND_TEST(RenderTest, SpacingParagraph); FRIEND_TEST(RenderTest, LongWordParagraph); FRIEND_TEST(RenderTest, KernParagraph); + FRIEND_TEST(RenderTest, NewlineParagraph); // Starting data to layout. std::vector text_; diff --git a/engine/src/flutter/src/paragraph_builder.cc b/engine/src/flutter/src/paragraph_builder.cc index 31d18ad95f..0cb1170965 100644 --- a/engine/src/flutter/src/paragraph_builder.cc +++ b/engine/src/flutter/src/paragraph_builder.cc @@ -15,6 +15,8 @@ */ #include "lib/ftl/logging.h" +#include + #include "lib/txt/src/paragraph_builder.h" #include "lib/txt/src/paragraph_style.h" #include "third_party/icu/source/common/unicode/unistr.h" @@ -78,6 +80,17 @@ void ParagraphBuilder::AddText(const char* text) { AddText(u16_text); } +void ParagraphBuilder::SplitNewlineRuns() { + std::list newline_positions; + for (size_t i = 0; i < text_.size(); ++i) { + if (text_[i] == '\n') { + newline_positions.push_back(i); + } + } + if (newline_positions.size() > 0) + runs_.SplitNewlineRuns(newline_positions); +} + std::unique_ptr ParagraphBuilder::Build() { if (font_collection_ == nullptr) { // Will be deprecated when full compatibility with Flutter Engine is @@ -86,6 +99,9 @@ std::unique_ptr ParagraphBuilder::Build() { } runs_.EndRunIfNeeded(text_.size()); + + SplitNewlineRuns(); + std::unique_ptr paragraph = std::make_unique(); paragraph->SetText(std::move(text_), std::move(runs_)); paragraph->SetParagraphStyle(paragraph_style_); diff --git a/engine/src/flutter/src/paragraph_builder.h b/engine/src/flutter/src/paragraph_builder.h index 7055894e8c..df756672a7 100644 --- a/engine/src/flutter/src/paragraph_builder.h +++ b/engine/src/flutter/src/paragraph_builder.h @@ -83,6 +83,10 @@ class ParagraphBuilder { ParagraphStyle paragraph_style_; FontCollection* font_collection_ = nullptr; + // Break any newline '\n' characters into their own runs. This allows + // Paragraph::Layout to cleanly discover and handle newlines. + void SplitNewlineRuns(); + FTL_DISALLOW_COPY_AND_ASSIGN(ParagraphBuilder); }; diff --git a/engine/src/flutter/src/styled_runs.cc b/engine/src/flutter/src/styled_runs.cc index 3f5f79da62..7e64460c18 100644 --- a/engine/src/flutter/src/styled_runs.cc +++ b/engine/src/flutter/src/styled_runs.cc @@ -16,6 +16,8 @@ #include "lib/txt/src/styled_runs.h" +#include "lib/ftl/logging.h" + namespace txt { StyledRuns::StyledRuns() = default; @@ -65,4 +67,40 @@ StyledRuns::Run StyledRuns::GetRun(size_t index) const { return Run{styles_[run.style_index], run.start, run.end}; } +void StyledRuns::SplitNewlineRuns(std::list newline_positions) { + std::vector result; + for (size_t i = 0; i < runs_.size(); ++i) { + if (runs_[i].end <= newline_positions.front() || + newline_positions.empty()) { + result.push_back(runs_[i]); + } else { + size_t start = runs_[i].start; + size_t end = runs_[i].end; + while (end > newline_positions.front() && !newline_positions.empty() && + start < end) { + IndexedRun temp_run; + temp_run.style_index = runs_[i].style_index; + temp_run.start = start; + temp_run.end = newline_positions.front(); + newline_positions.pop_front(); + result.push_back(temp_run); + + temp_run.start = temp_run.end; + temp_run.end = temp_run.end + 1; + result.push_back(temp_run); + + start = temp_run.end; + } + if (start < end) { + IndexedRun temp_run; + temp_run.style_index = runs_[i].style_index; + temp_run.start = start; + temp_run.end = end; + result.push_back(temp_run); + } + } + } + runs_ = result; +} + } // namespace txt diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index 3fd52ad78c..24ac305700 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -17,6 +17,7 @@ #ifndef LIB_TXT_SRC_STYLED_RUNS_H_ #define LIB_TXT_SRC_STYLED_RUNS_H_ +#include #include #include "lib/txt/src/text_style.h" @@ -56,6 +57,9 @@ class StyledRuns { Run GetRun(size_t index) const; + // Break any newline '\n' characters into their own runs. + void SplitNewlineRuns(std::list newline_positions); + private: FRIEND_TEST(RenderTest, SimpleParagraph); FRIEND_TEST(RenderTest, SimpleRedParagraph); diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 98762eace3..974ac595cf 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -1335,4 +1335,60 @@ TEST_F(RenderTest, KernParagraph) { ASSERT_TRUE(Snapshot()); } +TEST_F(RenderTest, NewlineParagraph) { + txt::ParagraphStyle paragraph_style; + paragraph_style.break_strategy = minikin::kBreakStrategy_HighQuality; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.font_family = "Roboto"; + text_style.font_size = 60; + text_style.letter_spacing = 0; + text_style.word_spacing = 0; + text_style.color = SK_ColorBLACK; + text_style.height = 1; + builder.PushStyle(text_style); + builder.AddText( + "line1\nline2 test1 test2 test3 test4 test5 test6 test7\nline3\n\nline4 " + "test1 test2 test3 test4"); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth() - 300); + + paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_TRUE(Snapshot()); + + ASSERT_EQ(paragraph->runs_.size(), 9ull); + ASSERT_EQ(paragraph->runs_.GetRun(1).end - paragraph->runs_.GetRun(1).start, + 1ull); + ASSERT_EQ(paragraph->runs_.GetRun(3).end - paragraph->runs_.GetRun(3).start, + 1ull); + ASSERT_EQ(paragraph->runs_.GetRun(5).end - paragraph->runs_.GetRun(5).start, + 1ull); + ASSERT_EQ(paragraph->runs_.GetRun(7).end - paragraph->runs_.GetRun(7).start, + 1ull); + + ASSERT_EQ(paragraph->records_.size(), 10ull); + EXPECT_DOUBLE_EQ(paragraph->records_[0].offset().x(), 0); + EXPECT_DOUBLE_EQ(paragraph->records_[1].offset().x(), 129); + EXPECT_DOUBLE_EQ(paragraph->records_[1].offset().y(), + paragraph->records_[0].offset().y()); + EXPECT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 0); + EXPECT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 0); + EXPECT_DOUBLE_EQ(paragraph->records_[4].offset().x(), 593); + EXPECT_DOUBLE_EQ(paragraph->records_[3].offset().y(), + paragraph->records_[4].offset().y()); + EXPECT_DOUBLE_EQ(paragraph->records_[5].offset().x(), 0); + EXPECT_DOUBLE_EQ(paragraph->records_[6].offset().x(), 129); + EXPECT_DOUBLE_EQ(paragraph->records_[7].offset().x(), 0); + EXPECT_DOUBLE_EQ(paragraph->records_[8].offset().x(), 0); + EXPECT_DOUBLE_EQ(paragraph->records_[7].offset().y(), 336.9140625); + EXPECT_DOUBLE_EQ(paragraph->records_[8].offset().y(), 407.2265625); + +} + } // namespace txt From d09bbdfd37357630c23a080d91e398bd65ea1bae Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 27 Jul 2017 17:54:27 -0700 Subject: [PATCH 345/364] Check if width is different before skipping Layout(). Change-Id: Ie5a99f39cf462c42ed1e484afc90a61e7567bdc3 --- engine/src/flutter/src/paragraph.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 5c3c77b2cb..4b4f8532ae 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -167,7 +167,7 @@ void Paragraph::FillWhitespaceSet(size_t start, void Paragraph::Layout(double width, bool force) { // Do not allow calling layout multiple times without changing anything. - if (!needs_layout_ && !force) + if (!needs_layout_ && !force && width == width_) return; needs_layout_ = false; From 1fd69f9824d51a375a0dba7ffb0680b1f6cca49e Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 28 Jul 2017 15:21:39 -0700 Subject: [PATCH 346/364] Refactor FontCollection to allow for adding in new font managers, and initial android font loading. Change-Id: I719b14a515aabf5d6b3894f79ca64ea20ef5625d --- engine/src/flutter/BUILD.gn | 3 ++ engine/src/flutter/src/font_collection.cc | 47 +++++++++++++++++++---- engine/src/flutter/src/font_collection.h | 12 ++++++ 3 files changed, 54 insertions(+), 8 deletions(-) diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn index 9aabc9ec04..2888897efa 100644 --- a/engine/src/flutter/BUILD.gn +++ b/engine/src/flutter/BUILD.gn @@ -24,6 +24,9 @@ source_set("txt") { if (current_toolchain == host_toolchain) { defines = [ "DIRECTORY_FONT_MANAGER_AVAILABLE" ] } + if (is_android) { + defines = [ "ANDROID_FONT_MANAGER_AVAILABLE" ] + } sources = [ "src/font_collection.cc", diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index ae59ddf639..fceb5fb527 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -28,6 +28,7 @@ #include "lib/txt/src/font_skia.h" #include "third_party/skia/include/core/SkString.h" #include "third_party/skia/include/ports/SkFontMgr.h" +#include "third_party/skia/include/ports/SkFontMgr_android.h" #include "third_party/skia/include/ports/SkFontMgr_directory.h" namespace txt { @@ -69,16 +70,50 @@ FontCollection::FontCollection(std::string dir, CacheMethod cache_method) { FontCollection::FontCollection(const std::vector& dirs, CacheMethod cache_method) { -#ifdef DIRECTORY_FONT_MANAGER_AVAILABLE for (std::string dir : dirs) { if (dir.length() != 0) { - skia_font_managers_.push_back( - SkFontMgr_New_Custom_Directory(dir.c_str())); + AddFontMgr(dir, false); } } -#endif skia_font_managers_.push_back(SkFontMgr::RefDefault()); + DiscoverFamilyNames(); + + cache_method_ = cache_method; +} + +FontCollection::~FontCollection() = default; + +void FontCollection::AddFontMgr(std::string dir, bool rediscover_family_names) { +#ifdef DIRECTORY_FONT_MANAGER_AVAILABLE + // On Linux systems: + skia_font_managers_.push_back(SkFontMgr_New_Custom_Directory(dir.c_str())); +#endif +#ifdef ANDROID_FONT_MANAGER_AVAILABLE + // On Android: + SkFontMgr_Android_CustomFonts android_custom_font_data; + // Ensure the dir string is '/' terminated. + if (dir.back() != '/') + dir += '/'; + android_custom_font_data.fBasePath = dir.data(); + android_custom_font_data.fSystemFontUse = + SkFontMgr_Android_CustomFonts::SystemFontUse::kOnlyCustom; + skia_font_managers_.push_back( + SkFontMgr_New_Android(&android_custom_font_data)); +#endif + + if (rediscover_family_names) + DiscoverFamilyNames(); +} + +void FontCollection::AddFontMgr(sk_sp font_mgr, + bool rediscover_family_names) { + skia_font_managers_.push_back(font_mgr); + if (rediscover_family_names) + DiscoverFamilyNames(); +} + +void FontCollection::DiscoverFamilyNames() { SkString str; for (sk_sp mgr : skia_font_managers_) { for (int i = 0; i < mgr->countFamilies(); i++) { @@ -86,12 +121,8 @@ FontCollection::FontCollection(const std::vector& dirs, family_names_.insert(std::string{str.writable_str()}); } } - - cache_method_ = cache_method; } -FontCollection::~FontCollection() = default; - std::set FontCollection::GetFamilyNames() { return family_names_; } diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index fb3a3be0bd..f305241669 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -84,6 +84,13 @@ class FontCollection { // managers. bool HasFamily(const std::string family) const; + // Adds a new SkFontMgr to the front of the stack of font managers. + void AddFontMgr(std::string dir, bool rediscover_family_names = true); + + // Adds the provided SkFontMgr to the front of the stack of font managers. + void AddFontMgr(sk_sp font_mgr, + bool rediscover_family_names = true); + // Removes all fonts that do not fit in the cache capacity from memory. void FlushCache(); @@ -112,8 +119,13 @@ class FontCollection { FRIEND_TEST(FontCollection, GetMinikinFontCollections); FRIEND_TEST(FontCollection, GetFamilyNames); + // Postprocess the family name to handle the following properties: fallback + // when not found and reverting to the default name when no fallback is found. const std::string ProcessFamilyName(const std::string& family); + // Polls the SkFontMgrs to obtain a set of all available font family names. + void DiscoverFamilyNames(); + void TrimCache(); static const std::string GetDefaultFamilyName() { From a28fbd2e7467aa1ea82339818628df2053487622 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 1 Aug 2017 11:11:07 -0700 Subject: [PATCH 347/364] Correct name of def font on Android and fix bug with coords-to-glyphpos method. Change-Id: Ib9d2a0a1a54f14c4725e47e00fb547df0a91cd40 --- engine/src/flutter/BUILD.gn | 2 +- engine/src/flutter/src/font_collection.h | 6 ++++++ engine/src/flutter/src/paragraph.cc | 6 ++---- engine/src/flutter/tests/txt/paragraph_unittests.cc | 3 ++- 4 files changed, 11 insertions(+), 6 deletions(-) diff --git a/engine/src/flutter/BUILD.gn b/engine/src/flutter/BUILD.gn index 2888897efa..2549e6d017 100644 --- a/engine/src/flutter/BUILD.gn +++ b/engine/src/flutter/BUILD.gn @@ -21,7 +21,7 @@ config("txt_config") { } source_set("txt") { - if (current_toolchain == host_toolchain) { + if (current_toolchain == host_toolchain && !is_mac) { defines = [ "DIRECTORY_FONT_MANAGER_AVAILABLE" ] } if (is_android) { diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index f305241669..63c9ca1a38 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -18,6 +18,12 @@ #define LIB_TXT_SRC_FONT_COLLECTION_H_ #define DEFAULT_FAMILY_NAME "Roboto" +#ifdef ANDROID_FONT_MANAGER_AVAILABLE +#undef DEFAULT_FAMILY_NAME +// On Android, Roboto is called 'sans-serif' +#define DEFAULT_FAMILY_NAME "sans-serif" +#endif + #define DEFAULT_CACHE_CAPACITY 20 #include diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 4b4f8532ae..6b9f8ca5ae 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -842,12 +842,10 @@ size_t Paragraph::GetGlyphPositionAtCoordinate( prev_count = 0; for (size_t x_index = 1; x_index < glyph_position_x_[y_index].size() - 1; ++x_index) { - // TODO(garyq): Resolve edge case where second to last glyph position is - // skipped/unreachable. if (dx < glyph_position_x_[y_index][x_index] - (using_glyph_center_as_boundary - ? (glyph_position_x_[y_index][x_index + 1] - - glyph_position_x_[y_index][x_index]) / + ? (glyph_position_x_[y_index][x_index] - + glyph_position_x_[y_index][x_index -1]) / 2.0f : 0)) { break; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 974ac595cf..b28ef56ce9 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -28,7 +28,7 @@ namespace txt { TEST_F(RenderTest, SimpleParagraph) { - const char* text = "Hello World"; + const char* text = "Hello World Text Dialog"; auto icu_text = icu::UnicodeString::fromUTF8(text); std::u16string u16_text(icu_text.getBuffer(), icu_text.getBuffer() + icu_text.length()); @@ -39,6 +39,7 @@ TEST_F(RenderTest, SimpleParagraph) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; + text_style.font_size = 12; builder.PushStyle(text_style); builder.AddText(u16_text); From 4a5e0222a3e729b093f80db4fd60657d9ae41aca Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 1 Aug 2017 12:31:37 -0700 Subject: [PATCH 348/364] Change handling of large y coord in GetGlyphPositionAtCoordinate() to match blink. Change-Id: I6db6d5e98a0ef63e29cc4aac9a3aa38dfb18e59d --- engine/src/flutter/src/paragraph.cc | 13 ++++++++----- engine/src/flutter/src/paragraph.h | 11 ++++++++--- engine/src/flutter/tests/txt/paragraph_unittests.cc | 1 + 3 files changed, 17 insertions(+), 8 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 6b9f8ca5ae..ad82dbd4f7 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -416,7 +416,7 @@ void Paragraph::Layout(double width, bool force) { run.style.height; if (max_line_spacing < temp_line_spacing) { max_line_spacing = temp_line_spacing; - // Record the alphabetic_baseline_: + // Record the alphabetic_baseline_ and idegraphic_baseline_: if (lines_ == 0) { alphabetic_baseline_ = -metrics.fAscent * run.style.height; // TODO(garyq): Properly implement ideographic_baseline_. @@ -466,8 +466,8 @@ void Paragraph::Layout(double width, bool force) { postprocess_line(); if (line_width != 0) line_widths_.push_back(line_width); - - line_heights_.push_back(FLT_MAX); + line_heights_.push_back((line_heights_.empty() ? 0 : line_heights_.back()) + + max_line_spacing + max_descent); glyph_single_line_position_x.push_back(glyph_single_line_position_x.back() + prev_char_advance); glyph_single_line_position_x.push_back(FLT_MAX); @@ -830,22 +830,25 @@ size_t Paragraph::GetGlyphPositionAtCoordinate( size_t offset = 0; size_t y_index = 1; size_t prev_count = 0; - for (y_index = 1; y_index < line_heights_.size(); ++y_index) { + for (y_index = 1; y_index < line_heights_.size() - 2; ++y_index) { if (dy < line_heights_[y_index]) { offset += prev_count; + prev_count = glyph_position_x_[y_index - 1].size() - 3; break; } else { offset += prev_count; prev_count = glyph_position_x_[y_index].size() - 3; } } + if (y_index == line_heights_.size() - 2) + offset += prev_count; prev_count = 0; for (size_t x_index = 1; x_index < glyph_position_x_[y_index].size() - 1; ++x_index) { if (dx < glyph_position_x_[y_index][x_index] - (using_glyph_center_as_boundary ? (glyph_position_x_[y_index][x_index] - - glyph_position_x_[y_index][x_index -1]) / + glyph_position_x_[y_index][x_index - 1]) / 2.0f : 0)) { break; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 21bb722716..d0cc8fd05e 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -86,11 +86,11 @@ class Paragraph { double GetMaxWidth() const; // Distance from top of paragraph to the Alphabetic baseline of the first - // line. + // line. Used for alphabetic fonts (A-Z, a-z, greek, etc.) double GetAlphabeticBaseline() const; // Distance from top of paragraph to the Ideographic baseline of the first - // line. + // line. Used for ideographic fonts (Chinese, Japanese, Korean, etc.) double GetIdeographicBaseline() const; // Returns the total width covered by the paragraph without linebreaking. @@ -98,6 +98,8 @@ class Paragraph { // Currently, calculated similarly to as GetLayoutWidth(), however this is not // nessecarily 100% correct in all cases. + // + // Returns the actual max width of the longest line after Layout(). double GetMinIntrinsicWidth() const; // Returns a vector of bounding boxes that enclose all text between start and @@ -108,7 +110,10 @@ class Paragraph { // with the top left corner as the origin, and +y direction as down. // // When using_glyph_center_as_boundary == true, coords to the + direction of - // the center x-position of the glyph will be considered as the next glyph. + // the center x-position of the glyph will be considered as the next glyph. A + // typical use-case for this is when the cursor is meant to be on either side + // of any given character. This allows the transition border to be middle of + // each character. size_t GetGlyphPositionAtCoordinate( double dx, double dy, diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index b28ef56ce9..7e422673f7 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -922,6 +922,7 @@ TEST_F(RenderTest, GetGlyphPositionAtCoordinateParagraph) { ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(1, 270), 54ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(35, 90), 19ull); ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(10000, 10000), 77ull); + ASSERT_EQ(paragraph->GetGlyphPositionAtCoordinate(85, 10000), 74ull); } TEST_F(RenderTest, GetRectsForRangeParagraph) { From 3ba10870252f56a234e97923c7f82c73717f1129 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 1 Aug 2017 16:46:42 -0700 Subject: [PATCH 349/364] Use serif font on kerning tests and white bg for increased test clarity. Change-Id: If9a0063d854a277ea3023e44558ee443602cf467 --- .../flutter/tests/txt/paragraph_unittests.cc | 14 ++++++++------ engine/src/flutter/tests/txt/render_test.cc | 2 +- .../flutter/third_party/fonts/DroidSerif.ttf | Bin 0 -> 43648 bytes 3 files changed, 9 insertions(+), 7 deletions(-) create mode 100644 engine/src/flutter/third_party/fonts/DroidSerif.ttf diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 7e422673f7..266b6d0113 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -39,7 +39,6 @@ TEST_F(RenderTest, SimpleParagraph) { txt::TextStyle text_style; text_style.color = SK_ColorBLACK; - text_style.font_size = 12; builder.PushStyle(text_style); builder.AddText(u16_text); @@ -1304,7 +1303,7 @@ TEST_F(RenderTest, KernParagraph) { txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; - text_style.font_family = "Roboto"; + text_style.font_family = "Droid Serif"; text_style.font_size = 100; text_style.letter_spacing = 0; text_style.word_spacing = 0; @@ -1316,8 +1315,11 @@ TEST_F(RenderTest, KernParagraph) { builder.AddText("A"); builder.PushStyle(text_style); builder.AddText("V"); + text_style.font_size = 12; builder.PushStyle(text_style); - builder.AddText(" Dialog"); + builder.AddText( + " Dialog Text List lots of words to see if kerning works on a bigger set " + "of characters AVAVAW"); builder.Pop(); @@ -1330,9 +1332,9 @@ TEST_F(RenderTest, KernParagraph) { EXPECT_DOUBLE_EQ(paragraph->records_[0].offset().x(), 0); EXPECT_DOUBLE_EQ(paragraph->records_[1].offset().x(), 0); - EXPECT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 441.16796875f); - EXPECT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 506.16796875); - EXPECT_DOUBLE_EQ(paragraph->records_[4].offset().x(), 570.16796875); + EXPECT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 622.015625f); + EXPECT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 693.015625); + EXPECT_DOUBLE_EQ(paragraph->records_[4].offset().x(), 760.015625); ASSERT_TRUE(Snapshot()); } diff --git a/engine/src/flutter/tests/txt/render_test.cc b/engine/src/flutter/tests/txt/render_test.cc index 4b87a06bbb..aa80d0b6fd 100644 --- a/engine/src/flutter/tests/txt/render_test.cc +++ b/engine/src/flutter/tests/txt/render_test.cc @@ -58,7 +58,7 @@ void RenderTest::SetUp() { bitmap_ = std::make_unique(); bitmap_->allocN32Pixels(GetTestCanvasWidth(), GetTestCanvasHeight()); canvas_ = std::make_unique(*bitmap_); - canvas_->clear(SK_ColorTRANSPARENT); + canvas_->clear(SK_ColorWHITE); } void RenderTest::TearDown() { diff --git a/engine/src/flutter/third_party/fonts/DroidSerif.ttf b/engine/src/flutter/third_party/fonts/DroidSerif.ttf new file mode 100644 index 0000000000000000000000000000000000000000..90cdfffe540c8440456c354061ad2aabc9c0985f GIT binary patch literal 43648 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

86+7r8JHQQf9s^`NiqEvOwnbOW>8a- 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 Date: Thu, 3 Aug 2017 11:12:37 -0700 Subject: [PATCH 350/364] Fix incorrect/rounded glyph advances, update tests to reflect correct layout. Change-Id: I15f441d065a2990decc433f9a9f8a74c452928c3 --- engine/src/flutter/libs/minikin/Layout.cpp | 4 +- engine/src/flutter/src/paragraph.cc | 2 +- engine/src/flutter/src/paragraph.h | 2 +- .../flutter/tests/txt/paragraph_unittests.cc | 69 ++++++++++--------- 4 files changed, 40 insertions(+), 37 deletions(-) diff --git a/engine/src/flutter/libs/minikin/Layout.cpp b/engine/src/flutter/libs/minikin/Layout.cpp index 697fbc2ba2..59a05615c3 100644 --- a/engine/src/flutter/libs/minikin/Layout.cpp +++ b/engine/src/flutter/libs/minikin/Layout.cpp @@ -314,7 +314,9 @@ int Layout::findFace(const FakedFont& face, LayoutContext* ctx) { // corresponding hb_font object. if (ctx != NULL) { hb_font_t* font = getHbFontLocked(face.font); - hb_font_set_funcs(font, getHbFontFuncs(isColorBitmapFont(font)), &ctx->paint, 0); + // Temporarily removed to fix advance integer rounding. + // This is likely due to very old versions of harfbuzz and ICU. + // hb_font_set_funcs(font, getHbFontFuncs(isColorBitmapFont(font)), &ctx->paint, 0); ctx->hbFonts.push_back(font); } return ix; diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index ad82dbd4f7..c1233fec11 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -102,7 +102,7 @@ void GetFontAndMinikinPaint(const TextStyle& style, // size. paint->letterSpacing = style.letter_spacing / style.font_size; paint->wordSpacing = style.word_spacing; - paint->scaleX = 1; + paint->scaleX = 1.0f; // Prevent spacing rounding in Minikin. paint->paintFlags = 0xFF; } diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index d0cc8fd05e..63cbb2e770 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -157,7 +157,7 @@ class Paragraph { FRIEND_TEST(RenderTest, DISABLED_ArabicParagraph); FRIEND_TEST(RenderTest, SpacingParagraph); FRIEND_TEST(RenderTest, LongWordParagraph); - FRIEND_TEST(RenderTest, KernParagraph); + FRIEND_TEST(RenderTest, KernScaleParagraph); FRIEND_TEST(RenderTest, NewlineParagraph); // Starting data to layout. diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 266b6d0113..7a20dbb0af 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -972,7 +972,7 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_EQ(rects.size(), 1ull); EXPECT_FLOAT_EQ(rects[0].left(), 0); EXPECT_FLOAT_EQ(rects[0].top(), 0); - EXPECT_FLOAT_EQ(rects[0].right(), 28); + EXPECT_FLOAT_EQ(rects[0].right(), 28.417969); EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); rects = paragraph->GetRectsForRange(0, 1); @@ -982,7 +982,7 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_EQ(rects.size(), 1ull); EXPECT_FLOAT_EQ(rects[0].left(), 0); EXPECT_FLOAT_EQ(rects[0].top(), 0); - EXPECT_FLOAT_EQ(rects[0].right(), 28); + EXPECT_FLOAT_EQ(rects[0].right(), 28.417969); EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); paint.setColor(SK_ColorBLUE); @@ -991,19 +991,19 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { GetCanvas()->drawRect(rects[i], paint); } EXPECT_EQ(rects.size(), 3ull); - EXPECT_FLOAT_EQ(rects[0].left(), 56); + EXPECT_FLOAT_EQ(rects[0].left(), 56.835938); EXPECT_FLOAT_EQ(rects[0].top(), 0); - EXPECT_FLOAT_EQ(rects[0].right(), 151); + EXPECT_FLOAT_EQ(rects[0].right(), 153); EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); - EXPECT_FLOAT_EQ(rects[1].left(), 151); + EXPECT_FLOAT_EQ(rects[1].left(), 153); EXPECT_FLOAT_EQ(rects[1].top(), 0); - EXPECT_FLOAT_EQ(rects[1].right(), 163); + EXPECT_FLOAT_EQ(rects[1].right(), 165); EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); - EXPECT_FLOAT_EQ(rects[2].left(), 163); + EXPECT_FLOAT_EQ(rects[2].left(), 165); EXPECT_FLOAT_EQ(rects[2].top(), 0); - EXPECT_FLOAT_EQ(rects[2].right(), 175); + EXPECT_FLOAT_EQ(rects[2].right(), 177); EXPECT_FLOAT_EQ(rects[2].bottom(), 58.59375); paint.setColor(SK_ColorGREEN); @@ -1012,19 +1012,19 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { GetCanvas()->drawRect(rects[i], paint); } EXPECT_EQ(rects.size(), 3ull); - EXPECT_FLOAT_EQ(rects[0].left(), 175); + EXPECT_FLOAT_EQ(rects[0].left(), 177); EXPECT_FLOAT_EQ(rects[0].top(), 0); - EXPECT_FLOAT_EQ(rects[0].right(), 347); + EXPECT_FLOAT_EQ(rects[0].right(), 352); EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); - EXPECT_FLOAT_EQ(rects[1].left(), 347); + EXPECT_FLOAT_EQ(rects[1].left(), 352); EXPECT_FLOAT_EQ(rects[1].top(), 0); - EXPECT_FLOAT_EQ(rects[1].right(), 359); + EXPECT_FLOAT_EQ(rects[1].right(), 364); EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); - EXPECT_FLOAT_EQ(rects[2].left(), 359); + EXPECT_FLOAT_EQ(rects[2].left(), 364); EXPECT_FLOAT_EQ(rects[2].top(), 0); - EXPECT_FLOAT_EQ(rects[2].right(), 499); + EXPECT_FLOAT_EQ(rects[2].right(), 507); EXPECT_FLOAT_EQ(rects[2].bottom(), 58.59375); paint.setColor(SK_ColorRED); @@ -1033,16 +1033,16 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { GetCanvas()->drawRect(rects[i], paint); } EXPECT_EQ(rects.size(), 17ull); - EXPECT_FLOAT_EQ(rects[0].left(), 208); + EXPECT_FLOAT_EQ(rects[0].left(), 210.83594); EXPECT_FLOAT_EQ(rects[0].top(), 58.59375); - EXPECT_FLOAT_EQ(rects[0].right(), 292); + EXPECT_FLOAT_EQ(rects[0].right(), 296); EXPECT_FLOAT_EQ(rects[0].bottom(), 117.1875); // TODO(garyq): The following set of vals are definetly wrong and // end of paragraph handling needs to be fixed in a later patch. EXPECT_FLOAT_EQ(rects[16].left(), 0); EXPECT_FLOAT_EQ(rects[16].top(), 234.375); - EXPECT_FLOAT_EQ(rects[16].right(), 140); + EXPECT_FLOAT_EQ(rects[16].right(), 142.08984); EXPECT_FLOAT_EQ(rects[16].bottom(), 292.96875); paint.setColor(SK_ColorBLUE); @@ -1051,9 +1051,9 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { GetCanvas()->drawRect(rects[i], paint); } EXPECT_EQ(rects.size(), 2ull); - EXPECT_FLOAT_EQ(rects[1].left(), 499); + EXPECT_FLOAT_EQ(rects[1].left(), 507); EXPECT_FLOAT_EQ(rects[1].top(), 0); - EXPECT_FLOAT_EQ(rects[1].right(), 511); + EXPECT_FLOAT_EQ(rects[1].right(), 519.44922); EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); paint.setColor(SK_ColorRED); @@ -1081,8 +1081,8 @@ TEST_F(RenderTest, GetWordBoundaryParagraph) { txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; - text_style.font_size = 50; - text_style.letter_spacing = 1; + text_style.font_size = 52; + text_style.letter_spacing = 1.19039; text_style.word_spacing = 5; text_style.color = SK_ColorBLACK; text_style.height = 1.5; @@ -1296,7 +1296,9 @@ TEST_F(RenderTest, LongWordParagraph) { ASSERT_TRUE(Snapshot()); } -TEST_F(RenderTest, KernParagraph) { +TEST_F(RenderTest, KernScaleParagraph) { + float scale = 3.0f; + txt::ParagraphStyle paragraph_style; paragraph_style.break_strategy = minikin::kBreakStrategy_HighQuality; auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); @@ -1304,7 +1306,7 @@ TEST_F(RenderTest, KernParagraph) { txt::TextStyle text_style; text_style.font_family = "Droid Serif"; - text_style.font_size = 100; + text_style.font_size = 100 / scale; text_style.letter_spacing = 0; text_style.word_spacing = 0; text_style.color = SK_ColorBLACK; @@ -1315,7 +1317,7 @@ TEST_F(RenderTest, KernParagraph) { builder.AddText("A"); builder.PushStyle(text_style); builder.AddText("V"); - text_style.font_size = 12; + text_style.font_size = 14 / scale; builder.PushStyle(text_style); builder.AddText( " Dialog Text List lots of words to see if kerning works on a bigger set " @@ -1324,19 +1326,18 @@ TEST_F(RenderTest, KernParagraph) { builder.Pop(); auto paragraph = builder.Build(); - paragraph->Layout(GetTestCanvasWidth()); - + paragraph->Layout(GetTestCanvasWidth() / scale); + GetCanvas()->scale(scale, scale); paragraph->Paint(GetCanvas(), 0, 0); - + GetCanvas()->scale(1.0, 1.0); ASSERT_TRUE(Snapshot()); EXPECT_DOUBLE_EQ(paragraph->records_[0].offset().x(), 0); EXPECT_DOUBLE_EQ(paragraph->records_[1].offset().x(), 0); - EXPECT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 622.015625f); - EXPECT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 693.015625); - EXPECT_DOUBLE_EQ(paragraph->records_[4].offset().x(), 760.015625); + EXPECT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 207.37109375f); + EXPECT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 230.87109375f); + EXPECT_DOUBLE_EQ(paragraph->records_[4].offset().x(), 253.36328125f); - ASSERT_TRUE(Snapshot()); } TEST_F(RenderTest, NewlineParagraph) { @@ -1378,16 +1379,16 @@ TEST_F(RenderTest, NewlineParagraph) { ASSERT_EQ(paragraph->records_.size(), 10ull); EXPECT_DOUBLE_EQ(paragraph->records_[0].offset().x(), 0); - EXPECT_DOUBLE_EQ(paragraph->records_[1].offset().x(), 129); + EXPECT_DOUBLE_EQ(paragraph->records_[1].offset().x(), 127.69921875); EXPECT_DOUBLE_EQ(paragraph->records_[1].offset().y(), paragraph->records_[0].offset().y()); EXPECT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 0); EXPECT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 0); - EXPECT_DOUBLE_EQ(paragraph->records_[4].offset().x(), 593); + EXPECT_DOUBLE_EQ(paragraph->records_[4].offset().x(), 586.9921875); EXPECT_DOUBLE_EQ(paragraph->records_[3].offset().y(), paragraph->records_[4].offset().y()); EXPECT_DOUBLE_EQ(paragraph->records_[5].offset().x(), 0); - EXPECT_DOUBLE_EQ(paragraph->records_[6].offset().x(), 129); + EXPECT_DOUBLE_EQ(paragraph->records_[6].offset().x(), 127.69921875); EXPECT_DOUBLE_EQ(paragraph->records_[7].offset().x(), 0); EXPECT_DOUBLE_EQ(paragraph->records_[8].offset().x(), 0); EXPECT_DOUBLE_EQ(paragraph->records_[7].offset().y(), 336.9140625); From 530fa386b0901c9cee1f038c29f4ab6ab1a6bbb4 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Thu, 3 Aug 2017 12:38:37 -0700 Subject: [PATCH 351/364] Add emoji font and initial tests for emojis. Change-Id: Ic9f4b3ded8d747004900ce296b5fb324d5c0da3a --- engine/src/flutter/src/paragraph.h | 1 + .../flutter/tests/txt/paragraph_unittests.cc | 47 ++++++++- .../fonts/NotoColorEmoji-LICENSE.txt | 93 ++++++++++++++++++ .../third_party/fonts/NotoColorEmoji.ttf | Bin 0 -> 4742308 bytes 4 files changed, 139 insertions(+), 2 deletions(-) create mode 100644 engine/src/flutter/third_party/fonts/NotoColorEmoji-LICENSE.txt create mode 100644 engine/src/flutter/third_party/fonts/NotoColorEmoji.ttf diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 63cbb2e770..3aa6265ce6 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -159,6 +159,7 @@ class Paragraph { FRIEND_TEST(RenderTest, LongWordParagraph); FRIEND_TEST(RenderTest, KernScaleParagraph); FRIEND_TEST(RenderTest, NewlineParagraph); + FRIEND_TEST(RenderTest, EmojiParagraph); // Starting data to layout. std::vector text_; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 7a20dbb0af..a818c71514 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -779,7 +779,7 @@ TEST_F(RenderTest, ChineseParagraph) { txt::ParagraphStyle paragraph_style; paragraph_style.max_lines = 14; - paragraph_style.text_align = TextAlign::right; + paragraph_style.text_align = TextAlign::justify; auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); txt::ParagraphBuilder builder(paragraph_style, &font_collection); @@ -1337,7 +1337,6 @@ TEST_F(RenderTest, KernScaleParagraph) { EXPECT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 207.37109375f); EXPECT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 230.87109375f); EXPECT_DOUBLE_EQ(paragraph->records_[4].offset().x(), 253.36328125f); - } TEST_F(RenderTest, NewlineParagraph) { @@ -1393,7 +1392,51 @@ TEST_F(RenderTest, NewlineParagraph) { EXPECT_DOUBLE_EQ(paragraph->records_[8].offset().x(), 0); EXPECT_DOUBLE_EQ(paragraph->records_[7].offset().y(), 336.9140625); EXPECT_DOUBLE_EQ(paragraph->records_[8].offset().y(), 407.2265625); +} +TEST_F(RenderTest, EmojiParagraph) { + const char* text = + "😀😃😄😁😆😅😂🤣☺😇🙂😍😡😟😢😻👽💩👍👎🙏👌👋👄👁👦👼👨‍🚀👨‍🚒🙋‍♂️👳👨‍👨‍👧‍👧\ + 💼👡👠☂🐶🐰🐻🐼🐷🐒🐵🐔🐧🐦🐋🐟🐡🕸🐌🐴🐊🐄🐪🐘🌸🌏🔥🌟🌚🌝💦💧\ + ❄🍕🍔🍟🥝🍱🕶🎩🏈⚽🚴‍♀️🎻🎼🎹🚨🚎🚐⚓🛳🚀🚁🏪🏢🖱⏰📱💾💉📉🛏🔑🔓\ + 📁🗓📊❤💯🚫🔻♠♣🕓❗🏳🏁🏳️‍🌈🇮🇹🇱🇷🇺🇸🇬🇧🇨🇳🇧🇴"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + text_style.font_family = "Noto Color Emoji"; + text_style.font_size = 50; + text_style.decoration = TextDecoration::kUnderline; + builder.PushStyle(text_style); + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth()); + + paragraph->Paint(GetCanvas(), 0, 0); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } + ASSERT_EQ(paragraph->records_.size(), 8ull); + + EXPECT_EQ(paragraph->records_[0].line(), 0ull); + EXPECT_EQ(paragraph->records_[1].line(), 1ull); + EXPECT_EQ(paragraph->records_[2].line(), 2ull); + EXPECT_EQ(paragraph->records_[3].line(), 3ull); + EXPECT_EQ(paragraph->records_[7].line(), 7ull); + + // TODO(garyq): Add more robust tests for emojis, currently, look at the + // resulting file to check if emojis are drawn properly. + + ASSERT_TRUE(Snapshot()); } } // namespace txt diff --git a/engine/src/flutter/third_party/fonts/NotoColorEmoji-LICENSE.txt b/engine/src/flutter/third_party/fonts/NotoColorEmoji-LICENSE.txt new file mode 100644 index 0000000000..88cbb72152 --- /dev/null +++ b/engine/src/flutter/third_party/fonts/NotoColorEmoji-LICENSE.txt @@ -0,0 +1,93 @@ + +This Font Software is licensed under the SIL Open Font License, +Version 1.1. + +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font +creation efforts of academic and linguistic communities, and to +provide a free and open framework in which fonts may be shared and +improved in partnership with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply to +any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software +components as distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, +deleting, or substituting -- in part or in whole -- any of the +components of the Original Version, by changing formats or by porting +the Font Software to a new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, +modify, redistribute, and sell modified and unmodified copies of the +Font Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, in +Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the +corresponding Copyright Holder. This restriction only applies to the +primary font name as presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created using +the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. \ No newline at end of file diff --git a/engine/src/flutter/third_party/fonts/NotoColorEmoji.ttf b/engine/src/flutter/third_party/fonts/NotoColorEmoji.ttf new file mode 100644 index 0000000000000000000000000000000000000000..6067e24d469e3836a0dacc9f4410010e7bb57003 GIT binary patch literal 4742308 zcmZQzWME+6WoTevW(aV0atY}))Z5O$pg)1ZeaQu9Cm-jRVmFR5xL-+NU{LXJ4-R$e za6D+u;QnI;149stf3Ut$8B6+g1_s6m1_p+NjLFwkbQmwk^V@u7;N}2X#&Gt~m242>s`JNZ3=IExIKQ#y zFfcH1Fff5cLC#@dV9)u-!@$7#4J5+(4QvvK3B@e^AQ6sda6KTMj36-v2L?T`A{NeX zj1w4G85mfNS!XgZFv>w_=Iab;OhOC{Obl$CV09n@6bB$0jNSeH-5DGh82s zvAGo_4#U{wN5w|dI4#ova@qs2L3Y7t5F3Qi`5-ZD7^Dt_k>x;q5JnaoWsj!m(KJAL z8W_!2l!qa`(;+C%U>MnMkQj&$qCptM9!!`TZUUJB!-L6hv~&x|zqrf?$-yv44U7$< zLHwbHLGB)G7!-zs%}t~384ZEa5Eu=C(GVC7fzc2c4FN160GeN8Wnf?sVPIz9VqjqU z%D~6K!1NG2FZPe0fq_93s%aAggE9jHgBAk=g8?T4!%7AQhII@K3N{Q33Z4uMib@O& zik1uvic?q_6jw4bC`&OiC~Gh{z@R3}z@VnUz@VnY$e^aiz@VnZz@Vnb z$e?Dy#GvNDz@X;Dz@X;A&7hXRz@V1Qz@V1O$e@fJCuRJz<`0lz?Ol*XgULf(M$%$ z4=fCf9}5^6Kh`laeqv%^{3OM|_(`9E@sl|N<7Zwb#?PV*jGtu~7(XjAFn(6yVEk;x z!1%d>f$?)K1LNn(42++rF*1Ih$;9}19wX!D7v*MJC3tcbFKzK4f70`j~<7>k9_PukRTc zzkX(5{Q8T5@tXhxcfF$9D18#ps5F)%QQK{J&l0|SFND049|D9&VHV31&7P+ZBt zpty>GfkBReL0O7{L0KB&R&b`%U|?WSf@Z$+5VtG8WMEMK44TYmU{LpHGUql11_o1TCOrUJXaLHr3=FFO7#JAL85q%B&I$;Ec`S0?pjA3=9me&`b^rYd274 zXJAkRg|j;YB-4W|@q}i6P?&px3IPTNHGKvK25$xiH46p?HPBKAUj|5_;K0DZ5CAP4 zoER7w0zriY1A|&H0|P@41EjD>U|?W~gBBXe3=9nMpu&TJK`jlm*n$C4h-5G@FeE_> zlWGPA22cS5Dpcwj7#LDOg$o0N+H?j6hExVfAp?q+Y*1mtz@RpVfq@~1fkABn1B2Q^ z1_p*a1_rfN3=C?Zuq|L^su7}TyXFfi0GFsQv`U{HI-z`#()z@YYl zfkEvn0|P??1B2Rk1_res3=9ly3=C>NA(&+$1B2Qx2xjPH02g+k0*|2!TIhi)g>D80 zbyf&w=m8ak3=Ha^ywS@5DGWh%!(?coD8#_PFa=sTf)=1mg%*-x3=9m@poJwUuBSr_ zO+^LKYKtFcVaeGBBu{FfcI8Vt^E=E({C|bD#yQI|Bp5Tm}Yp9|&fc$H1WO z2f+;Up#^U!0|UbXXaO9~z`(E=R1h;TsHZS6Ff3tUPzSjQ6kp327(j(H2!kpy^$iRR zAk46efkAyg1T(A#72XUCnx+g43~Lw|v{@M#wAmqfT3ecdL0g7_fng&9q)-oFU|`q` zDcnH?Ji``fArC4Swn7SfP=U{|4O-}f+^`*7_=73{28JDwO5g)1AMIpd{BRzO85nkf zDh39|kA(~j47(W^Kh`lYegvhxy$p;W`@ooiVLt=o$B7J#A7?QzFdSfD{P>K4@#B96 z28L4%jGq`8KotrD!xLzwBE`VK@C;hHfb!0B2F6cD42+*ZdFKTK0@AE0_p8%VEoe0z`(Ya zf$_@(FlJx^**TGc@ykR82Da41LIdu2F9;`3=GW5 z42)j`7#P2%GcYh~GBAG4XJGtVz`(%l$iVoun1S(Y2?GPOGXvw-QZQy<-@w55wTyxB zYZU_nvl|1XVs2+(VD<)8&s%M1+6 zF$|1f?=Ucay~n`79M1r$^dB-XFegDP|Hljr%*oJ3zzYTj<`igS;5`Eab1Jk^@R@;u zIStx4aA9CzPG?~J<_g9P?B^L6zqx@i1N&_T#&7Om%)tJFf$^IM1LHR@1_tJ>42<8r z!I**lGXvu{A24QM-pRoD%@>RrI9M1MzxjbN0|%%9;?KbN&7XmR8Pw2dU|{^Vh=GB5 zF9YMZ#bC_9p~S%WZ3zS8x6KR;%nunDzik0y1`a(2#&00|wlXkqSTQhu+XluA93VGt zXJGtxl!1Zy3$*caiGhKInSt@!0|v%#PZ=0kxEUY~nU@Rrvd}xPgMp677Yf*pK4&tz){J- z_){H>8Cdig7=IdoF#`*THfCV_X~w|7V#vVw(;SQ$IOZ`h{G3F#`*Te#gN71W`7p~t}g0u+Xm82De9gE0fkL{MXsfq|c47Xvc`BMWG~BB<(vuo)Q? z7)+qzObmPsAy76mk~j+zo0TDjAqlF6jX{Rt7?jP<;KJ|-%I08@U{r&$Ig!|041SDu zP;qVsJH{R;n+J)_%QTJg6jYp#!GtA&!I>eSp@5;1p@<=qA)O(Ep@cz!!HB_t!H~h2 zL4m=YA)g_iA)O(IA(cUa!IL46A(=ss!H*%Ip@boyK>@5ghasP#h(UqDl_8fQpCOAO zlOc#9l_8y>lp%*9k)enoj3Jewh@qGvlOdlWk3oUKkU@{Zn8A|4n!%mHpTVEOoxz$R z4{D+=Ln_=9E2uln84MUq84MXL7_1l!7z`LJ87vtL8O#{W7)%(<7*ZJ$8O-4>0{I5w z9)xQUuFYg9W>8>AWKduzVJKoqWJm$q26AIIg91Z7LmEyWBZq?yQb-`|QvjO<@xKB? z8rZL(uq*}pJdYtA99m8cE({?I3g8f}WGGM(R)GOwvJZ+0 zpfJG}&!D(gAjxGZU_XH3CzBzGp_HKn>OM%?Nd%`LB?d=^U~nu1Gbk}AFgStvo(#bZ zAa{f_crt`Acrf@ggo495oWYSHh#`o{P1_iMCNCpK4Zw61W8j#tk44Dj&&;f;0DnkWB0Yec(Dnl_iWkK>mCPOYm0Rt$6 zK_RQhpuiB!kO~e@h)xin*l>lUB#>P&y~W_TNM^`nNCU@!0yvj}(pM=%A~;om+zE=W zB8FUWSi*81B<+J@8Kei~N|0YbX%CV!LGqxqRtCDjD(_O2IiCl$Jqh z2$EAkE`p>cM5;hfZ|G^dm?0Tl(iAY1FcdTBf%8TVgC4j9NoUY!0EN5{w3E)j!0=mz zp&2}S1u0_@BohNeLkB}@2Ll5WPiKIiJ1>_M7pSlA>ERN@z`y`n-rm3h>gg*Tw*d_i zs08?gxcX!k{wD--HLsp#U|`@W3GxeO5NLEzyZ-;fvh;uh^*==17#JA4JzX3_Dj471 zFpXw*6kvOB@b2En2Nyaj>GG-ib-Nd47rqKv`B`|yyYC0>wg;b4s@`mI=63DbH$S&? z{_%0*P;5Ez`o#+l%{m>PpN9?vid??sIP<6l8_!w8w?b3odYlgkEOjq>U!rnz#x&-m zhdE@9eVqS#3R_?GE|X;}1rI(Rchv02oP9u0`FMPvAtz7emmi-E^B9{8|16a-Z&;|a zY^lS_13UP5j(wb-P{Ys`w5!Chmh+92lfRPTTa_g#hWA#Ou$fh^Hk{qc@cn33aN7w1 z$xks4E6=F0h6&5c%Gw&{Zgk#xyyEV{CkhiJqZY~EKC;!%*Cxemrnhka-o>4J`!kaM zoO@T}BP{KEEWl&>zZ+_C{dMZDuSop%3oJWTytnF++m}Qo>IavBZ z<#wq_ibgJNJN7hu+?X)GNh3F@-=t8y#$7l)L-@1zm*&|P-_EI-)dzbCtKYwPM4?M;qJSrwLWa4ZVHAFF>Tsw&uq;5p;KBb1A1)*)G>vKW`nmT!kKOHmS+}?4&Q9E%_1W&1kb|MawJ>%}KS5LQ=Pw7V2mgRqZ`jw4kF+I<3&8>r(Hu za~&5A#Dz00*ZlN9awVp6lFL8Ws7nEXUdIKGES;g8vHFTt$)nGCDyI*ZT>Mq&vNZ6* zsk^U^O}}Rom=|IdIi_p^u0pX$D9tYkz1pD(~jNu z^X!ewyz`yo?|rb4J^udS>`m*}axE`AxSMr}1;_cM*i6g$&FYn=w^YAs+f>}?HI0>B z9ea6xr2A9bj7Yik+Nw+y;Z0nxlxGIa;mu|>J$z$E{X&)3=i;AP#%e84nySao)BCi|wbk8c^pkzH!;wT$~v8ni%Jv+Xh zRq86bvGPpoHNGllht6#EnJX$6^F&JrD!N{ZJ6v~tci~-wV4>o(Z`Do3UM0!yIuN!^9z%olBUejR-L0VF6D^}KZ6GG2Xpxpto?Y_>4WRLXbBRX5gaaS` zUuXyySo*->U6b(~1_mZ|cqZwO4HRJiP#Gibcy>YBoT$Lu*YUS`vs$I6IOb*xUQPS5 z&+o1^fAM7F;PUhOcWU3Cy?EwM@yq{@D(5|~oLZ~S7-8~BVy5VwqvhGBPd+;oyn(fJ zo5bV^c|WT!Y0qf!;XdWLdV}1}Ws}0ZpX_q9Qk^^@`yywMCCkaMOC1d}mj^MY-JN=< zcY>~3xhu!#d;8YDS^7ImP4P@kk*M>IqN0%Q0_Kx}wujalq~2PzaPol-J$IfoCyE3v zS)CZ%b@1MW^y-7#UTEaeDjk&h&3D zSu8u0FN9fbv?`h~g{@cV!sWF^EpK!}!ua*;ISt>HCZAwj{ygaC{#`NAzB)@+KYo~$ z@88wUvo&zd)}+|u(~Xt#ct6dHm}u&;GlGY^#PNj8k`L=So$8YXuD-nS`N+JD-)?yp z2vm#Czr3}nD(~C3x=rCVH@+S(FRqL37u{X!a`UZl(6*=A@5Nj%ec$STK!fS>mGeo7 zKR>t5eyddUNu=@nPVYJHeio_*)AqeuvrqG?((hFwtkG-t+x96dbzN!Rs;VB?V5_sd z`)dNX|BZN~7M(I($Ad9NC1Pj(h|S>Vl%H;O_f7sJ&6Y^tb4kCha+o=7YY|y@<9wT| z+D+r$t2fjSDfzz@PJDi_g~?3(f^<-Kiu~t4!b`$Gm=rsoI=Lvp;>MSvO`Rn?m-cqP z@hanGoyKn);8)Lk{b-yCLf$KNO(u4uxNa2biJ_N56V+^3ylPZ$^&IKe4ZD{R5h zy8jNZo;`SRje&t-IxLZ@GBG7ev^>ne>}K;=-NA^p^9AdK#S(jlPe^yGEYTtC6>Rdf9g|1e~8b3FW5?f^*gp3{9`~QN& zgy?%qQy3T+r@;crv`WTNgyn&e@#e+8Z;$xQocWS1?bs2KnKN&u^5qsP9V_uyy;gEQ z>(}ozFP**r8Lsm1t2G)PlQ6FTdv30^`59OFIeX6f-M{V-cJ>5gN7$v!ypyDkt!Yb8 zd~7G{o+cde!fun)_xY{+o=&(Z_U#+v%{gh4xJnIvt7vDdyFlN>{`nJhKZi$b)vr<448Iby;#|9ab*f4I@5J1FFBcb{ zf0(}FnDM07?R_;8KV@I`FP*u^|6haE>6?#t-dn4~C{r06ZF zzSsWotI44UB$9g!5Bp2E&HuY^nxG6fwlp%Gm^4C3iLc;LIr~7g!G;h21s+^D>dCCg zz`(=@ODE2^WgJCV9|+&xmV0~K&d%Io>Gw&|wTt48ZJYe`$#Is&uhN&L73Lp}-@7_) zZqe1;ih0i~|8M&w%jP@lLZzzAnwv*=Bvf-Otx=x2ZNE+kmw)<^%22O|*Hf<8op{=B zcv#M3s>C^;>qnSxoyuuf2%aGp?%biX?5wzl$il0YH!oetQ)BrgyY#A|N6CN5$C@s? zKcx38Uz^p-zkU7v&STCVBB^&$7&1<7@t&X|D1W~1$ac%~&lN7sd6KS@6Q;+{<(4;r z$!90SM4|O(FP>k{d+^waB0qD*s=NPZO}Lv@dd17&snQiLqo+Jq&ZPbnjA~5{pFOv- zX`Rz*(Yw#L3cj>a{VcIir%Y_(yTyqi@!tjh&igMZd+_`Vj*K&ZBo%`fq*nfu30H6F zb6%PvlX}GTh0bry=xv9xrJg6OIQ@Bn&J?a4{l`PD=WVa;y#DUFdenTD0PP>feu;@s z&s;kZxU_%j7TGgf+UJP1+<9av!CInt`DCGowkD6EFMF>F+aJpIH-<^LhE^*XA8B*DaMOo~3E6Rkkq0q-?rty{6@yqy7@-A|iKY zgp0q6wdCJX{P&KjOD}`{;;;TYHeJYB@VeuV7y|>NC^Su8+v>*>D01wh_G;B@kAoiiJLF|- zbbe8w@sa&N)}H6SA5Wir=kxXHYPIL_YyVBkPfeSX8aXXBRL_1+aRv9J+Xp9VGhGs3 zx|F04&T@pCG1G8@Ig^kuBd3$YJq`~a78MRgOBDq}!3hd1PbM@RadDXC=95E}BO3x$SupR=7lU=Vd;YxMrnYX~OPJ>ly|3+T5DaIB`Y^Z_kTa&HWA(63F}Z0N|DH0NC5#0Rmfjuw10 z?{PU$oh;?q@ZF%t<+zUupWM%?o9@dzU$A9Z`NhjWJt4z+^xoEYt&7-yKk$_P(NVQa z;@vZ^wj)s*Rde{ReG(MC$?e*I`MIvrC+0jpPd-D9x()v`1UnCVwm;c2O=`Ju%!Uq? z2aje;#GH3N`L@sX$+Fu|ZC2HPFZ$b8{$Bord8*bVznZBc)sDAxUa?0=n+7pn+u|)` z#eGYS^Da~FvZHIPPMZm_=5BLMu@as6+4}QKf$vZ9KX7H;a@GpcKB%rDEB4BEqFwm) zw(Dh{GtA58@l<@u);C!CTgW{7%(R+Wo$j+VA1s#@eac>4+H7wVc>d*OHqkex6&B`+ z9}4DO{v9dW?D#}^Z&#>c-L6OK>+Fw~KfhAn`L1>I)#*lgCz1sEu6lK??sl9Rwyb_x zp?*a0DLD`OyCxIoetmuY@MoLzv%gfCuV7#}Cj2Jbd1ee~y#RWjoM|aBsfVJ9XZL@B zmJ6l@9~LA8JlHim+?0WVNd}UN-rg{s9^xp#`XEaDj^ZKR=JM;J>PPP0y?a;j;BhCD zd z!WHh-?7P;51 z);lU@l3U;B>~HG(Q+we=fCYQ|-dguXGur>~89Qq_7UusjQ*_$RbX2uuedh99#|P6@ z*DW~koYi~g>>i`LONw2V{OS6|9{6ORutEMA*QmSFy@}71`0pB5-kr6fb9uScT35BI zbuPZwUf%h3#JPLx3F-46gt8}kY8ky$+PC>a-r3A}K?(i^+dVdKJ)v@brBBboCFSX> zHhP%H&$luB<~dcrabE=U(a8>1pWVJS@tvk!(|@%Y`ipDkdDuVq{5G{uqWI2s`>FBw zR`$$QX?y!K|H~uR$1B}WO?-G=cJ7M4n?iM_c?LES^^K?hu#~p!3k}+JaQ(bGyYRej z*X=yE0#8{?KJ9h>>0x2k8Csq`yEw_*mYG*~a?6EW*(v#xTY|P4^tQM<&9*F8sgvBe zXM0QcB8@JkpPU}@!TUY0X0O0f)-e_mlUm7dN;?Py{QuCf;8yy!2^nHmp!F1Qpegl= zY86YOK+8iu<7VF9EAAxJ%#h3zn2;!YEm8Jbs@_dy=D=XkY~C}OvqDIPB>IgIItkf zKw!g%|2G**mxnPhFoi%v{|0lvYM=n?1F72&Z*6z5lQ9Cot*ZqqzlPhkdydRcu>l*ZlkW>+N$9 zpIaZUB`2&@Y|%5=Gh1INI?+nMC7@zTZ(@b(6^{~?nHkUiw4J|Nw`})9ZIv#S*_{@v zvs@;cy!doPfR#B=MReD6uS=#sl$It*J=l9fAhkd#z9lz(+jph)QxZB&#h%Mt$dItv zlhFOmdX<=G(!RERS6kbKZttBxB1=WPv! zO~t46&tCo$vHD7u{(IM~zqvsqHp`ZMTachtr2TCRu@C=WT4}PB|8%;+Tdu2Az(C{6lGvw(uJh*H#ZK? zmU9$f`%s?ydiT+t$ISdUzTLAi_x7G+X8MNu8~@F-5dCuIvybo5+xu^?+O~Vuu4Vfh zzhD1gbN=(BtP-V@H+{D&uY2SB_s7j0RUPW94fh*9sazv5_vhS;zZXusJH!43>sBtS zT~3-a*KKUQka>pT@xn=m98U9c3o0+1a55p;bnfpq#bwI7&hZ#pUduZcr|)$~-Sx|} z^AE(6?XEq35cAV5)@5thwLnpM*+~k)Uo<5(60drmEY_Z-c|T~5^z!X;pEj?UJ4rc` z=fu}sm&sxQ=Y4W_%RW_qyl-ycpEc}@G@q+4ZqhPy5=3R*Zq@{w)<*=|j|6b6~z-0B#%b%XTdOmTnkNqOqTz0&{2lzPase`t5DGx4kZPhuGfU7Fe;Zw{oid<{h(Vewpj1 zULF)&w|v9FCqDNtr%SDVdL;UPiF8=!!ruK?xLRJ{mrPK)__Lcy!)fb*CRy*dMQdg; zvUJYdrlDl6p#4l{YvGiA2OiuEN_DMnXne9k&v%xI?6T&@8`52c5;7;}#?RWBw^Ulk zYop60nUl@ls;_QW&2n{}zU$>>;rJbwy=+gO-zdd$Eamq*D~_Hs#~)ri8YtnuX4SuM z{WeWK0^wVq?X%a6c(gP1XULJ;v-dxkvg1LZUf+tEw7AXPQv4I|9*^?-qxETy`n5?m zb{%idRz5n>qZK&Qov-u{`4&?Vog_UuBAjqNJn0 zt z$ulIZRDI2S;diwR>%QstAFbJHlqpidGvSc_G}TVedCxww{ST={m$kQx z-p{&fy5E{%m6*n>qce+sPVh>a8Fl|^YnM@%QETM!?Gf5XH;VLUZz*o`HI1G0O4pz> z&{P0`zD(?LGiPj-JC@6$6Rc?5~ncaMavy~%=1mkjq}l=m(#l> zxR*R&`uK=BXR?CQ!|6gfQ(8Z9AN1&!;1_Y=6%^84f0Rqb(RruXjSadpj?Z(PxG>GXwHp0mHVaIV`FZ})`jbxZcS`k*LW%8quxA+ ziw4QbCpiE1rzhGxSRWVmq2ryLrEdQ;*)HZ{bl9UUjMU zJKOjy{!&__g#3o3@|C#{=hDre_^sI?y5^vgKrf z(I-7siyvPKT|DLO4y{@2CNaHv-^GFnoWbR02B|_f=h{xRjM%>PfYsTy-zF^5UI%KP zi!^9ze&umo$?%G4508Vn!#kCK%#utTN)EFal>{fOZYW?=u~ATCiY$J}tUbSK=ZiI; z%LNqY?PmG#oaLXIBA@ix1ow5y_M4Km)XJ_fW??DcSOsZbzIhciFMySAJH7OH7#LVO zAmv-q0qz!`Lzfy9u0~F5^f|zhuvKP;3TKl>O!k~ymh+(YXm0VnMat*4W)0hVKkeD+b#KjHJGQt@4gEOzs$fs|??T)FU?yd9{`$b%I zHlA7Pz2x_Q%uVm@*r0laZ_4xV0Bl;U# z|5C9-K0*6z+-AIY?3;9Dv%%)_Q}T1)@r!y0&)po5y>0`$>N?i4m?T?<*K>t5A{i8( zd|y6~=>V5%5G#Y(Pcf&n9K0KYDirUA@+{dD6k+mHOU>>l>y%@kr+>@bu{~D9#cs|K z?up)-t1Z?qz9avvsLK44#?pwwXVw>|w6L!}y^HDAX<1E%BIWtZ4|h+vnOzb7V{cKE z`gxTzLDTa?7w(o`owI?Z`nxN8;DcA{uKl4C9l4@Q_I?_ zPNr?YA{olGJP(EKwQHz-vva0gcgpr6kMv8)DxxYYvZu{Y?rFItta5bU{;96^qN+P} zF4Z3M*j3zl$A6XKl`dFGxeu8m{m0w#g|i(ZAfi!m61*P9LW% z{ard=!}IH;l)xvMI*E}ZBnSHNUz5d4aq5Z>&2M!diA}Qo2r3)D+n- zojNc1d9A%!w_I1{oFv40VZ-K`-%fpF-`6=Qr*7-TQ}4FT?|QkYC7$)%McZ%OjT)6a zP4Az^MH|IT*b~J+TcG}_if6g}$v5|A?K27ecW#E3=bp%U94B|Pczj#M;!&pJbZL%f zOUKdgx^jl`W|q?Xavmp7|MU3pI$nVeCW!_mS<%M^=j0oB*Ew2$JHWOel~wJ~+qp{) zH9tMRBKpES<{6HCPBr`q6Pg5mPiRu`QoN(>6?anMoWQAMkt_p=69TVtBpVb|BHRqt z9}zsOeLG{P`ssE5-K4Kxc&*TUjbrt~=NW-@ZOPHbQBNiW?^wD=s>tb%)_gz{*DkM}6W{CoJqd z-Far?xug73Z*o40c%F0On?>sP{hGX7VN4NQ`I#6J8Q7Y{4EoZ(E!!hj5lCm6m&FZ>J$jCwD{aop71E5p|io1aRbvU(HA^Fss#kj z>oNYD^B`a7--g1Rc@sLN4ZYnNZ0d?#o_xD84NJ+$^q82E5jF@+u-PYKqz&5409kJ( zRM7a};lqLDQ3kgpYCg6xFfb)SO2jueOoLeh1y~*wA60ZOHaUJbHmS(Oz1YOP_zSyG ztnIR{d-FCQjB7WJj^7e%zFkp%+OBu!Ulw(TZOq_vxz*FtAcd>9yHiX(sCGwKO;b$B#m|c^kmYkQG$#Qmyhf@g4 zmxnVIJb5?e_VP5@1*oiYv|2Nfu^>BGMd@DNg?6>3Bc>UlbnJR}e`lMX!X=KAc>%6>G#f6K&tP2DSMH;7jE7U4!$Zu$_%M&syEKm*Jbpho z{_2HvW*QW3=Uig)CqSfl5#JL5+f}n&^S=A`%n0o6{UUMKOEFF4%IwBH51*>4@aP*q zo+TfAP@-sgjZ{*H&)E$Z3zuacelRn0(ceFO>RDY!O;;N=a#bGh4Pc*ps4?%%Cl`j5 zEv{urN}Q^*wbu!L;8fwU@KM-3`+U!8n=nP2uy%%v8=iE9-Q0M{>*iV>mj=m%rIL&i z2d}bCdy%5RwZYHKY+kEx($b9^QyC5?urXX?*t1Q!mKU^54SmR(`ClgyYYSmRQ3TUE zL;*@K$3Y;W;Q(lfVSwg@f;~$e8yFavOCf3g?M&C%!QLXS{(qism40`Qqg|2DSw?Ng z*4-h|1?Bsl@7%q6H?is8jBh76pT7&)y)N@r^!A$Y&=ry$ot;ao1kFtYLpS}r;JQls zns?`^^WXM|u;;02`Ta5#iag-;R>3|o|BAhc>*NMk!%rvN|GTJ8(2rb`HtBctRF6RU zgGoxB0cme8OzR1J=EI?Sa@y;I8iy7?o_Z&2LT!`~vv-%1hu4ZpySYC1Ha&Iy#ef!C)3bcGC_8nPf&{~_qIp4jL%Xp4N z`B6FPs`IM9i-)a~@a(JnzG{|k=5^Cgmt61d zX}Q?*Y;_{vPfqSTuRe7?d@$+2KfOOEyyo%F`4J_wJ&0Ag^WZeqA1D7u&p0LTH^-p3 zGj`gAJsFQaNJ{joa5(!1Idr^SCbaF^r`H-AO%}7LRLv_pF616RNu!5h+5=`6y9pHy z&ArK*h1(W|7)8H7s^GrxiO%htuhcfGeX22<`h=lV+VxlTyhY14Ffb(csF+P?aA493 za&r8WGLuECi7#gERu#66q}Y=Vt?FgzJ7@K5aJeJ3>vV9)6B&!#jWVo4))wk7z1FZz zcS-g%@#J~b7qhT~*|Q}s^zdt?oyTQgYqmU@6*6({nZOF&D?-;-cx0XU$XqQrTRDJ9 ztLym|+2=p~mkP80KPAgDia4<7;eB!Jv}=@PcBe%oXVkEG!DQtRyd=RZUblY^s{z$#Bw2;iU2j z+5Z<=J#1Ju9=md3ZiC8flT0zs_9as8QzN+@d zOy0B0bI#Z44=S0~t?@qCbCzi`@1418ADADje-U}OAz#1l&WpFN<>V48cRp`a-6!*| zZ^Z(|eX}2kFV23pUT~$wL!paHziu<)@u{S^ZPqaq~dzq#pXbTmMq z^`VMpasvA%#t6pPzpHxQFjn!*sdCHboEhmfjgyyQ$K8fvu@6`0%iRmvR~6W`%_jKn zy11!_*522gE0X{AScb}mvlSgL0-vr{H8^}^qL~oWmp+{qrw#J9olF)*DW)P#8CVGLAJnAV^nB;f5J!r76kp!{db`H70mlBo*6k_CQRp2)1@gsxEntw#bc zR)R1x*fxDko;SVSzozKE-;d@6H}p6wJ0$$L^gb~Z{{Asn*Xlv#k$_F@9ZHNFSzIPI zLuOgBCHv{#+~0&ak>PogyTI9v)@{})6@5N!&h<-fJjv)g9`Ski zgqzn*+2>mq&Rvte+W-3X(${3BE?V%rOrIzip zm#y$Fj*OXq)qcnK+CwJ3ml~c__U!F>z5V}WpODi{OJtK@|DJj#z+k(&W>Us#-O4#K zkBd|nbDdK^=@V_VEWy@HeZ|d5QImW^H{6}}#&6Q$c`W4$8cUnz{`Cse%urHuJUuPL zKKYU7yw#7Glajowgqjb{SRto;{C{ni=1#%wJ}Z*Kw{8;^&0f7W#dhJ6V>1GnmL+~Z z7-^`{!|DHRziLHh=@FF=s=jN^PRY5p-f^P-#5&GX9SgpysvG7{N}a~yIP;Gi1_IJVkyI`y6Jc3NQ8@x<`F&~vLvpI?Z#J=t)g>d27^YlK!V zjNiZ-HR*25OijmtQ;sUK6V-mZE;&Cfqh4{->B%ku`;VNRE$iu3x#xoR$EN#HlV+^F zam#w+)vFs+Z;C2ryS=!@?76J_&g+OtTX9f(Smsc(EcTJ9m!H%iDdv5-oW}ENjRo8vaf!jo7Mdohb zlT+?J3EcKXvyH{yWv=~6(I}xUYx&o)L`Oalu2`m=D0eI4b!c7IG?u%`=FT^!v#{rC z&9i&w!RKt$8vnen#l5bo%j#8+^2@jlDq_uE=N`##*xt6p*|YQC@35CmXMBVLKGmOS z{V{bRujhe}pJk#K>8)3j5BA8K_xxnd_thyWuG9Z8r>RXonPPO`&76T@MbF>WvWaIv z`-m~}%P(T`3v7)%{+xm=J8gzdEdv7sWR1LmOM1hC0|F2JPq?t*gM#mehy@G`%(;+! zvt%0c8QDOA*5%+44eeFAxBKdnvy@kfnyol=%Pe{Ijq7(K=UVf}&zW6bmiBIDvApET zz}4SxNE$Euo)6C@0T!t7glI z71?@Bpv@*mq}gqeR_u)v%w0`xZxWBi-#Ap8-4fSwF>Wr zB3nZ*aZI``w=&~L=$nsa>PJ{|e-%|rvYb$kzqnd9Pw$D0>^M=yhg0lXQRS(vOb{zQ_9i%DM`C-b0u=$M6ho9b%mx){Gp;(ll5Wi%~=7id> zPD`ddFnWHZ^+C{|b8$!iSNH~g>i)mcc+2b+_utAS{(aKI9rx?mo_Pi)d;W?z`TaXn zAK6g$BqyNay^?`r#e`?2QX3K+w^^|8y!#lPH$~a?hSE%yACtd^EeM=&wdY#PnvUv6 z{*57Aml|$XOnE1NvUI~Ohb0?$j*6-#Dh4o|Yw7ysq-xJ|_E3%?r`spB{AzZm&(9_6 zKJ2TMp3Cqi>-F+O3DbXlmYk*^U;iw(o5y>{3ES&?4XhK6#T5H*Gq{n^%a@ldBJlp` zk*e=+%^8ZXo_H+xEA!;^87E#YnQg1^!SCu82K`wv9#7i7KeQM6asHU>&c|~e6qQWm zGitx1U|2Gdt0+w3%}Tu>hn`9DZ&vC}3jel)p(81F$$~Edj$sOJ6Jw0dvfaq;^6=Z3 z!#<^Vl}DiAafX}-*A|rz!eSc_8yee9yy@p~&d*2XbALwqi4}@d+&@0>+<4`5Lqpix z8(dBj4T&$R%}??ko^^)H;rX-hMeeCd(VTrvj{>;*j=x)=x31^GC$4oD-#NK&VMtlT z>cpoYTqLlaVdjq32ks|W>|Fw!)S8rdgpCphsbnHMqy93JZ&dr;vN!Cuz?~0e*f$>>+{|o%Eh9=u%K%UmD=P z!7C?|c~{2`#bsYCUnp_-bu8!j#j$HQzJ&TC}PC+z~#=QHJp8FQ-m*u?zFl0&}YjD;ft{c;(HFh`u|amYooHSOZoox zdO@dafA>nXB&we|`bX}cKga2eCrS_X)&KPNJ`oK5btm2W8)*OGVS^H>5Bg$)>kGVe z-dxYQkkh;^p7+7s1ks#nm+n4(eNlYtd>;F_I=8lqjrXFwzUnrTogBhQhK58eeNs~_;*b6l)^Y>`U=39JZ@=zgWJx#UpOwKM|)_*VNa0*z+d7dHrtDE3akBYmBeP zehFUg9XGM=RQqY|Jvp^I&b)ZN0NO9qyL4jsTE-qU<%+l%2&0b zXu`SPvO4388%&;d3@i;=Y_k~lF-~Cd;C^r`*-ntpp_YM@xkNx9*kNL2r2CeIf-_u} zO0D$%^6B@h@+Ef~|Ab2(Vi%mBR-^K1XV(5-Kg$m(8%|6)E8v>Ix>DTb`QKOk@{j(i zIP?o2@L}RHJ5Z9s6GGIJTObU^MF2O~v`_b6p3l@S}9+1wCfW`m! zXBN~e#IKQGb(n#H5jvUs_KJCscA|jm!+0s_eX=$-Pizmh?2y^dxN}bDi7m``nm)$t zc|CdMuQd-=uiG_uk)}@9B8@I9^>VUo$n}TSRe@mFGJ?-??)t`LArh zZpnY;*6TU!yS81o!ZwGzgZloyiVs> zc*fqDLsgh1pvaM7sQ^oWmm|Ycp(n;(#y{^evHtAY^z}3=*C)=UGd=rU1doKycXknM z31U$cab$26a1vw*fHEBfSpo!HL>K~@83IdZJzAvEwMb(ZYv2pM=^xy-fhN!~;`1^w z@d@j{qQxN^cd6{Vy$lQtkR{a$76Nf~8_xWn`(D^PFNcAFF$|L1lO!f4i1aiC8gRKC z)R16xVw*B+fl%1Rg$|vJJ*zH1(t7!mpma_IK{OR~8?qls(d1dn9;O1=sJ*Q;q~b>s;>hNb}A4Ah(Yq-_kYr9tqyH z^6u7K@^5$kz1Vw4e!@{L_Jz#sioA*Saz=#$vn)A!WmTeH}b1jYftOSWfvkGNmq2XuMP|pkd42c&SuC<2WDF(zgl$ zQ8$;xmuo8otjY;ZW@R}w?e}lqR7NJ%mHv!D_8Q$2W|``+bhS8a6wnZ2I_k8*gF}S7 zQAsfXEI3g>V>_SIZ_TM*OM_N^nOwy%U1!o&_Kj=8K$#V710Ulxn#Jw=x&Pzp1kP+Y z?vu2bfq^j+61Q(IZ!bLJz~CHsqEKWL^G>EGpWix&rOz-Cn(~5fN7E zVl~ugI@f}m<*)%%~wrnrZ zX!;<>=PJ3iefX=Ni>o7BjRw zW@w3JIJA;8P|am4BL_dT03RcVH^ZUn3@z!eo!2n$KR#uj(G;mtg~hv;Ynm1*G)G+x z;VM#K;+X2QOocs(O(2a=#k?Wl$VpCx9vP232F-xvEh`%ne>B3f#^MAK1_r%7t6%O} zS#u9t^j@V=^a?1Pd2jJQu5RvzEjJ|dKzGwYqxb6e%EJy4&50WAm*NhHiWl5)SQA>v zz<%ekU+{*qqos2%Xfe-yH~YcfAB)R^LD9RmjD7#b%VK5U@BEk`zAwL)W9LW3FB(l9 zNlq>w6;R@rTkvQ@jNi?-jWJ#`r`k^N*5rQo&Do{$fTeCEpYxB-%~8Qq_6pQJT%(p! zs5m27guSV4k%d5s$kE0H%Qg5|m|Y7MDi&(+vFN%MDlE|AOL1FutwF~l)nS9mRK|l= z3he%_GnFbCsjU6&~?4NIWo@3F5f19)T z7wG(78nI0)VA}sl;ZuwzFrGQV$#&*XI|th)MjHtYhBXfo76=%y8TPn9%e}=3B0WqD zW+mS^+vF?bvBWOZJz`>)lKF*%{Sz9T{uc$z|9YU=qvtiLO}x7prF zX<|lrtj~PKVD*Oii5`(5yYspgl9ptrb0}T=%E=|@V=v^g=5wPHi*c@q(u_Ri{u^By zP2Kl2Tnc8ou}GULy>w7)Qa4q);ikMPM0paQh*AZcjGbTUEW4BwFJ4t$?`hr<4N|3OUJm-PmN)fvZRQ0;{+SrV4dm zh@KqXq@P`5I+682m}?IEzcU*8jQjkWI`iL{CiB#s{n&1PAWSKu$<2GWekRX(h6k&! zci4o@_->%n`RBIaPn(J7BM#nD3@enr``4wQCeS^B_3w<`d%oSMV{R}ylfM0bTgsBo z^E-nJyZWY7&S~(KQd_p$Ukn6D6WchotDCZ-=?y&-0HGo7f-j^GWOe zle(cjyZU&A-=yz3_TAeXet3$pGF)PeGhw`QZ{hYFh5ysveiPeJp+Ds&hgklurSJDL zc5m(K=dEQ9j0(`7vQEx|S)*_6+lZ~EDJKekoiD2DPt7ds7F>8vwsEG^#A#o-1go_L zW@`4|m_5m7svFBZFXeA?+Mz{WicIHClrH!y2VGO2zv$l5_*%j-lfzcy^i{3bEU zoa~WVhscIm`vnUA-}qplP@~el7HKv24CeK+jv~j;e_fj^?f6mRnwi|FQR6Z+uU~R&HvBMS^51tW8KO6G`=!THMM8_su%Y!*>dVg)uEL3DOZa`d|PhB zl+9!Gm=tl0L1$*g{H2rRPS0FA=}D!S_XcJVs=Br*rl{xXq_;ZLzgWC?G@A2tl1lXi zp05fo3-33lm{(7DaWB&QYSW}ifB$ajxnfatr#0d5zvn3@!{51_UgOKcnE7nChQ>wB zlPN_?moFMlyHjz#t3cjz(-hI^CnoA>N0|w-iQbQLdQi-3Hc`7$wbJLDPw1rDCq7HP zoCW^8kUlAUb;7$z#Pz+>(%w6Rk5tEnGf@-+$wLNyPhKZ0Dc3 zOIY-;<-b*74SlnHeu}QU_=}BeFK+yOD6e1MYt_&8XMQ_0gAPsi6x_&hzGqrX@=1?! zRZGTu!JpM`q&Uu-a;xz`U6Gi_q1qpPmKqJ8GH$w5r0-@_dFC*Grf7F#OZuV7seGp! zkBF>LFW<7pz|-N;(mNA_&wmx#(D>$|UyEt&S)tO_AI6`2Joo#mao#^tDdHF!>dAiU zg6O+6ZKk&?Q{QhE{qAwxecR%w4~aZXwI4pF&ar*395CxG$L~pPFLT^Cn_URn<`nO2 zn{|^Z_`2VXh@Q{Ni4#xQoZNI=^}Wl-S9=~biQ1~q+g_g~b+)C7ZHr){nf#hv`LT6T zf%_-<{XhLWApP(IxopLa9L&%9Vu~g|nKZ45{iM$%@4N{tTQyIr{`Sz@>Ed)nuDd~c zYfMq+lSyflCd+u&OBfm&-e(APIeJZT(y?P$QaGy=t`yDzI)vuA`9;uan+eb!Q)^6+ zwW&#KOi*h~P;rn~q^pCorMbSozLk|#Qc}|N>C^M`^Y`uB_w?!0|NsAg`t<4a>C-he zH5)f>T(V?|J{W|ChJtAX;o;$No2fV`a>#1>fe|MCaN zjOO|8YaAIESbQM0!JBiej0YHam^TFPzPtZ{vGLu?tKu@NHRC?DXgj$BNS&=Xw;<&e}|wb2U-Jrg(KuSBi%} z&-?#VwjZe9^IEk>cTs+IqD6%JrZowM4c~b)_Eu{jjXL4hmcMIWv5HBZ^3k{x+ZXIu zD12|Bbd1{3s1x(2d`RBMxBQvP&S}$x>Thyc#&hu4K9A`3xf2m7QYcjVKo=9RN7ea?GUYl8U~<}3SqO7alxu2tRAMR5ItJ@YxKlK%bD6 z)<*6AbDMnE`&U16eLG=>jMxu@jM&;+tKOyOp6c20Wyb_PA&yMXd8h8$r|F&xELKsP z<`U>#=X`3(viBTD!EV!6-EvO9Dwn&VV9`h0@S>ubJv;1rn`2+Ez4d9@J;AewQVS+A ztP^~8<=XwwiISD48|wBs@E7NtYZp!mmY00U+ZeXaF_lmLNB4>w1$x!BH>Wz>&OXbS z=6df=*|`bHawT&uKMAioq$Hf*FaCWae%y=G-Y;s+aQ^*^ z=u;9Y=VeZ;n|p@2e^L1JTfYw6eXuwG_!sdF>5G>6aqPKuMXmMp{%M!BLb!K|e~Y$A zY!6yEb5-jU^M5BV>pi`+T3BgntsCE&M5QM^Z>Bb`nCkR=>n+DNuHrK;aT^$&J$xl4 zH<{d%m2%sn%UXQqMcv*o4&4uS4}VR4k$h1`ko9&PNBer0`~{if(_19k*=9<74xAL4 zQM7s8yIaSfritole6-cuci&FMM4v z=T?L6!*J;Ux7%zB3^%#olvp_7#^M~&i#E3x=gcddv%$S`&H={La&H;A-TkVkxckW* zdV7-p;jN7=wJGn8vzy8*F?x15_Ewds-c#^mT;HqZ7QXDT&4UXn2{Y2|?}g+P2b$j7 zBL8EV&(2qD`@Sg`-1&dM?A;9p1qF^p89WRx_6Kz^@D$ibi2A(QzxUBK{STfZALQK| z7xw;|D91W4O~~-d^*;qIUYQL$I8Ll>VBq!mRI_BkX5RQj>6z!u>Kb%T%bL#r_F<#& zgnCVdbrFp_Lf8uvluo!$7E9uDEz;->$`T7q`^*XC;1l`TFPAudOjbC%13jFs*-fRZ(k9(2EE6zFd6psCnh{ z**mXCcHc~%^k(g`yM=Q;9K8Hge;Vj`X-RNFDUg2Pzw3vF2NyI!MI;zc`2YX^^80pW zsSFG(Y>-0o?HtZai!FHES_N6=^r}`rI&kOzq{H!} z?2Mdw!{v$Zq#}k(M{YMWKg<+bD${XA--?^>SX0dj3kk`e2N-|Gvk0BEl(77nU?I`= zY@>?h&%|Ipr>v90(!~r(A34@9TBBH6w=*bF_i8PlQktF;r_!dGjU5mBw)UM66Z8~u z<$AZF<3w0si(1mo#TNuM1qFjdByH0ENV|#lcUdRR@;W2Cwe7?t>oSw6bE8~ue;1Y0 zP^spf=p66X@VEMcfMt=p%Y|*4Tg`mkE}vA57A^Yf(vtexZ8PVA$t?bY+#N1foJ^2ldimI zQem0gI5)ddze9&J$ot!eCJsxXImMPbX%V`XexFu&OMcSY@L=WFt#+$e+)n)UJ;Ka? zrogCvg?iaIvZid35o|sDW#*?eZGBf|e+?aO z$xHcheQ)Ga+M0wrPaSx|kl~d*Sm z*3>?j=PF|3ZZDTVt+gc6^TSh(C7bq#a^9GAqok#6N!Kq+e}me-u4C$EsST6YSNu3r z_j=z#b4Qye2E{w~Jq`1$IpT8ralm(}cf$KaUOCxXO`9M6)XU^vVg8c2VWypzp1bE3 zm*3CS_gCAQ6s#fl^=j{8LE)`_W|gxv!`4clUOSD^B6{xu8F{&K^Lg8*si}rrU!FR( zqUX7mFPC)hDLv_Bd2{8>B|}qKHYZoMmX_{|QL$h99AiTrK`^<*vCq6gH`_+r%2rwB3>?wf*0W!b_b# zPt`8{YZ0we&sQ-re}3VHiq_#7*L_PNnF@ek{%<-);r3}~iP14yA`0DXN?hB8Uk58HD9dYEVs_wDt1bbMvP!$eJ)Cvu|47)OjiGeT^$OoxFYT?u*xb zn|96Gb?EA&r&~{7Ty)_0>SJg2Ub^=G|Nr-&K3C3KRIzZ?_n$vE?LE-9WJPsX-@W_y zt0qjXnl@+OzI}7&&8u$j+^~7`r7KsTz58(N*s+DnS9ElC*3>slojUc|^XDn;ePO?{ zE;BGN=z`0?hFkyttkMhs7kmVW_b2wbMKCZh^FzzT>DQwk8wj{@K5kL^E^;#A&6jO^ z{(pX}GVRI4jV~X(sViPrv#u!5#6HH5=db|`eL4L=s!l%NA}gh5-9q)eI|BR~f2Z;+ zwBN(X*=V;@Hpb(`-M_xdEYginwz#OJ+~D9` zHftu!3`tHAhcuNifvAsx%i37D*V-hsPvx*)({dy6X<+*ubEjp~?g)P3_IF)A<%#&S zOH&t!xu$$fJ8?<$Q}O9{tG>6Mh;vTTUj4m=<;nA`$i+E5ImH4qCsr~poGNJ^ zDoS(x>!DgHy-{gXn8C8?rVAfMM+S1<-={oxy6OK{j-P*QDmw9BWYX5Q6mO3Ef}8Xd z3Y||p_$42G|481ONqfG9`Yl~iZh2c&!OX2sb>iMN<&|zv&);i4acZG5i=24+H};#V z%OgYkbhbQc*tGgdz=9L3f{9C9KCXJN%+-I-UM$Hy`;JI_eY)n<34barodsu`-Q;K} zSa$SayZQWlPY_yP(rOdmZx_!x`P)lZlz=Yu|5u)ZOan@4g8i zRwmWz1YBEJGwY`#qe@g6JHtk^O>a0D*RRls@6fU9XZP@Q5tS<4x!AnrU%+>jlqZh) zcPi=X; z@jL(3H@@cG?~8PES=imv2WGac!{o zSC?z`^*8QtH#A&vY;)DayAL8mGE7fbh?)1kKiaw>?L*cXqkZXrIQ~0b476mtV)NhR z+4G<6Cc-sdSH$KEO??u)Na^>VA0f8(cA{#>%sY4tFaP-Q{H6P}M9u3)n~w1MFV_1p zWd(0l%^!~JiI-XC3z?qp_iz0%WyJ}XpWiFC>Hf>?Sn=x0Pr1aaxt3$AC(F%j9 zlOCDxE?&2u<#!N^*M+z3KNRaak0$&_If-ORy5fh>0Eu8pJ z{r^ss%>jjF69jVXAKzwRU`&NX>YFQDOIZvVTmzlixqm*9&b&9tET${8X;uWs)z+2F zi@i!%|Id-1u~wY#4&y=B*XyrjZH-!c&0+qoH!&@9ZAxv=>K%$yI`T-## zq|%(&mI&2Dle-NrczEa?ic|90++8q@W8)4Ef1!oz^@Jw5+}O!+Sx2x>&q+t<;X&6I zt6iL)E4@)UWU`aPy>r6}y+h3|5uxIob6q5Ma9maq{HAwE$-8B9_l8wMiI0?cOoS$N zZ*Vj_EA_GaDYF3ES7w2-`~5X{o*((t>ikD=vhJ_T{~n7k*ezP~bXm#odwsGYj0^`9 zINsjBCG`JEvw$?mIc1A04^kVRv)F^bOK|w*osq?QmER}D6jV-#L(=NKJKG+=nAN4?CnZSgb z?|h>e7#P!_(S2rnE{marOQJ5vowr6Y!lySe?c|a;ZKpA9eS-D`{RY+;HR1UBRS6A@ zB3=4_&TbFiKkjogNxHKXS)d= z(H|zLd8+tToJew0GOzGB;qiolzmv7ICPB$oC{k6}(oLyblE2bTN%66wy@!gJP0B=* zOOF*5l_w_KEYbCNBFWz=EcElBi`>K$N;6L|3UNyE|8!EyJ?K13WunDH#cs(?n@1qk z%r+|PCY}&iyQDl(ZRQC>p~y28CyYU=BNZp^IOZ(oscb7JWVA`!W{K_(PL*$eWGkO+ zm))(wAisrcrZt>*j_0vZ)no%`EX^rlFBG%{Mn zA{)V-T-0;d>Dc+`fc&<-y5@`rT||XvdDJjF3b{lHtaCi`y|sCzod;*~D}^ARx%~o8 z9Ev=~%OBKxto&bzCBB(#Xcym60uQSGD}2~sb9CnP>d$n@qU9rh zdAn4*(E5+ePqs_m+3GS~Z2d>6^&dYc>Yw{{Wb$*a|7mWjU9To_iN=?1e)RgQ_O6n> z^-dd8nWVekvPgvFTt6Vd%fp~kWXqtl`2d51((=c)e3sJh=WaZ}(0!-vyNT-*E)Q89 zgYG{poQF>pNB+o~&-!e_=?_!;nWvdZMNIHaa8zq#oyjVeA`~$}Gl9u6vSI%vEsX@G zO0oJ^!S8M#ozKRRz!cfwnZl?xadPRO)%SIa_;_}GWjdo2e|Ui+{{fvME}ra?ofsWk%Qw#u*M`34E5Z?U{dt^B`uh&Ttk>5Zfs?P1l-TZQ|v` z%Pos9r(bRhP7sQ0@O%<-BW=H-QNry-(;e4nZVGwzmgUnWyIS7FUmxGFf4UUZe_UL8 zdYRmWYf}n4y-(Z8tyP*cy=+>w^`&?Bw@==&W!Fc6XL9Frcj&z}{aMCTmKl7e-Qa7* zpNrL*{x`M@ukfCIWUuT>sW#L0KbMxhK6BeMCW^m5-EzzHX|>kd`qPzf>E&wu2I-rh zaI@fqUanb=m2yLDZjafGC9Y4G^4538F?`$k;`wFwtvj$KB0t(Cq7VOD@7Nqr5GYt4 z?K9(T8v_I5Sx6#ElJH6pG0+lZVQMIQbIYrnp=s~mwb_^u9KGSB?u{kx(JcGB1b<$!DKd3?n(+C= zUWuvBXO;PrQszZ$sNDGd#8ZYF5)mR3at=PY{!aNivx5;!@Fv#geCzxeZibTrIw!?) zPG0SEWjr`7=b+rAc|Fr|K&%Hp?<+57^4P@M%r&`C1f)hR=cE{qmp<3$Taz!QWHcR| zq_3lvX)OP9gO}&**C(cL^^M|B6z?||>PlywB)0YOqnSFHf!2ESaxXDm>0{rRef;R- zTOSq5-X`e#&f6k)NKYy?O`FmfOGcYiE zK$6tk8`}$+4MkW2X0in^Roy6V?$O(?XV8Mf(x^ICz>k{kd z9IF}HBos63rlq0g4^62X?+V+7!OWT&e+tD@Q7no6Hj$tg1Ul6 zr?LeH$E-7gIV>zwm0z4=WwGu{@L+0Ub`Jon`xWT0tGF*gTR}p|-GH0J>lw#1rlz_l z9_E}J+hh)I5EnQj}fyf*8MecLo7 zPc2>^kk6xg_`)8Z+$$F@@Gfr6KC!VUy6@n5!zQb?hglM*dAXYsLk)F&+rFON;2{+j zb+{-u;xjKhU)$n-`B@$+;INS15Pt8fs{cmN1!@>evxr)1M@DQaSpOGT+VK8X)c$+i zt9uw27`@=JS$f1kpe2#vxpL&S0=0=Vzh7az$zVMpnNfq$Ri@Zvl}ntk&xTLG#XopH zZ-`|B9mM>3&;6T;50-uqn#Z;0o6Uu!^~#^mOnk{8>B%Z1si?fMN!j|ui7#w2nG2Pf zEsV}vZDMo}YV0w2;IU@HL_V3B_Z-~9BxNKOlvg$>OP}y~b8sS?l~IGTY)J}>dzhWo|mSEwi<_C^w3X4Nlzy}0%7gk<}?m(BD4a%9=_WGDZW+Ym4CCS3IQ zQqTDNZ^S)+Pra72(=6h1D?8t{emlrYN=-It2hQuwd!!up7=4yCnsPvIM%?mG_gwX7B*eRY zzdU*O_Nl3n(^4bTB7c6rba(P~zxp}Fo4!uGRexe)-0r`HeRj%$j4rhd9bqhsw3#l> za#+OF@s6!wg+PZHi;!@`i!w%mvn-386tY-^L>;cMH)Oaf>{1d~%c-K(@FI_)gR3#a zS;3I8BTt;+qK|?W%OW=gka05@pLaZ*Yj1BK8XCIp z!lNZimUMM><>%+CZn+HF*k%MCky8k0a4?wm;J<)F+W!x`1TJVc9G&wy;6eI^$1k3K z`~T+u|IhzFAdl4jY7Grrz`(%v0Fo}YOkv%2*no#6wWo>i@L&F43nePPt}=P5c1ilO zkV9s%lQvV$(tBCI<6qPqG8fwXerlTarM<0@*Q>w(pT2e4k{!W2&kNssxLqr9qw?*n zihC2E{QL5-MNZXzkx7xDaHg{HN((2^6eY!btt>2kLF}C#D=fVfdQx+mTqdwbKkQ); zR$#JOV*E(r;lz&gmdW!a4_3_j*8lF!g}?RrFL<22GK5&b_kJw!P=7Km6T-@CnHsTz}#ddbggZEK%gW^`eh9JF^{YN{WLOW2dAr&m5Z zC?F#1@q4q!{7a0iYDf3aSeceRVQa0qh<4k${LO3oD|O>d-B;Z8N_w;W5o56Zx|Eo+ zf?v3`AHNs-9KX?$0J7azW=llOT&X)Dl1FROjV@dm;*;;fu zOA-#QkoMkwe}+?z<-7YUPm~*+(!0JyL*l28;{D!~8_n4VJ60$}DP6zDKO^sq--GI3 zhDJKCZZa@`UUTBZ1OL=DRolwS;&*VZl;;HzU`-P1MuW+cvj_&AA~$wwyQO53vA z{g2Z*nmv|VeQCc}QMvfX1?^c{k}m&_cpmLHJKWKi&ahA5$xN+-CCaRYUQHAIN>+%h zn{mmYq*X`oHrhZCTCI?eu)zY5i@wu{R~U zAM}3uwbXt7gvVd~Rrd(qT$=8>zuhq-o!i36&rVTY`$(wJy&9(3$(%c!&ef-n0nC0Ng;T?KZh9>>OA5UXot(6G^4qU5PFdR1;6oCsilM`m?s>xwr$_iqjN z=yW&kIloWlsFQ)B)%(NzHj1)l`->FU|ERWSvkwesm|8F4E#tORz(VA=&>sH!mAlt1 zOV4iEq|J9gOo&S?{)=%CbAQG^2kZSjmUF-~q2^}rVb{3EA3>W=8 zXJ5>X=gQ^p hsbzEIP&GbzBB8&ajQ+MqCxM^5?2W+}{nr+YEnq3H zG+f3S`@mb|(x=(2$97KGCn{s3-OR7(wBVJBY)5Td;H1URe?OG1G5>VA{jtfkUGn5n@pWa7R!Fj|2bY~XvEI`3Oq<&E@I~GCIntCS#r;l-Zc;Je_Ead+ zl9ay0KSekDq5V9sUB9^JW-V@!x@NLxY5o6oskc@-yc5{{b%~dko3YD1Lnm34Ge0!_ zr%c(i?{ACK3ciiuvLTN+EI<2k26!}CEzwN+?dqLp>*T+C^{d5a!;|kgxSA!cw{l_2 zzaDK|*WP)ff2Kyo@wsPKv)E4i#=6aR-*vT>(XDZ*dreI@b@1 zEIhGVuEZv2x`~<=hthhZimuNk0kd?@K3?8%*zH{?->;SK>`Zb`;^xYGZu_U+^5I9g z;HKD!6SL+kcQ1O9efAH>^;uUZm5J_^+8?z>tt*y)O40Vzg6-REHvD^-)^nfH?NPn! zEITgHmBkEbi{UwNZf!zt3ao}U1@!gxrBkNp>+9<#YcaQc7^#(=NbSKXK~pb`7n6%e-DBx%isVs`mMA+f;krb-#?y!*f;K^WPl(zqi|~^hElc*1XAkZ|>so3VE6% z$!0l0@l=K4U8Q8fmeY>swp`e%ui7=)#CNmJ`F(PpG80X8{&d@)cj=zmw&cue(aM=? zuC>IAZYr2o{DWoH>1DT8Xl8%YV6x&q+qT`~c2>JtYxzdg61IXRg<)@1yE)G~EHCn% zaPZBd*XXy>3X zkMnrJQcbbz8V5FA&{?ghSh;WZVH-XfHyxgnr6OyE6E%))oYDU2&Do3bjLM>>sTUn* zuFzyXwd%d+rHoA857!T83Ose65OYOT|Kn;l-L-Au^OSUoyBJq0cL+W2dd|`Be$3AI zoW-NWEfvaC@SSK|IIXE%B(Ua7`pdRw{)>U}xVa=~nUPJ!_{#m*`#(eReU5DJ6xKN&2MH7A5mp7atca zu$l1Y2ybrx3In0+3H)ccwcnlcn7gIx?6N;8Dh!zsjT&aGQ~5m7*cW9f_=hP7Nmf{! zcqzZVv1b~?MsD6oTVJ@XdKBxDI`h%oB|(AP9X9nj$KTI$x$;-OR%NlmO!kiLN1sm& zdzbw2pR0eFf8oS9*Yo>%1(u$fdMZ`Z<`%;;!%q{^lfU?+o4mZ)i?T;QUNaeY2GNzq(G_vhBp76EP{Cue){bzq`?Tc-7@gF>e!7 z)_l|1_^#x7Sj=X>O&zj+OB7D~bz8ZAUT11D;efx$JKDV*iU!X2@V|lWxz~jw-+U810&*5GF^z6zwMbYP7d_vDJtzHs* z{;RK((T;s?TDxYeB)ae2c%cHRG~1uvxMoOMzB{ZpQO zZvKn^;d^3lL~*briu{|uVE1Ij&4PCpeTjdt^~O=zeO!Lb%cmZk**e#ySbM3K*vcr$ zHLSm9E-3alDHip8K8J&cFHvy2tEX|OV4-xRh1Y*`t;b8`end{%@y0*VVnT-82fO)` zz9?7j_qTE2?)&P!hw<;Dihr*}K3yz3zjC?m9QTl8-6>uLM%nvRgT?d|-O?8e-r~@E zs_l9tzGKR#!uj$4pNd!8GFEN4`}Jx3&Q>gg^6Zm|87zP;(~-(qgdeGut+eml7B=Tl z?z*!RPd%7_?Zu9lUmEvbU-$66_vAgt-+jOI>BqgVzux}(^X1RK|NsB*fBp5z_upMz zUHba^Ha0dlZrnJ1`t+wypVHIQH*VY*78X`pTl@6s(>ZhI{QmdP)6;X`zJ1H4uAj`n z0KJgZp+PO+$p3;DGZO@^izS9LFtDxnbOB#TI=g+^;xl|L*BPH5xZ#pKdG6nT=gSLM z95l*!aWC)Lvi*LyPSmZ|;yjr7?~n4{S0b;(UWxqrF7V}7>|u$T69&8f-phC5>Al!+ z^@PMfE}!}{4gxa@_dktlaB5k)cb893(@uX)rac*Z;YPM30Gh{l?VC)56& z5%J(SekjS{0HYAw(WpPRp3BdPE!UI!D6F!MyE{1D|GEC})HJ0cSjBI7DHh%??4?~|1~6F2pUfU0D; z#kTV$GK+WnomE)=V%=k7&D&fjBi1DzV2u9IKX10`mo^Q2&ktH-*P9ubqX1t;n#sHDu}Ioi8X zlRd)aImcRQkDPNd_h!rteKyZ;{JvojYb?# z>W`$Tm^h`)SpLhwAUU1)aEsWH8a9;+oI*CqNuN|#iXCxtC}~nqD=YSNGg%q8K$PWK zjp?){|MyNhD6v<;;CXf8>&?b3B1h`)egEtu%X0l=rYBF@iZJd;?yY>U6xvq=#OZqW z?>{}EY0jc{q0k8`RWCv`J-;7caV}6GMj@2d^P{|z=QE#}mBz1&mc?xhThWj(ap$zp zrM`O-#g5#JKCM!CaN>&QB~MFbjN*>3G46Q9ce-Mh=63y^=lYIZ%_wQR^Y^O53O(O@ zJ{`t+3uIY}I?aX6l+5O2va{T~k>lZZW#%=92fWu01RI^5v%q%30Y&57sNKp+N^!Fl zrYxvAOJ_=%07`qgP*1F`T*0u|rpH_3{_N<}(4g1|IVC6giXk?Bw|zli!L<$3G}ef?)V z;p)p)s=S=dV5k~??aiNzJBKYN-*NYmTN2Z=t#QgFlL?o$#q?B6P-XLsKGYKbNnuHS zw8*aM%nSYJ=$>-DY@qOkakcA1#%{($r%P2X5dt4bY!ZF2uYQHx+ejW2#~FwHcD}F`cz)r=VZR~;1xLRE zKHnclInT0Nq&NyhOfYzULE)c_l3AmKT5A zRi?rItX+wNuaUWRJxB9LQ~4Fm3K~3IX~$+BJW!dQDsW<(*Oc@9qIo|*e*5{*sWb86 zzV#eTXQ!4rKAO%+inSKclLXDa&Hez0|Y7r+6oW%Wegp z3(m|h?z1vwvj1dfk@~ya!tGAtwfkYyZPWkkHu{mgWWVaa+lw>z|33Z7|NkH5u>VX} zYyT|{{H;G7OWn+BM@-$EAK(MN$s28BKwE4un#hA|SN{M1e|FFIU5n?o#su9wb8<#m z-n8PZ)|jB5U%wt)vwX{}DXaV1zr1|in;!e(!M(3nA3bVbc|EfG#oS$Q)*ru_Jn7@1 zD|d2d-m6%UExN>i>r-<@$vT z3@pjeDtS)z?nM?n?c6O)?2ju}bIIv1{{7ef@gw2r^0}u4>sD@>{{8*kncqDpPb!Hz ztM7TKXUfS-N4}_S7h#DeWEiwZre-=$#swZ z-79*-YDi?oVnsO|` zGpTf&akhZb)U7j5m9+&d$Zr15;N&EG&Co?zyE#xhXI*qfYR%m(1r9Z57gXO8;q%B1 z;4<-+niS%?Ql~WMz@(MDetrSrMqe2Zo}6&>X5|09hc#c`J8M4Q|8hZlwme_u$C{~s zufFB?FDg0nM(p2>==L{xhn6ol**E{^yNOb|TH320?^s-^r187WTI%Bot;KGY#y3As z{rvR1)O7#M(@*N7I@{NE&fT=;{P+7Aa}Kiz`n~_+TN5y6#h<9;OOuW)HaRs#TWFhK zNT2=bi<2`$zX~zsEYsCGD{p@`@S?z_Q%4poV4vE)z{4Wu!Ukhu&iYSMo4)C= zHRZ@=dz;&73HQessiwUBcrf|irQV#hM?n!nOQLVJ>;5&%=3afrWx3GQ*`CGPkGm(w z@mydCdGIY z^Wx7rGk$*7dNiZ_0;ifo?dz4ZS98=AbaZbJXAEO|FE1@vneHMqUpdYt?cb}XJ7@h| z^-<{#lQ7Q<$Itt_*4*DP|LHaU*f8`UMDvf{?T|O9ky^q+{L-NQet~N5;iF)#$5|5y)eVzztfS` zE;>&y*=5;uu`JW&jLf`p(lg`vnf;=IqOaX&N62MAOLw`E>v7_%ZOV+wAQ!L5yDI#j zzkgQxx2HqobBfrr8Foth=5Fi!bn@zy-(4TVzUM6ZCRgja$8*(8g=jgYLzC2v_qIlU zFc8cPGTQ2S%8c2yVo~VfPX7swN<|?XgSb3SA9kI?t9Z~jg{k91l&VT=ik6a+;>?wQ zCd;WD%5H63K85F?i%jgw4VGB$KHPql zTWJ%&c+JNcTZNbjw_iBPo-0xOAYJ(H({;&<6LOB8V$+j)*b^5v=V#oLj?Ot3tj|9b z`w{1K(MKd}CNU&|N z@6VX@aj6Q+^If*<8UB^4?R-_LveR9!3w!_#gM9_Vt0NTwS|7Jv$L6RiT#jM{IqH@A z<{AbD1~#ap7!JOim@Rvbfq{V$>>`I}H_{jw7?dCmN?rguTjs!jc_zCHo+%*^*y3cs z<;KXcF6*Db_X&UbusDIS6PFW^7hy{yoPc!^_RBXrD{`(8nS7R6$ z7)2oNdvj@PoU@}q>&Kn99tAwwQqg;P(Q|fLDb2_E6ZVwdNxe4f#Gl{Vzvrqdwg@f$WXpJ<^6Y|+~Om1m#yQCm@MN7>9{NecYJy4ERMJ)&9WoPW&t?m6cH3q@P$ggr0R3;Tqc zmzHPNZYV3+y=!{!fvRh=$7|;~Z;10et{RcQ4-q4g1wCB-YF7_Ki4qGJG3+%e|DJEv#QpF#yxjamgOS=Sp zd~W87doDAma-4eHWP!_%z!e{a7?pT7wyn6E-l2E!kCf8pnHwZi1*T5lc;h%n@8%Mx zGy~^9|Cn~?$g8a3;b8F)iMUxD^Qko9<VoqGzWE5*sphiSvItm|eSh%% zV`hQP<7v;C(|<8BWeUbP*c^~t^}gA z=29=GoAfF4%yh1m_~i0JTR!U9p7m+!m%7!y#2Z`wj$3o~gZN^{u=H)yZS*%?{+gw7 zg!_XMWyD%=-oGAT=o0g^@xvo z<1D)V_^+@nUvyOy)1Xp>c(YU zOfx2xH*}n~$dhpT!vAbyvP8zDR|*+I^VL>0Xjw0N_Wr8Uy49*Rt;(5I3c9A1?;33m zEL?Llx_-g4+*Xm2t(m(kIIB%hT+X@|e!?SM`xs-z9MR_tf}3tIE42r0ZN0pybBe-~ zc9*)mlj*`qyDvMMNS1HAz?;39^Q5+e!oj~S5t2KS|IXyGVlVTPfBIud9k1yM<}fiY zfltn&Ki4y!clv6!#QCS-A^p#f_N1|>aQsxPPTF;Ie#V-l)j}Zz$u5m9mlLrti9|i z_dr%t|Mx_-?0Nh`F}qt_G`qiPS35CX$#ZxTy>P0)uRiUAe`8K7-d^>ATb5bqOpz|b z6152p0$vk7DW^CqRO%f6=~zCIx8fdiQ2Lsih9ONoyI$8gE9`CwXqqCgcw6j=&~6b` zkDnWtuVp;ccThhjPgRLUNXMl$!C@(jrhU)uhBu$s+&P`<-bh;9Xb|u+c-W|L#K$aU z`Iq?)MHLN2=TnkzWgoXt783bc`^7m+L_yKtrAcYOeM>-t4(qYcx*whXaGlkj#v~@@ zq_XMme4%WoAG)U(zq@&I#=NRmn*ADAw7DuBJc1S716N39JFo?5Y}NS3&SH7&+15pp zTVIJyvu;>Wxv_VhW((`uY}L=ITLR5W99CHwpRAd}+QKWl_~@*q-=DA1j#AYt+#;}Z zib?<1#VXo!oS6A6C1x>bF04K$+sD|XZ}@|8)5&x1oGgB*o=v@OB(o{=>f6edM+8L< z8z?Z|PM^B_h(XUrnF%txA6DwTephh!h7sb--;>h@c2{|q-?p^G$yuj1oa#cAzl`DqzfTTl(ikjXU$yFPkF|C=$w1MeL z_kzz8_ZLqrI((ny2=jD?M{^kNtNb|3RwSFr;JB%kbIHyMP=${^fy+>dt46@qOi)x* zOjhkEM{g!TPf<^n-~k^(ci_+e|Nohlol`v9gxWwzN97|OPxfT3m!ap zaQ0M!CRJU)xB^!gAh%OsOF|*-H(caW`b;;$gTL$KdjsL13?Nhg9Q>nGRPtpF}XYNHQ$i%Ft2A z*04gTBaYKWyivxSA&{*hL!V($E*x|<%s6HW?QQ$43LKJtyi*yNvD-Yi!7Ip4EnS0+Sj`jA3 z3fr_9HAZ@q&u1+4;%-(_KfL6_Yqg^V#+d@!9$qv_onbO*x@U3h%Esn{FO(0b$XxMt zOF5g8vxBccFstok#ZME-o#9!$i5mn?{Vadx%J zgJRn^`ISuf?iOrLlsL54KB)4t`KhkMj`?`9$$#I6 zliYSUA5FecJBiDxQ*`bVZo8QuPukl>KAybtw~AY7atChOOH>hRz8L#1T? zk|w_-SM{Gw{%JLzn*6W*NO@)F$vXE)o8Kq7`8q$IaL>1SG+Eb<^RD{Jg_9!!PljH& z;~(zK@b;!9BSQesp@9GEB$FTXh8(o#UQ%cMDB+-J^KrI$d;d4=6P>Zl<<{cND-K2t z6^xRsP4CvS8d}C~F|WJVq-D&Lvy-30Zq<(qSBgJ6UUH9;UsrqP`+>#<{d%_^EATI~ zQTn{$T(UE>!E0{0S5 zaO8U>Nc<#AJV_8a@xQ%M-q{V(I{}jg&4COITTWW6dZoKck76g_DEugN0!igBj!=M? zzh$8F@BaN)_|TZ8v=|Hz^Y%0aGB6xtllyRM!c|bukG3@cIWAx(YJ&x=R{~!sOpvi$ zCvyt?T>OL${{;$e8qE3-a6qBK!Ro*~K?Vk93rO-=Go86dCQzc`c}{$fl^zjk!OMg0Ph|PEP{r9d z*E4vVAKDb<(!q9VRN(z(D#VJdebuLWFVdKd3TE@)sMP?<#1rPI=j^-bW z85Yc+_QZ(6Ws6Ebqr$4$Up~Zl&fk6Yr^qM6pATxXZ1p_!6W+G6c+OY&SR5}jF+E-3 z-lW!(O%=yWD#glKwH`D5@9}Kj;e5^UUP=^mi}{T@W3!1WzYPuub*k_)#4j|y-oU&~ zMULYD^UceOX_ZM4KEHnUzi)H>J)@a>ohtW1^R_9wyBQT0cooe^_SnI=%E`lRlK8nj zg|l6Ma;$pdsSp%#DzU)!Q;E-^Ref9!#D$aJzq!2Je~;ADGqWcw+I~AKGSA z@9xqg_MsB>nRWu)@#c^9RTsRQ&Yb(dIN8vwsW|8Uqu^2_L67Q(0ycsRS6IbnYfs2o z-u!?~dy4A1Nj8EWS+a8iZhEwQIhho+$8TU*%SZQwr~ATLjs>e{plihJ%Zj znCj_#+~hb0E>tD@2`#-uSQ{%;#?You; ze>nbV!wt`rj@YLK1#yp(ZMyf$EnTp{=9`wO&B2XQ{3g%8M2P%2d-A<@sa08nrlzA~ zt7c>5$Jh+DX-^Ef7ENmrUF6=mP+R44puh%|2d`CSjwVc&adW(())j9&;^U5|2hS_7Xn$CrR2lV- z%W3lJAFCcMJ^6aJxaayUaqIRzvo0w3@=!och~08Vk;}6U=Qb{6_HkdyS9<^P(|>IG z%rDBG$Z`I^{U^qGNo)(pikY7#ttg9q`sj@4ywfh%XX!=6e%)1)_E%Q_QM&DyeRCSJ zg*I$pT&>LR_xx#$BYPxhUp#tw!aN68<&3-}5Oy-#@$0wG-oF3%^*c;-@!li2;DJlm zAHROL^X#Qv=PvI$clqA)*N3m(Jb(A$&a;HNi*Ik>+=r?UT!=l_5)CN&(~^t4pSFeu>OBG$(u_mVIA8rJ`HBCXB^Gij@`)$pcX)c*DA$}> zym3N=`U1`KQJRYtPglvk<=Ebl`+xB~)}#|R&J{?9)_Jc>$q}4-_C`n5p=mj8OAl|#uS>T6miS>!jEuEch2OVR`;_J- zPT4DJGp+S+rOg%%_6hMt{HOGHvR|zdE{G26dlGg>K}Lr)CfH)$@0{aylVw^PH5klu z<}C=S5!y82ef{a9mYnWy?k!lKRrh&?Ur*{r1D+{*f9;PS(1_jjlV?rUGdDPR^=kc^J*@EXyG56(*oNFf;{}!IM zL1cd93?J4gMl&n%red>1?U>Id#qoTe%AQ?!OtUZD4V*sD?L^O_ihaqkhZI_q4i#p( zJ&tM>%GQhPbrN}O;J0d-b;;WwF;T@4e^sK6|b7KcT$kFY{#8ro5~RO0=3KXK*;h zD(ZoL-}EmM{hk`W{F5%LWM(wlcP`-cI3GX#QJ~&uuH-+`zDtj)>h68I(b!w~lHBtj zZEU`pUjN-L3l;YSHeH()C(9->Ni0q%weH7;WoILGjh^`Jxj6a7Ka10Q@;i>tezA%D z+WIvsS3$x5Yx%5G6niaN_q$_h`7jp}lSw_GL$ikU%PJPH#YB)@IS`T&yqyQaMkZBi zmqkroU9ouW@%f$73=9ks;LIq{^5B2LI)^CNgo>H_|DRv4@czER|Nk0^9$)V>Ffbi} zWWu+%pEoU55IFGBvBOJR)VJcl`rd7|i&pGB5cBZ+*Szxomx5Yf-B*=bIb{!n^~$=; z#>mBSrGJ<|rSo+Da&~H|VqddMD#*F)%d1%SIkTjKoXt3L*L;?~mguKB) zYvZT=1NJL9-jL|6<#JeK!r#E{M$Q;nBR@ao#ASVh-;Q z7rz6^(-`M#XH>KteJ;&9N7d$;fqua`qhz^*2PD-J%-;F13;C$>eg4$6wpoJZ`nIJu zzkgZm^D`0hQT0CH#IvM>(VLU|cAFyGK31oQ8%k+9S(YVD2J_T}r={Hp(=zPQb}to&vSbs*uZh3<;`r?oe|sA8CsH~SGPR3xi7r> zs`Bi+0`LF!xW}vyw^6Eie|Y5tgD75owYNg12k+;-I{LQE_pf`pSj9#Ob9wHWy$aE{ zbN2<`Sm|$ezwwLO*RZEsMJsT2F<=fnR&C)Vr6J=`MdtKKwlzc)*LJ!S+Yo zqJonG~!UG4640{QUj#3%A?Hzd68ihtn7z`)W4$+d5;xAq+|;9ehJbS1ZF^OrVDVN^vr*iV27Hui-^!{*+jX$K4!!=A=$wKe1#Hp5yJUN%d-X)!f z+Z#@1YyDC6%}~#f(QomO(>*0nblmFT;~y~-PkP%h-FbE4B5QZ}y^FI>mI$m>{;d0m zC7Pl2_wH`r?tp#DtrIM+?kbbxl9klqc`v%YdF77;nb%X-I4eGGcFnN4VpUvU+RZ&@ z=Wed>C0loPnHV25b#-VsGQIq5;l!tm;dw`e!k3yfJf0rd{Mt%xf&P+1rJB4KwlDkE zap5DwTVXxto;mCp@>_KmnbrTTPmdp0x5?Z#L)6<<*5pBUg4#ey*VVWX8R@Lf2p3J-9wW z?s$J(-NW3=?Tq_*F0&hkTJ~R_64Auc_ajw_b(53F9bdCv5ujFKaeykE~?YP%tTldo4GB8PX#|Qbf zeCun@`d|C{!*0hDNAvFwuCM?6=*;pxKMH*dFXeyU^IhOq?Y!-BO}6*vuT64&^1tZ! zqvm}Rs`t8oX}z+^l(!@9uT%ER##4Q~_a~UYULR|;{>KK{<6KVf4jgGYVKc${Q<%+s z>Ej#LzuqLje!lI?o(e1b%SmEhl7}4x>}1>~{x+Q_a__(3!d($NmT}&X*lWFe=Zq!J z9om=YHaz~HKj}`Y?8Md+Zx>c=e{rQe;lY(l0+T8U&uEtG zSFRVh;H9@&wdO@-lxcJLF)3H0wrZKL5i*P4nH9J@sHXXKxd=Ue|2WY-WBu3ajJE1C zFZR7&q_U*mq|be0k!qi;){dOthi9aD&dhK-Q}crJPMH3F>vx=|1z*P`^V%dH{=>Ip zZCtjMoI<|jN#+Li4+{d!nZ#M9?TJlr`{ZP`fiL^&tG{vQ8QRicNT@h{&Aa1T{X>Ya z{$SNF?&B3gpKq8&SANTW$7Hy$V!`50p~D5%lREqacx82`9GJKugVpMQ@QW2;kC-3t zetkgun6vv*A(weFYguKzB&NFv75VoU@yy~f=qXLLoqmriR9ow2ylLWj<36v#8UIWl zw5-xSwv~ged%>fK2EXI0(_{j-KHU>%ni4LmYiP=^8=k+$owk%ZO;g?iln*OGK z^Z7oT?Uupsw>Rx)T@=u}MQY)yEvp1r&oa%LnZ`TIW%HAIqeUnGrcS!@_IjNTfF^p3)fa41ybXHQ?xC?F@29z$&o&p@Rr84b^XbrebxW5O z$8!Df{?ZpbT|?HX^TNW}Wv9Mzx2Prhz=`t{PAUsvA!TJ`wr#n-=9KK^>{^{=ImzMOgW>&(la%O8C` z`Qm5G^$&|5emU{t=gfPbk39Qv{P~ah4?Z7$`eVwSPqXiRKJfI%fhRv^-utxo(T{zP ze@wgkY1hN=Z@&L+x&C3woliR+e82Yg_y7O@fB*eI;r7SX_rGqx|NY_TKb!A<+j8&Q z(=UJfZ++T$=Uef`cU?C>uD|`Q_Uij}x4w1W__*fgx70IlTCaatb>rKL>tAcGyl=Vo zVfnSM4OibUz52EG%KODvzbwA;WyzHD``b=|A>)(uvQ$`(N(7_uc2n z%cRq9YEORXJ^Fdhxi7o!gUs|f@-pt!>+Zv!!%w^_JobM6`LBEKe~&)-y7SPdb=SW| zoqW}C;M3j*Kf+JEYTN&5--93fAO2|B`)T3%uiI~ZKltd!$!EVpj=!qj|8es1&j%j< z`0@Aujn}^ekG%{y_A>C;%cA`sns$FW^7!ZBM?cc{y=~n2$?xc^V~>AC9eCZa{nP9d zU+XS>sN42w?d5OBpZ@ed^0IKt#{&<3xEy-Xf8fi>XFnYezNp>u$^FoaGtYmz9ePo- z>Eor>zs|n+>2&Z#^@dO9U;T19_#$P~`#Yb11@C-aweHiEx4&i_`08}vMdjL0JFfr8 zUGuSN!2TnA#mY~Mj(>ap^H0U{Pj|ok zzW?plgYUoG54?0f_@Zjb=lG59s+N4tUG*V1?b$j821W*OQ-GCIQddh|RY^fsT1AWI3PSa-XU2$-OJs@!6wi*H#;)4AhtNMG(Dvvi>o>}tfZi! z!l<>nuA`-~r*n<#gr152e^2R{P&;k%f*G?a=gduCFn_V!qGc=Fm#tZ~e%;0`n|5#7 zK4bT`-TQVOR6DZo_@UE#&u!Ro>W1f;Z-VPQG!k z=9veftG)LU zOje!|TP>7x$wH^hG(4%yVxECe#2PGS3N;hTt6vBS@GtsUwSQ7aS=YVi zzb9m?hGN0wx;<)(^G^#v>x6xVTY1nq{pI-7U7Skc`fQXnxe>g zL@0lfKxC4DJJZ9IPt%1G6%JkzZqeD;t?9Wu$bOA!-{{k)z!|PJHS4QyP?`1B9V|Dj6arU2p5(Ro<`YjFy_iE+ z61}%)$xnJRTjg4Yxy2+QS0)|Bmww!nRd(O~CN6Y&cFRlEi*f9eOMWwNI@0HLn94F+);k3SoQGZpC9%vdE=tO<77K`$E1@#Giy#hZSwY#b4mKG zezwdP4kwUV{_1p&p^oHN!QiG-adBo#XZCR%)P9xDpb(3=My{AoFmdM0xBEVDp{V+ zjdQo)w5WZ%P(b}-Yx9&NuAXOhJkg%C=dtSdi~E{A4@|J1D4^cyc9>iB*ng#ylQ%z4 zQJJ0C=Rc7{z4O?kZk7AOEnYv=&YzqARONUDr$M5VXPA)3(xh%x6_+2@;^$6#d^=e8 zEYxadit5ZOL7gA}m&ZBfFP@QNUBK}neR7Y=^z&;Jex7rG6Dp)M@lBhWkJ)LDqMv`N zCYfh^KBVIQ-C1~9K!VE7q(a-1yH8J7o#cGHu`g)T0gs}mkE$l=hp+cixxG;M;_95G zPToaVKUGcA2Wd+;bM)U8wovtJ*49-)8z;FKcYu&tG z&E;#_kiST2*AkU$c_vc2@@f|^O%msqPnzWY!EtN&>Wh=A_V=q?Eh@j@D#YTsRoa<_ z^ORTI1nUQ}6I0}8Y+Pv~b#cCY7Hj*|f{H-rXhGS{TzG^saX1#l4!>y-uBZo0yj7moszb%(n){#s$uEBfi9aVwNPuyh|?|I_6@bjlT zw)_(hJp3Hkp;sy3u`oK&q$07=; zud?^rz9ivC`|I!P95h|!U03UU7rwVv1U4D(3vo*l;kKH4chBv?aJ?*9+ zk(S6=u<&7`+RBiu4iC3iu3Vnhax+zbe|tG;Tk)idiw6%nK62Q*ca@5*)hbUfRgVV+ zGgR5Xy_{5kf6|fNrXEt#;ff(avaWkn9tQYK3TEefF{ym1*pqYq0mm(-PVv0Ec(Sru zr*mM>q+s{{tV#1#Gtb$m`qK)vpWppgit+{= zzq3Wl@pA&hBG0OTJI{^1(){OLQF*j}n%G>0vy6*8pNWf|ndEgOeae}6mWw^@rbk^` zd(_op+OrbR%ANZXrY%txRGawJ{d>CpoIusz|8jaCpP%aL@!*2W>eJcTX`ZH{4^=kR z{A9}VIufV5y0})bH#a9^($!Ye5cU?&RTD+j9W9tbPp%K@=E^-}xV3S`lI`W$*=KcD zmM#~VT=9^BWzynlVV2v>&CSJ^mz9}xUfp$d$`!>x#jWphrcJMSe>Yh5`26gthyU*Q zvFk?BosL5mas1PkuPC+nD{}DefuOm?Z8Oah{hTFc@%pOG)HUu{v#l!Yf%c577_V9X zh5wveyD6r;-}#e=N0=E`>m$jN<-aPMTAV%aRViz=2R`bXvQkC+WszW}XW>NWeTT3A z`}94ki23%4DKRP&w}z~I^LD9Eu-B&BPd{;TE}j1WcRq8y_4Jod!;L3a8_xQ#VRig2 z*Q#019w|*v>27VB@DIHo`TM5|PZWC75Y!Z(n-aTnLDgXs&7(eHvsp`=f@1!B ztp01`SP&CFsob;V?9`UU7Y(9yFW<>vDvJ7){Oh)TpJ!d0bAa7$H>I58O^fe3EXypL z^`eKRFWG-v`}cRAC;r4t>DxUmHFQ_Qf_rKEPfixly?N%yvRig8 z*>3yhJ8P=TOAqe{Kc0Jh`fyTM@#mkUC47rjWSI3N&D$F|PPSa?oWrTGx*+4^UUd$E zKUvDT?0r@;6SmCSc2-qtk;-aqZLg+zH78~L-&wkC>C;}99ct6>{AU&~hlel*Pj%z z>owac!-XYUszORC`!cmo-cMMtG+Sj}nZbmx6N{(#UGZ_VkecoNAYjt|jqexiX6sz( zGnMzvV}X)_1$t}l8%%xjU-wJ?Gp+b1ny&-G#P-*!bVU)w!Nw^)y5QWF3ACboHAp$|{Q zD1Y3xSmAPO>&rq;nFfcT^&t-`vL?(Z-X(O%Ue?PoQ$nozo`c7O1{L?D_a9<9Z24^T zCi2O6GubA8d%0MUPw!<|g~c?Lq6qaXneGQvL-(bG6sgSY33+dFguf#0u9L;ICA&`i zncO$6Bt)kr*>l}iGl$1$EY zV)~3uMhe!}UyZQM7;*>@(Isbi3+<9yZGV8g_{x6&Gh{BDZL;*V&F;tgtFBsXy$2CA z*>FpB?rDW-M2AEiCCXMg4Q6J>pgDeAKK! z1Eva2!CI!4LZRg!zWpj%cjm&AcmMzYZ{B_}b>%7hiMzBrx6L_r=fLe3K{NMCPdu>x z;v zm#H;vFb<73F6;4~dpK&r;q#B*hPgUhGcYjtf%{(q4gn1t4lYRe@c+UD1Nr~|{}(&} zcTX^gKmY%Oc0T|7|3BlO&Hw+8W*q(=z2X1=_fH$z}5ok z&AhqHK54OmKx^Ve-^uJLozsfv)%?G`_Ly0;MWUeg&)p35d)=NqeVVE;Yn}A6l$)%_ zrm;byzjG2j|IOD{VJ|1|=Vc0A|Ggh{z1_ol*S%+s2v?-f@t)5z`5foe9~a6v zAKbdD$MBDm(z2fCD;x^ky60Rm^k6SJZhO|@rbzZIqgiv?GH(mb()18awKSVzEY&z= zR^n$voe4r#N2e__VLW-sQ&{=^j-w*h2m5#5_!|60guzH{gK<;p*I*`ThNM2(#~7uss$x42>sYnvR4SV@ zEwHe7)%Il8+(hHeJ53I!8O@H7JSdVKac27JuW8k(o8xq!bFWF{`W5P7+y_f=|a?>ihYS^RVE=2L*IM&iD5**0_@^~a#wA@`6S(S1SW{{~b32~e^3=-3?fCWQ4_+_UHC6nn z^6{X{TfsvoQ@WjU%Vs?~^PKygR$#SG3ra6aThJ#-BWtmF2U*RoA8b z%tc4RyRu7HEZH)HVWG@D|OKEqq4IbtrWb$2Z<7TtGq z&F716%Nj1f=4bo+@Y_i}JI!;MG2QoA^xuk2PU?Tfn_{wQ>&A4c>$bmon38tf57V)j zv5seZqN(k-ie>*druDn=F0tDb>0NO0 zoK89d7k)aHp1LCG-M1m8BfIy;d@CE}NzR{VXf8hcyqlFJz_djy_LEvmxu5b2kNHt& zp4%Iyp3~P?-JiPj)cll&%d=}Q-FbB+T~T0M-i{~dS5-M%6mvU<9F<+8 z-ge;dfvVcjZ*2u>n(q>f<-WNpE_LwNzbKuWe(B)34$T>zyD}6DmcKg7=;c3A((taA zZb$C9MQZ}TKjX-cR^+&sw{}^?nwoUks3R9SCat7M>I*FRpt6=k7Sq z5ZJDfwr|Jz$Et=?T)sT(k#JQ=6_L5N$KqwgUFk!T6IW%{2EF;Xf9 z1{+xgoKG5ZKc13TF|FX5=r_TQtZQB_d@`j~QC8?@ipIBTjrq%2AF{TXKU8(HGVaz( zajg`NQ{ithZkjO9rDJ2R-4gTXJ5 zuQgw|I=kVvyJ9OvY%zu7a}#bfQKDJqZ3+tgduP5LczHawtH13Z45d7`t#eXTaW#7esgp4bN#>@F+daTGWfXcNWY zF2EqbpuoVyz`>v-akAmPNnGjvOU4cB&;PIbdi&nxcRp@f6HgwSJh3N5McH0?laW)( ztAyH$l+ynON`mbbM-^t*Sp?BhJxh1+r<=2}ljws3%cDTzt0;>WuFUcq#QRe&D;cW8=qD9kP?z%mL zri)n8g9%Yfs<#(#D09!yXqm_--KwyuVWP9Z%MC#sO5Aem;!<_MVx-QICm6wM-tCPF>Cd5C2-W2-ZyIOJosgH(=^=mS8-p*wgSxz|EnM zLwSKki(r7vAr1|=v;gDNLy8>@MehY%9B!%~QCcGKNHB=wBZp>7MT>}&jT4umoMNj$ z|Ab9fL|z7$soz#|R6L@*K;V&J0LMoT4Ui%Sh$2>j{s~SU?jDg+ax-oIpZ$M4O+{Jq zq{nYfcO#=Orkx+-Zb65xY7^@GXn#|bI3)Zu=#dqOL6)> z2m_78Tmb_YiJ1m!O+wmvSV@7VEwYmiG2|>V-F!!9`6Z5$)K zCr7oV0!RNpsEhpIpfK~+|J_lRAL{=*7R);Ezu|+yErtL8K@;#BHX7~JWnf^w3~9U_ zxyCx}hyf3CfciEj=A*yomoC^6^L?$@KgKUiUC}qilR_3|_B8q!9B4^%2ue(`Nl_HF zaZzmPQvVhqJkQU?<%kMb{hBMH*++d^CmL|S2|F=OL`P|_sLH34XI5>BUf3nJK{F=w z=Mu|FLMyjfUw(1x%&xzS1dVx( zm#frn&fw2sKjSo~V`JpoWdg|$p1A)x>m-ujQXkzBvR|29EQ!I|t?Gr|F7x& zp*`#B1N|lUe@=a17kN~^^Pkg`5Xb+%Q&bm={ru;oqN0Cv`AxY^TpK5}3+)wo$a{9x zZtHO{u=Xi2P4N%{JASoZCF9abXC0#YQ~R4umj=ov`4K6@BvAY7Yh ztId^rcrS0`*4rOHbXRU+aAkL0bjm?Vx$(_yL;my6CJA*W{r-@1{OcsqqkRvrGRD|! zlzA#9zv)5x93uaoUVb)!hbIiFVx0d=cmIfAC~Ns4yVp{q~GReDgN{6tlUY?EAl7%rc4%+S!EgL zf3i&BWZ)bJ*MGdazFY3}nCqYJ3AmPbLDsdfFh#qWwPI+K!=>wQvNGbVm5TQ3tR;q)Zr+U;Ez@>_3gw=b2Hy~n7e=wkHxa8KpG zjbDt<8!hUYG&M+Z3!7}=nPu~<{Mcn*PU^g*Xu>M{Qs}M5DWA4`M-Cq^H)%QdVdAvk z#Xr@4d|m21<7;yE(O>^fW>jw%{LrAEFmHX)OVveM>>4))J>rp(jL)Umka!^|5gdpP}8v z&5F(XR%VkVlWGKSWTbU`YJC*+T>C7~!#_W|Bc5FjkQSTV?GYO#vgg&gqer%uu3Pi? zWQm^0_4JsXK6fOKaW}r6eP?CSV_wdlc&?Ngf4Y?1KX40s_RN<$acRnYfi>r*as+YS zf6jce?X#@e#C5I3i<#ZG1nA{Fm}7S6ou|*A<UkdKZ65o!c9AkY=OgRR-%@h0T zAl#xiZ{I$D@zRb%#}{naF=5HNHMg?|3=HAkR-kg-yn4pg2sQC?*t0#5u zS-o`gycx-d&VdS0L2$wKe!hdi`TzS38t(TiB&-i8I9cM$$iTp=3@M}D%wWH?OhLef zy+v*H_x*3wrfZ#AZ=V1EXQ+w&!gQW*%YGcN+<((s!9^jpnlXhz;~Uclh6it77Hln5 zF1h1dWv;rHsWW!bBQtB(tt_=tKkhJeKW3N{wDhBi$b)@}>;k1*uQ>Xe#kAa>=a(*& zF16ysM!wE#OU{}EObq>SBz%>Y`g0#<(U1MFXJsm6MqE>iKHz%2OJ=`V;g4gPLPnm< z^QF9l{g`jOJipT2WlmH}Nf?h3(`11a9;pYXbWDht^uVRsYGU)!gUzBIQ@Tuw&OXQ} zZZugVC|((9e(jO!!G@HK~Gl7Rl_qLs-{n)1=)6|n8$f?3F$Fut5}uo_FRyzZ(pr%u|(hX z`Fhu~x09!DTQRxw$j+cyp{t(XR1upTP_e#biC?LpV&;sBO=X!iOniEm>UA#pMw)i^ zg`_H}9V!&`=8x6Oa+TWQ(eZuX{SYM;-b(A!^Clg3@>w}`BkOCeiKe{gwrz6%Gv$5V zssASRM+7okCVoh_(0`GceEj|cyUS_vC)PD3h#a4C3NOg8$e zx$lSdJI2tve}YOw#r{o7xH8jwao-s{3Z$Tf2Z`{j4af;-bD|{vKAl znpXI6@4wwtx}&!(o=;U$Gt@ZhsHWwvYts*J2=rA?o3Lwx4yR@1b=4!M%Y(Sj&Df)* zd13+cpT$Mu)alzkUo>-}-+}UD z?Wg&4zSIabKHGnIvt{egpKqr(I5B+>RntFNGc{G%EN0WkmIEfc+SLpjt znk}aE@oWE&|LS)WUJ9iq*q>OhtH`n>c9HWZ!4#Jhd`DK?EY^B(t7)qJ6Be}+V{h&a zo0H$_uX{dy#;%z@+!M|vOMTrFrChQ#E2+)JJz=MAdEMELkIIH$zwm4;<4HF7GbysK zddlnB3>(irx%kiE=JXy_x77MRk`PyVPkK{@qH zqv=F}g;kp)%=Bd^Dm{_dzg}-jik96utAFR8?|WZxT=j_mbPH}L&c)7ghu%M!o>9sE zb$4(v0^IArC6RZ*O7wwIHd3wNnb@5oJh#hyGT zPjq+W3P5s2RZVOiA~;OEZECB?otzK&mQI6Hru@Y{I<8d1Lo%5uK4!<(-q^{y=%^_n^mwUzQFK)NP1moRzZSn z>)hS!J#$!@18oEZ4K3K%78EMD-T5g|Q7rgv=i&bfZ0VJYW`2NG99jQNL}@cNcBq=N0+dsprUD z+;IL6{{e$c?YYyeu5=t~Jn<=lv$8KKTKDyBfm437y)SO~ALZ=yMc4O~iTT0SzTZw? zReX$-;~SiAC(Xa982|XPTK+WYnOl7MzCsUxXV6oYK7HS2npo>DSv?7i3hs zJ<96MXHDLp@Ik`Vc4O5lcBA`(KQk^1XUs5;S?%*ELC?iQ>B;1^6VmN#=j>S)A0&6L zVO@&X+ZdH2YnKqwNK?v{h!~b@?CNYT{1~xkH5@}*beO#$Ck{q zsap8mL$UXfl@^bq?%hf8Q5)Qnqhb>}`4`NQo!Pp6zn%AemX6~KlzSyA?H9dTq4mD? z3s1cL>z5bepF~xO8$Qu364w2?GW+%5 z**EPKY1Lky!I6wst6pnvYAjuNF-HEsdRgnT1)8(x1}gn-dR6sn+3J?-2biv_6jcb{ zsF2DH2+O`Ap!-Izy0=J2wCL)J;N^?t#>Wztrl%FiFh(i>1^-plarbPpO^%n zyy#QvCs5llDK)(~cec@{)RR7!=Ds)}qm+8^OLNzrXDUfI@6{IwX=>fxujl04=;5zD z#kJ++#^%K*ia(hyahNEUkvz@(<$2wM-;xyB`1&hEPRrP*9CuK^jth4Uke9?5lrzd+;Ci35?ePwo`a#8)Xo-<*)f|LPnSHWT}1D>;6a=yzEu=oTM`UL{Wv-sjj=L+d>cDoGZ8C2$J7c)x>P?dkjt=NGDQZG0&3|HSw98wVy>xa@7&ad?7S$`30S**24S?mes5 zJAX0TV&P&M+fm19Sl6M*b@AY7wl)uY7ok=O`xN_YQM*&CPpSX?lHZ|P8TO{HJY44W z#g*cpeI%0pKIb)kB*jvhEv)ZyFztx=n~)n)yH_o0mGSSYoIA6%cG8Jky7|*KJo@M~ zr@n6mXF^VvB(ZqNO_Bz05D56vp&esMVU%yRdw1%>x-KKZ@7J+@z=aCOUx%GtsP z7iGK+ODfQ2bKWz>^3|;^ldFo@;?)lAFxb2a7g^M8m0BxQ+1%c5Ds_|8 zX6ZTn^Fx@&VN2g76IwU=MP?U#T{_3`bx)7$1a?2Jts9;Pz1ksv?q|X38&@?T7TWjMoGjCB_xF|Z6xVww=wxK!%jTW+OQ1h4?37?D zPr=qB0(18lv>wz{yv`kFHR@ce@s-4J@NR}C5uJwiy8H1e3&`&k@2~I zk4|MQQeUh++vV|P+mqpQA6@#IGmj(BboC>r_Dd}Oj4PUh&%C+&iAmeJ{@#oS&4TG0 zr!04Rvw~5uc7Mdd(tj-%{5#w8oB~|!6u$&t+O(pLZJ+0c9acZ)%{qEbNRQ|5BNOIs z|C+_l23&Lgol(_#*u%AdFZ0J|@BTKrFh2hxy4dtdft#&C(ar0VgHqnOe{eX(`(OA; zWrf)bW1GDhlbMSzt>FL zr)}j(^IbM|$L+lB<%hOK#Bgo;wN!WW4c8K(w@KN}`ueOl|DF@7yb*DHYGGZ@`x8a_ zO*_rYl&k0I?5{IfRLrk5gFQ*7_v^>K3T5@G9J*_Ix8C?;AADF&=*wY0-6q9*t@}5I zom^Z{UG-0ld;9U*O%ZWB7}lS>ZFkgTTfP50{zsdp&vbm@7cp7da2eW{V+Qt_LfoV;gj^I5|1BUAja#;@zm z%dAjFg})EPID)g*oJduiXJprAed?crn2D)j+uCBW|4ST#FP;tITT*`_FKkUSECp@8QFLL42_j)t54QKKI+dIeKkt@Sh(=^A^868J(?KS=n=R z>N~k(mR7SCX1jUHy=#%)T;XlpUN4lY=O_37Pslw>p1EvVR*}c%sfMm!7(Hw4)eFq= zAwH1;q791}L;{3$Tb55{Qeh2b&Qh&8s#)UhSR$3FQ={6j$U$Vn8Hou^O`3n&RT#Cn zmVJ^JDt2JXn82mKzF|>=$Oo;OJ&wTvQu&9Rc|5qhm^R)&vqdE2wYhoz3C#_6vh#vG zxO{%SnXT>+n7~ybwEY)D71tVeyCZAwE!4E=EiYW%V;Q#k(-Ng=ulc!B9)&r0PV;&+ zd*7coua_P(kDR!a{8c z(+`z}O(qE%pZ}zpJZzfsV9NFXfei}H^Tb{F8=ExFa5IT&c-WeI$ZB{nR_KH|3)*#L z|NeJY!Bq0q1;;f^zD>as7c#m3nwoL#ZL}|cN41Am|LyA>i>PgZQ^OI?!GR^KigJnHJizkuK(r@nRjgRH++A2sbsO!#hyzV zNh^=_7;1@G7k{t1-qk$Gl~1HK#Mbhwml*2=@gUxRQ3egJ?D!;I-nVy#`nfrtD*Jr@hKhC1e01fjwC%sEyNi}=obgt( zcx{BGr9v!Yiht6+uNN4iK2Goby(&;DqiySq+}%I3a;}}Zu$`B|MAx|VYxv}1W9yTz z_AA911%^awskI$BpOClhze%x}7w<6#fn|U1zIyqv^!@Msa%B-|?Asdem+`E+m_6yX ze(Drw|LVDyMXO(*G1piuQ}yrdE8|%=mp?f8|MbFN-j1g>PAT7WiEGiTDUW&U9&np| zW6N5omeTpkMf~!H2)oGt#o7Fdxgi&C-s25^>vHacrpbbazuY28_a;9#S!n0?ZN0d& zjMfEZ;p;m2j~2GQc(F{(G5ghBhx-%e?Q9e{pwpBv>qt?CU)3{{%HIM#J2H)S9^uI` zNk6*urw()C#G4*FH-=sPA0tqdYgc~fPQ>d3Q?=~OO;K_|t2Z|Pj56JMCTQ3Fj;9wE zJj-Uc-lb)x^!jGsndvv9jzr`uD^C!YSb5NJQn3I*1r8qAXroHDbA{b{nU%ooXsBIa79?M+kK zrXI8SwLn3@?N#H!MSLtm9S6TYD9mK=j@&=7sbuTaKl0*jcXwIr)!8WCZ)PedI@NKh z#FpBG2ao;VZ4H)9>t=mfvM#`jiT!KCah^K=Pf`InKYlWl{)u`}5_i_mcZc2jw7udI zN8awgw9s~Xj7i1Y)A`|93Q`T8FHsc0X82t-IA~OV`V+*C!rE9JoD4=J#Y38_T&njk#5m<)*Rb-=%jXB&T7@ajL(}NcCN4Q>?ZJfYJZZu zexdA#<*dp5CC*7tm7ji#oow^+&N99E8{3plh;Q=y7&HHc+-cW+0kaZ66bY4X{y`P+J9z6#lbdI|78`#q3H;&KT4Bjn93Z&vlW3e|St8G*r=l~v)~N}Z-8?W!wD#J1 z!9PWFww+v5wEFxJR|`(3sc$kYcfT|AFfd*be=P03y6|Jx$ItCj43<88^1$opvgJy5 zTn+d{-dtGeDBaStVXF6=?SFrjG{`C&$;ZCg$n3r8;n4@KmoK(9G9L-wEh&NIq;^%&l@T_LB#P(xsm-l04-;F6R+r z3FJ+RaR`{i8X?MY$o&R)Ay2~f-wU@jc({w_fBRQu9J|b;rextw@ja3?YAwl&xW63P zee-x&YsxEUx8QYp-e*pJxzE(RMCp&_m1_PvW4U9?D(lQw|9hZnp3GkB_AKqNSmByY z_g`LT@hzHjOQ`C?tOtJ93Ec_Z1=r8dGdbC`C+lPt|JTEMvAiiAvPG|#`8i80asBC( zGskyAwE3ykv9^aTUoQV|b@h`p*V#D=JN9`cshm_WvlgCpNl*W1m2yndK?QbUDf<=s zJR;6E{SkU;tIE6h^lz`DY&?^m`-Zujmj1rz_@?H~oe%5(zfdTx6Zp6LjKbN!>m0of zHGkkZ^5KtpbHe6-jgAF1{|_kS&$i@dVRzDK3p*Yw`L6!_)vDP`_m~znCO!P`Clpn? z@L{9EU%!}-48OYW5SoiMSpjv#k6tBPh?KI*6(w+ zB0}8STv&Vm#%bpK4y$6D^CvP3#Z)yuQg6xFXdbXN`oOsZdkbrR%|CdKV`fW9`jwPP zJ8QxmwmSb!TD8q#VweZFx}mBk;|K!!K>t$)8|mbF_ac@K0I%pv~`(T!{zt z^j4)efEHV#55cla6H~5+lTfa{-zhz{Qbk{1e|3k_$$9dgjyj><+K)EK=ErLMJ|tC> zrk)g{)mfmnXNsbYh2GWWa&N6?X)rJ_h(pF}9U3O=`|!WuLbw28`KN*2gVslgzQ>+( zpkkJX#o^>GQP~@R!)M3aJ(O71w6MN#B5%O%;DpJCwgd^T*t=kYllF$gc1@q(xZaqa z^hh<)-tiL4ZuxJU4}ZVN8~D5X)V_U&dndJ*T269Hh%h%O6_$2d!Qaj+(TUUY=AI2l%chm9$WBywKjUW6n%C+%l^@^SoU=8ZyMNRA;-ejx zg$fT%UHt0X`It#6#yaLIDqe#Bt1U9_DCGt%J~{E4{J)jlED0^gXQc=6d{tjucZRdx zSY%i0f=!muzS1oz%?c_vwp5zuj1W#DvxRS9!?wy)H@Qwbe1LoxEaNt%lxl z(ccSRD`n>u^_*o5bojvVUu5g6ZiOu_3`ezBO}(1+$izahYm(pUuYFn{^*cR^YupMI zq=H?(xRhwLooo}1Y|gl_=4VQ7=|ygBRi`Vv&1Cya-*CI^Pqs-&-+jtJ*iVJAKkQT* z+s&Y)sXmh?aYQ^$+U`5Y*@)9eM&Z`0%g^&ZY%+I0+-Z<3EL*dZ?T)3v;)eUCx1)8U zl;mbBdOIjq%m2~ambqRz=}_YD$n6^L&q8Kf=S(~(BiLB}Y7;Beo&wQ^tYoUvRLS_Al`DSWonXcYvn_VB7B5>`SSeT>AoBqnG z*VBzV>rU;AUtRY7^MdVn#o~7-9bzhwXuKb9(KF%oX^tZS<`0a^5Ij0|A+|0B}JVklZxo3=h&yRhPIed|U%cc3M*4rAF zO^f~?xLRQ=-)GVobu`O%PWQRJZ*`WqTq~=S3t-6>4V!&bQ%(46xf|b+*Rzw<9&THA z(mh;epYiH2hOL{|#Z|h$-IXY(aa39G&)R=y{sfxebFq*WwB?tvwU0fnGFRZ@=L#j| z0#)G?p2+g(5(DdN9x(#*Cnj; zuDWN+L<+q9Wxf5^Vb?x2j@sU&m9P4vGu;DyW`!PK`?$Q4d3)F6?{(}>kA84unkd+) zbhSzdo~>}Wv6Ywa#j0zs{EEJOfAnQ<%FEhFnV@r<|7G~!MO)=bkSkG8_`io2VW0?KFem~_ibM3RHeREI0Z=F5sUwLtS zC<9Xf&(RydfB&4`#qJlemn%zQZy#&czKu*Nj$0UyFgnd)dBbply+mYz|AJC>2_6#$ zIrdrG7z{KxQyH|To-t#P^X`&uxGZ~}-@>3^I$x%``1$*FbL`~q9Sh-6SHRNuU~I%y zN3wuch$tPm;bCB4fSvRIeUc_tG^ONV5&WG0hW`=Eo{88W{1{rfm4Shg2hxFfb8V{= zv!h7sLt*{GjKiH}KbRNj-g+GH=+dJ-rbVlJ)hBm9tGWB`%%8g)`y6|g$=~g`oFW?N zGSSSJcLwXMKMj&j=@HYFx->4GVtcKz!1%a%+AOv5E5baj805D2GSeFzCQ4~$Q`S>dv2yPTj*h0BKB4+R{P4l6dD+3U%xs>V<1TXS{EL_8LXK)3@l@QFd;8kqsPCsWw&iB$PSxHv_mA<%oV@)n zFUR}8|2tLg_dMIS9XH-Ia9?L~sCoF&+DpPZzJU@jOloKTW9kbTDeg5%&)9i%}LG-v#+MH5UYZyx{#TQh;qo?>ok)Rf;t% z+=tuWY*}8j|MFb_$MNS>xiZ7Do_@(+>X?})z>u^(iZAcmrF`9Wcl7z}vV|Vsc(y=_ zrJ!|%2z#PY!er~;Isre!OzPTB9^gw-E;hQL$hCCqFKM=!-GcR}SryGr@GUy*Kf%~V zJ-urY*Qd4}Kkn*zT@+dJXPt$mr5N}8!w<}+8JKmj8dt5KEKuaJXhrWv>q$MF&8xS5 zTGtZrpsC=Usfm!9N1CosiHE@Ii7D)n`*QQ98L&-!V92TTDC=oW56fPsho1i=BKPe+ z_I}xdNvm2mvT>dZ47$lMvEbt2%kx~7@;BF*ELhRI)Bob(1A+m<;;U^!HqFYob7A$j z$@NTAjvl?{sbBcwU+n#sE9<99I(sC|*>xlG^df1_xZvK$X8vNF-vqTQl@%gx26bKI zy0%iZrf2b=r5~rVrQWs3`<(N3;^OO@O1AC}fAZ(7Y2D6^(Va3;-hN?sQ?9oDzqmr9 z_rATNbn!;1!{42fg|93BUSV`7HskuLew|<5i|P|aMeYgwcYjhYq48F;a!JNjubSB( z+;3D^>-`aIetW^?|L%YN8EJjXTkH?Hoi1**Kh$=|?qUCicUv|&-%wt<)oZrTow)03 z7lsNoWMx-MSG%nAmkgW!WyzA3ME``Un8%lM-}`xeRB!9F^>Uk9T5_XBe0`l&;=N<1 zGg?bZmc9Dgv`%E*$Beb7Z6ddCSuO3EVjY^j=j6{6%}$w|X*G9KtKS^6{Qm#SC%ybX zzt$Xk>AhyovK@;EV^1ZVgGUrU67Ia!6fIH)KvBPYgj|*=dN{LC7n)!MI z>z3DdH@y4t`L~3;&DZGp3t!&;a@@Q=thN8>DUaxhCT*{4Ray=A>m@#667xzCtnO*q zIOEuYc#iv5G#@s93s7FZ@Rn(&&TFIW%L1u}yn&xQoToT0*4*~FN2%y`u|r>4ZL~qJ&z-w((Dh-99Ox1nP>hrQC{j;^uVy+W!L%{A$ix& zhia*B{=Dw^L!U(^eifT!bz)BScdD_o&o}jzf50B*^`!ijYK=qRxs~(wbIxB@(DA?c z$267;`GrhM-7U#_lNWq#;ypFJkAdO;dd;<$+I0-E6(`-q6eqgS&JSkEflFi_`=`-Sh#GS=Eca*;jF<*^;{*q=1$YMCr|phTI)+qddobAQ0vYY{0E#G zGKGReCUX4b~9JP#K|9a25-dO{%ZUdS)G=O+a0 zoaKv_biNSbcz%B(kJ^1srMU`|s{_nf7S_B7u;~m{5ZUAJF0{kp)^Yx&lHpR$EAA!5 zo%vV4{~&MC-~WqVefZbd@Jhg_GC5~OY;p4zvB$c5zCL7YRNw92ue;5?;{Pr@vaeT~twEzhDQHdD)4eCJH0G$T@|&ho_N*|W zs3<+N;QRlta~*iX`d=%utvFpO;2ILi*x8{KEZ`b4vtf>J$AUxtXXf(?hWt4GX}dd% zsDe#H$AU-9Co}?5oLVc3EEJo#oI5{uaA@_ovzaQbFjx^O*|Ffzsf0?!Ca%-nrd=L- zmMcI}z^RhK?X;Rpsj^aJkLIV5HQgx;N-!^%kC}> zAxAGC->~_22gig}HP6l*EYwzVSaql}JE@X+X51(C4hBb6`wjD-7cn$(%~vbdQgR5e z+{WnY(xLUc`kJ?E%Zeh?!Yg|vmnq&)y3v;&Abwz#EcmE*j!)bDlzOe7JQdjGT*Uv; z-oS-nqJuGGCsR191$T?Mf#HT{4A&g@vd?9%XYW|=ePF)uKednTyv)pQj!Dz{7#Qkq z{iyetvF0k4GKq~9SDA#oz$6x0Cb_x0<3f&3PBu0+78Vu|1tumY`uh5A?(WIS$z5Gt zOO`A-4ZbM&|NsA0RaF}|ZhZRmX;@g;^y$<0?b~gqm0Cpc6`>Z(0;f!$>(Q8 zm*Jm~~&b_&ZP6=}gPDSGz4Q@f%Dk74A5zpW-unapb;T+!_rZW-~IM z-u_L9T_oq9!?6uLKX}>dCZCZ%$8leJ|AB}%{>Qkd_#2;zKVj#o`PgCgOnt5XLjg50 zc8kTuk2q;8-S|- zDaF;%?-(u@&5&FD^6VB3hVRF|-O-cJH53z1JnLSqw|&`%il#{?9t4Tll=GU+!dWRJNZ%r8$x3|XY)M{Xfa;vRVFMec=Sl;q^#rj<~dkh>CiUN z3Sv4Ro!S@sZ~f!m)gRPUx%5g;ma+eGXMQw%(4jj#Qc0!W2J$t zwsvJm&$*AB{agPYto_vR+`=7T_PnUb?6=|K?EN1vKH}n0oxY(d!e__17o5w4x1T*X{RvOFnBuk9Ja%hD)UL-& zlVP;u7Fr?k+H2z!Rhu~e1$JCQrIJ_I1_`mU@0-5#=G)B0vkvYMWqW?Gd~5V3tquCh zl@6O!9X7pwyV>~UD*Z_@PW#sHnH0-^^c>5jjdLdjygF-Gnx+t5?`m1N;&08Fvvy~F z+9jr}OF0m>%f$S*)2zLoxvcs*PhwAO;l6OjWiNyFT4e@~BEA%v0I_&s#7wUf`wB)JadSr>J}R3+xpUu=}BQJ1~kdZg1R~ z=xLuA_6ufaB<(XkHshF1;kBrC%Ot7Uccx{Svj3{j;XD1<^hdpsVz`O-@1(S<#c4mz zcWWLNbuT%0aoRKU&r2!`WzWR-2!6hCbHA{W|7_=-N~bo~pYE8!{!ISL7QM6OQ{{TUCyHT6dkxF#ey=`3fN?9l=H6B8yBm?l6tIC#ARK z=$cz=^TX~M?Yp(DXZ=}@o0BI@bGTgVy`Wbl!{*WRsXuo86Wlv%qEzIO%g*}eKb&7K znfTL7sOD!yLXrEVH3CkO$y4SjCJ1KhrY+3ojqjQDk|o`bVV{?w7k*Xozw8}vsXAj@(}vwgShq|lys4|eC|);BU}4PRnQik` ze_T%U-hZjf&tGbzXUC2&0ta-Rj@tZ z@9OU<|TFozaq!~D%SQ%rRt{OFZ#1z#6NiaL!M2u zNh*+KqRC7C6aCpsUNy)BtSNo3lB65n%ezRb_~$K!Po~!|c8eVO!PFY!u$RA1eQQ0t zi;P0HCc`E%fnOpF3;8|fb2WV7Jd&{W2Ux2Zttkw3=GT#kfQy~H0B=pM1iBrx8>gMkh-!>aL)a&`?pG8 z4+~)1nk!vcvtl#H9vkAkYW4C0eE2{x!3 zTCy>StB5^)XzZ61C~0@{zpKaMzRM4d)7_qn2AO2dWjQhD^4}#NLaeyY-eC=jXxn!n zzDD=S%z1}e!&fNZZIxbM6(isJ*@($(<Km^5dDYIwhDe)Y`RN@CKYN~3qBV}3Tu9_*~9Bx-chBaNeWFi6N>-P8!#K`8F{$;8%*H%PFm1ZXv;mpJYRJy*ZM_tE=?%c2h*B z?q2RCdou*@r97FuBlAGV`D0aUwshYPKo(f`$=2LNm=ErjqepM*NhgGUzYx#nQnE7 zU36R18YI*brm?8^##hOv2EHvqf(s|^JiclF4E?YV61$X?oRs%(V>;#?k;(E#@R*y+ zzZKzb4$~qZa4$?y6%va-mHNP^bNM1?C9mqmQ>SeE;CcO_$i+)j1wJ?|dh@8D?Xl*f z&wmfy)tqV(_KLBqrDf;k^j)84Y3`aKa?x!`m-Xh?GlbktCr=gpHShH-yLpq&*Vu8+ zx176jmC=qvH`j}|gv}|4)Ght?M(*cn!7dXnR zx>g@L`DmMy@{&!fkA?22nH!eT^5KW#sZB3)wM`CH>mB}>w@7_eV`j_eSp{Ebaoy(V zO}9_rFy{IF?u(<@-%nfOR;HeQ&`})K_LEUQzx9L!i%gc}qTF-qqdXk$tJ9=5McS1pW9)tvyt=1!f(?bp7*|=@!>*k)Q=M% zcRoFQUOmI8t#+EVg2gHe6U%*;9%&x03*OFnf9T-Vc5jL6j(W?yT%T<^w{;=6Pxwl` z(pdf7FV0QbeY*a7m6AfV^!4@2lQbNxbwj z{XR1=Ft31?6W5MUWmV*H3AAB-)%Itx?0%{B{avEwOmo{yj~B`u=azT!kx$~dnLFKC zOEiA#t>6i<&M{Aqt$!!?vhdH2kNU+GN!=yR5BD80Y+>4(H(xc(W(nJEDN+8_WuZj} zCn=sga&^NB*KQe6wo^q@ZX`VVmUpsY=G3PXnVkQAv{dsEU3hMxL91zdozOLzKb|Q~ zi!7FMO?nq%m7%v>z)?g*{t(+DwXR;TP)>fH(%CET!I1$iB_#=#dZ1 z>!-f-TC!@{hwhaojq81HJn1n{`>CpxTn)DPnPw8QzMsy zb7OLH@!@8j4NMypL;T}UU-Qvu{5;o*vxhg**s`W+0-xkl(-&!>N?v=+ifz{}cli{i zw4GgW^VJ>=)uQEH;U&I(1!uo1IfXQdH}JD|T4#M#a*>zpd?vn=`CMqn4VC8UQc6Zf z6K1<`?>3tuq|LpdJXFrdjN^%lx6Dax2I13&*UrY9Y;y6Qul$LB>WrnYwyylP)m$n3 zetBl`w7&+{vZjUkxvB0_F($udepKC@n72NfVN2{3TghwPPYi#F)J>?7DJ}gg*Lr-% zj6>={C2kehwoH^cyx%i0{7&N5HEsM1^II2JZtBh8;dZHQKQZHwQfAG%#dkYozVc7} zaq#edsbz~l{`Kj8IU~oce)S2zqf1_ByWTmY99er|%jf^+r8^(Q78ade)t9xlr6WxB zaZcD2QNxtFiq`d?E&Llgt|TmbmAi-adfjVR9l@&bw`aOj9x(cRdZzU9;U8Yf*YB7r z1ljv$f4K3|Ow99v9K$`%CAqFLT$X-X?&e#%I=?wR$ZoD&6<^CcPrycX*+07ni$58w zFP!n}&Dov*8m1P$d?a-42;=L+AyXT;TEj$VSqg8T{YdCU{f~7|SS}ar-y-!qB*P?K zweP`!l>YgL{deDEX|Pee@oW9z*{kaW;Q`x_jBvd-Jx}-|5=E;{Xq<-gHN^#rirK=icTvEAYk^-)Jbl{MEnx z<*oP%&Ya?%ylp`ec`eM|mrG*p4`lE<-;bU3_+hNc{g-JqvK{9wc3mzL>1hfy;9~eM zKEH|oedc*==D{R|Auosc5t?d_NQ7HbHw7N|;` zs%_*r`FsEKHUFNylhHa@ly>X?^?QCRv{-*FvzY6*TzRTj>=!r9P`L>UE`>YCUtN|N zsxG={?>7Qc6{i**XOl?(*r*Ivg&=Dk6)p_oU z_N=(j)iS3I1K7@i_#zcZD8k2=WesdMgd-Gd!lB`@1AiA^xyYiyX^to`{Mb9>!3 zv#z8!>gH}4=WiRC?RfK^#VzCf?AeV~Q z9iG*&^8L&G({F?`ybhE7u5c#5bf@5wAMWo@{(tD`dF{bo{y)L2vgt?mY8~c~H8r#` zaq_Y;F`DuxQn;U2*7JXKQ%veIapV8f6t-S?YkjP;hvoURsW-0O+&RJ6qhpTj!!U8R zz?c1k?B=x-bLXCxJ96%i%*^HrX-}r2i246A)_%OlAJ6d6zDa&<&;GKVfs<}C71>C( zEIXR_%rrIUVpLF>;)g&&C5OlNOyP>G%*8ndye=z^&b%iM3%ezwQ$JR8k(Y=UH- z09SYId{v(>2SuLo?^nDK=a^CSt@-HLd+oP%E9`e4t$Uz$N`R$bwc)r7`@ye_4xti` z4G(graG!rCTAeiO&)t6y-YtJ#eqQ;bZ{ogs&W*f6!JYY^ChR}{l)s+WzwQ5R=@$;u z>rdt$II#1s$R9ST?}qV_M=sVvX$<_MiUVdLTZ z*8~zyF$r`Uty1z$&9JWx7JKOxds%PY^rqE0KO(>VN(x)aeroCdecz_8S(jzhVi+YV zSu)kk);3eZ(RPQ|Qunwyw_bE>eOsipwpUW)(2T(Ct8|vEun+m=yE%^uk-N@Fjf~5>$)+VNnVo#urf~y!o7SG&sZVm$jgDALBB4+IwnOUpLwe0lc|341S zzWKgKVe27QvBwMyOl{C&k5%=f|AO2MS)dmCs>q zi;}rFRkvqx*`D*<5=Z9!Fp_LDkc-cXUSQwI%g4M|GiMX`G8xm8Qx>Z&knd#K-53|9 z@{#+?#)>7J7upa1_eeiux%;wknpu(i*Fdo!D?Q42-fnn$AlvcE)1X7yC;75xoIM~q z(ap5)fcEZ|$5gh zWXlTc=w;UgW@&a*>pDLAqx8k@kY(17=YogM?D}wK&HA*phI_-~(<@(1T-E(#d)&f< zR!h>Ju7BiwzScM4=Jkd{&&sYvMBYDmPh2U?tnV^Igynhn7wPufUT*(!?!t@tEZdp< zqiy3ln$JawKAf}l^U2R#;VFl_f0@oZ`hEXgi+_9O8k~CDa+~v0Z7;vxu@_8#_qF|J z>;CW8|9{%#|M#Z*1s4}=Kc~0AeBWmrQ*&Fc3%R_SAF_^1dF>be$TM^AfrX7v@HmA}@~^jI`Vdia zt^O3(y~Qt$qnYpWe!TyB4YoX!Iv{z5J1MKuLG9iDKQmVthc-)I-r@c5$Qr}#bC7PP zniX00S%Jrmm2aDlg4yAJ+kc%;&RXtgXSwuwLHuo%>48oTbDzB^u{!q7ASSP%MCw_n8`jmrAiqx=SYNU2?VC?vbJTYt}>ki=SoJeKDFg^?kv@@P}#p zj&Bv@k74XyP=k;V=*?Yl|t9JMEV8w1(&;niJzqGuzx~|LF)Mwom*9=X$#Wj;Eqz{Xb8Bgsr%S*@ zN6#l+YJ$$cZ7=hGhf3hUq^mXNdo8<@3@5>Eio@Vw++4}yA`Kw&6eap^x8zS0h^}6SJ0$whP*I>6BY~ofN&$HV64bj~=~*)?BYlJ*;9j6iauOrZ)kQ=$mKk_<l65h`*u6ER2(rk$u_qq+yst&E; z!7KAmrmefAaGN9BZMSLgmemqp(`GC>zf*kC4b_)P(FRho*S7xSSad_Ba`M;Bb8<7v zM7we)7jZpJ`@zqDah|l;v~7p~dABJ|yX{`nvG&vNmWy1^xDSQd_bfjobwpuJ%F~uj z6V~wl*FPuOQgA}pne*nQbr1hDiluNaovGV#>1E=i4*5(6`%3=XhU@opg+-hzdM#A5 z>bAOtfSZ&S=dteR%IXJiC_8DddlVCPGv}GOVYlHugY`%Cc5G@|r|%)4(6+Yr^>r-` z?ggt?|Jlyp8Br!7!qNBFz2@YV`y#(O>m4-K{^_qM``}&>Eqp4jZVtnpiLuw`&I;J} z$@bIK^F?na-QFz4dFs96QK!E9o%z};WEQu*WV9{nuXnwCBj?lcO^=H*B-Z?RccJ@8 z~D+LG7BzR1gOU}-zOKG^c(8QaM#(sY;k&fj`} zySj?)9*3t#g9G)XSf>5kF7;K)Vy3F(gVcWs4YT>zFs3YYl@v-pmd$WKg4r%9IR8NT znIk+I39FM2h-|ZBW8u&U?z+jF>|pSHdf{T;oY%J%;y$ag@s)K;Jb31pz);?_kE_Z1 zV}d;UO{MBdE4BCDJnpz}a_`wIw@&@GI8lE|oUyn*q*<{;{=MfjmYM$IO%`YKdz>cJ zOnGp7o+aO%MXd@DSSx?zbCFlTf>Q8-GJH*5gITZcV5+Vn2TL zlhKKrj|2JB*(=m$R>&q_oq2;{o|N!qiR^qex%R#w6{qvI3z`p!URrF%egBk?O_Sli z)J2^4J-n`ynxrnyQz3>M~`$e>m2(4{8a7~Ek#C=ym z36ZF(@T{@7OL@WOaQ^s~ZE>j& zKQHya=X&a9i{0WYtwxTStRCXQGn&JeU0~kQU8)!rDZc1oQfx<9a@TRi$YZkQ3ahuj zc%`s-@r)#6j%_?vIX6T4(pP=nB(})=V(W^aEt@sZr19_N+ZUJO`&y4L( zs~KA7=F7=^OJ1UFSfZSiZB)W`$@b_0>lfB7jb=fj5<5g2nI&&1e@=g%$8$sTb9=hw z??nq!#LU%P#iegs_%zR7z@hnR<>?1U-$YM(JMBx*;Tq>Kk;RCec?CdO_qB%nLcH@b2xVaK*-wfH?6W0nLkzi+FoTB?0@gd{%ifqzZPbluB+a5_Kott z$hkLeh`s;hwbAJd=c(X4=Um;bIq&=zMHlrxyLZO=PX<2=m$dccZrKF&8I>P(_j2*42SJu}(1+tsomIfkoU!nJ4N zpA8vX3O3$4<-qp9w$-SmzOm6p;4Yu>BBp0Nn_?dCt)Betovye98&eMx!^P6d1!Ye_%?0`i&0)a~AsjV_;zPfzO5k_>{Sl7KeHiW}T}I2$1bjEK=^cT->W5SP-w=rF7Eo#%uPzO{L0_6I>@9 zJM`_`-$ltUaty=_Jas3Dah=nBF@L2SOiEqw|tcY+}Xt>uSK0Uoz`Q*Kum0wPE$bXs=*rFt|ki%8O zNzk$@z=aXS=n80260v;c^ZIiChT5Vh3sw7su3b{#2r*aTE}B*=e}j+bia;K78{d@@ z$KaJB4;OZbdUfyDN;-Gb`g`}ZJ$DRyJGSmA+?~)UlYWy z%bC}*TjM}nUV`ha+YYA>>im&>!l`n~{+7q5h^<&+m8GAUScT1#B9A8EXD`>uoC06T zr{GY~FyX+3{~uxmmOn7~8g=#r0|N^aG=^t1&(`tgIlB4T_4}K1Z*R-}{dMzJvrDVf zZ*R+eeJkSe`W^H3-L;%LYhCu4_m|%(TrSnJ^b}1!F+uV0ri8V%=RTjF!F=ET`4ZjC zz#lKB81-GMd>bb}L0bCnX^(=lx2MRwuL+y+O-VH+LFl!Q_ZJh@_Dyql@79!!tS_*# z(pR>=dA*qF*!qWZ%$c>fb9K4?PdwH+XAYN<@ew^ARpFg)j)=NBp1RSgd*VRf8y9X# zjWlzq69-uL{FpRlld`_RCwAq~<2hSZCvLy$cl<|$L(7xIw0M!#*XH(BH!a>G_=(N? z8$*AEYE;Bxjt>$q6jElt&Ye_q(nD3UqEyHuY3kOiFW%i-s?ceAQA=0M=F~Q+5Z06b zm{l)sF6F;^+M4r3l5y;kk3pZN}7{>|2} z^Sk5{+gI9Jc$=BtB$tzFn&`xQF;5aqa?BLD20f#?J7P1Cn#=5oH-98jZfq_pL> z?T(8#4E2^-)+nW~QeX3pbFRgXo)z{=kL5N6-`{#Q?6~yX%__gV*IqAf;Xg9@o~F-3 z_S_8()8bVA>HlPYrW(z@Mtt{o=3D9-+TJwskx$cI;;= z|4qkR9+OHlE3_~ArffRzw)0b!)33VuC- zYJ8Vv#kZ5`0vnnw95~K9S=k5l|9Twn@k=9i+u@Jr@3K^+^1MmB+xQ^;&hGp#C85R9 z_dM!L=3J9syIua^S@qnhyUgmJ#+Pnk_nhE&|9gI-^3-$TDYu#%RPz4#cB$~0Om5UE zQ>thbi=QNA&VJ>&!I9z%DsMJATQ)|Ut{Q#aTL+L*mU5`8NV~!X=!CoT92H`anzkTQ&M@ezD-(MTG}xiyM5Vb z|IAxA>tf3HMR%u$+>ZTU9{RN-OZny>jrU9c9DFY__0E^nnvUiBmwKqYd!}`7*Hng? ze~RBcP37`^T>R!aE0^cC-idx($9r=guGQAyIegPA{J+7!8^_AZCe8DU^(lA86p@u(TYmoDtx^~= zfoECH_g67VVo4bnQpEl})SaO7^<(9`4IKZ1EZ%O&NSgZGxr9CawaiwF{s-Qd9Nkn4 zB_h(!i%nvTcRH6i(ZN=JNyQzyGMNqIRgUhKLxQ#)F$Yp)c64T;UveN`sPq-|y*CKt_hPyxJ zAJ{l4&tk{dIY}A6r#F7Q;M&SIBjVVB#}%tCoStFItX43?BJ#=8n?JJ(j~#41AoFR? z5`%jM3eBE#ewUcf2{qVpfQ8GhC~ccU=j4Dpo9ZSWS^1dZSG1Rl=X%~XHIn!CY?#IQ z$z)Og(kTzvFJ1aGGwtxQW$iaEWP9G0PuZ~Q_;+0He z)$6Ivz+X?ASX2wD>0cx+Se*CK(!psLsWu>y1KKFr)^=W)+ATxG!ljkTLD zyn6XhL`_@Nzd6uukIbRCeFE}1C%5;AGK!W=Eht^xw`oOvgLJowi{beR^IyqlG!}b2 zXv$?jQy}_NQtX-Z#NgSpX7v@%`@FqRanX_uav!5xFKxe4@x7|cVcP17uygC*aS3MH zt8bp}@%!Y4=^np5i)4Q9wC?-M)0=GH8S%|nx9{(go8Fy|Jl+}>>O58LI%JY)AGnWU zU4Tl^ylDltuE`rZKV7R8nd;bH_T}4Gk-2Z4)ZR@#$y^`ME91U#Gy9G&ou((BeO-s8 zs9~N?Oi@G0@RmWrgagYO9AZBF7r3clWHhyifq|J1TFgk?YY4n~^r-3@hI9Hxg@uJ- z>|4_LeTrNh8IJ$X5r4EKrtp;LZ8NToxwp41E7*7YWpIvl@y5ye!ak{Sx$^h+y?kr& zKS{rC>*Jl$AFhUR-#s>`==hJq7hyXX&)jZ~bB|{@z90-4OZQ zU`M+kA6w|GylsBED!s0kI1MtzUl~X4{3x-g<{iIcu0fpgtS-fnlM+V1MOre%+VVJF zcsojES0-Ipz;xj|r*9O)ty_w1`-5~$R)*4kQ z+|0T?@z{%r(eEUpQ{`pbL#@iZ+DjIC1m?OwSL9@2_fq)A#K^)d#F00_fk~)iu3kgJ zQkF^jjSsjvQ#x3J)EY&+6t=N6NzXVjV|sMJ)wXsU)`q!RuMRnR`7=7SI2A>B7|MD_ zoY1ZMs-LDPeB!8rj>@m&3jZgv*{``LFuHjMX z>tU{sUjE&ZDYCMAm3U0bHs^3o?w1X#jLecIN++^8ZT9C>U=(oJ#i8(xn^A><>4X5| zk}p#jiUe3D@baXHU+QYOsI`Pw(1EM*vbstr)8dNu{k1Cv@9}rOZeP+A+;jgTf2Q-H zc(F6=_xEl-bU$)>(p9hchW(SG6iz<>tpDl8nykIsnhPVvuHBj_m)3oWaciTerba`9 za^sfC4zD~FP6~O5O!Cs@6LRe3-EF~PaipQ5yLpQ;n?o#LP`}iKE9do{{=JA{$eTE= zUPbGN;Mja9Ofu+U0Ik zcYKnZeDz{=`B|^-<(%L7R=;`o>sM=EzO410IMMImjQdx; zntgY3;at()^5}%yZVi-zk{GDt$0)gJ2G8|1sMIUTt^Oj!0dzxv{5`J^S3Dv&l!- z1=j!nEUkS(ZeRHFc!&R$-#a2J+WeBgxL;KMU&$3=VIR8nN}$-GK+VKNTg|A52zNy_ zt@F=3{ewH!&N12={I=+n<@1K~0qW0ww8bp!y%BcnRR zi}6SA^^}0Ct#f)_IdaMUOrHPcEz>`Ty{dPoA75J1$fNf-D64sDF>`$5QVrHgOKSUm z?~(oAWb5!?+u6d(P{SDy!lq>YeQRL)#>CyM_|W=>FgD?7A7`v@Sml1LK;-JL)i?j$ z`sZO5niCc1_QRBQM`BcC!%a7vHd^Y`e6hdxPKY!30khxRT^kyM zj%`-(Wh@KW)4{)|mUZ_3Mfa;K?^b@&`{TX$?qd%ZiL2>Kfht`t6E%WN)tWDUnSX4} z{C&$#1T0D@7B7g8n-K_+yp*mKnrxu_?NiquCg;Cz)-PJSumM|wpGr)ECvT+1p>Dzf z&8Q_W{|j8W#jI+{z`!H|N$g1r*d8E0?`^+KQun2jqn=cFE4TD>t9fD~wY; z@X=i%ubOE-t;nn6^=j}QVWM3?b`KfF7>G!@2 z+sU84N<1(0nDePj_T-9Bi+^)m`Vr)zDzEkaerR8`he}<+-3pbD0r$LB`1dX`IuWLO z@~4XDBxLkI{L=ObCC1#IiHeSCikdnqCv;R=TUlndF4-_aVe@`V!rsj zw&q*sdAI*HwSIT+oMFfmsq!)Z$deB>J*uo%AF(m9H!Z0<<;imI{6%{~UjbxR*v; zYBPAe(yZm>^IHPX!q@R8{tC|JFy2@0Ecxi>j>5-zz8(u!^L`YPUo_n!$lJn2zi`R4 zf{wUH9=Z<&_8yrSbx5(QQ+aEP^A{oaD$e#5s(oL!d{yKWtY_q~TBu^Uy0;fw>SQM- zb&BFFjxTRr1=eOXgqpkZ za~U_exqUj%Fui=jtlxK4FPk?6+xL{`=H~t{i*C;@Q*haKJlia1qFClcv5QK(&F#z9 zxqi}7ja%|d&`IK>V$Tl&>!80JAlj{_Lw03ei-7VZhjW4-6((!D*myV|X({QLA>b0j zp`^wlDBje;>3F2wW1@zoOV=57OP9_g6)`~_LNoi1PiATIU}9_)a5M6l@8luH$Rgr& zc4!APMTtr#OvPE!e&>9aF0ZS*ZjY@ycn!c`k^XN_P^2{aA zgdSVJKGMyQ6vUx;v~@y~lSiTAk{JR)F&r9fM;0(Rb#Y716md9pXYq&2<~CkWbGw~9 z*iX&nd>Ndk#v&qqY4Ht#fRq!4inU&RjVuBI3@5`GUj~|RXw+1-@hL8S@Hn8Y;m~!@ z69NHV?Q46?BOKO*I-GfXOCTVIL!)7b^$W9t+}vD$rnk56I3_>age5&N#}ShrC>%j_ z`2XSPgaXZgh6fuG1Qs0G^vaxpf$1VNz1(E(kqZ=H|Dbt3Y|ihr^Q&^D14Xa&oGW(} zROijQZMNvvyVbec+s>KG|GKp2=G?0P5B)anzq;lg^WzrV`OC?P4r^){S$2CUXbN%kO?J5D zsZc4zAr&)!fv3a--HQyI(i1-k@d&-oFIlJAwtb0{-i(xm>nEh@nTDXpbNIjij7 z*2v`n=U%LHU2=2gQWM8ha$0UVDR)l_Jhbh;IBWHPp&ld0@;|*B_3oaXaQn-T3v=J6 z7_0bP7Z&tUaoPRccB7e`vC0m)oA0A-PdH0mP>#QTQty$H-Y0*B?MX?C<|+z4&z1{V z>#q6x#O3BMbvCKuC-XX|tTD}T5zd~&(4_g3iDQ|k!Vh02&p;*)zKIS&Qy7|lt4{FY zWcjQ*;hm7jGL|IGXpd9NLv1h4{#iERAeTZ0ThOfA4!79Dif(XhUGe?8&D+?D?|Ms3onzhTc68hgLqQhQ|h zJEWsyrMDe_;-6P(9ttzR)i-^aF7Yb=V2N6j*XQb~XI!6U*9BfLo~So#{?orPD$$>B z+x2x8CCra(ZaetmxQ>~auJrx6#u9(U(sOnQN*_GX^Jhz%!Lu`W zI(XZhnUC#>G^>j`v-!aLY_`MF7k_kazF?7Mpf^)h`H#kC>m=qjbDJ}fr`4Hz6uW&E zCF)8U{5o6oej?O zG=6sIk+)LvuKdnd_wB`sAODyvseCWMY?Ykio6XPN#g^pweC2p(IN#R%(!@=MSGgV@ zwyVxdaW7If6L@Dc+i;U!>f*fC0`)TjAKgq|xp5qqRMP&hC2ia*@U889&=KjP!}EDg zJrpfHyG!~0-_?1Cr8W0VO8ar=r81{Uhdo@=QfPYSz=TM%e<1HCPTOb0a`?QLgmWTW*-Yam zHRfRc>)V%rlWyQ##nzsY2(Bz)O#tGqPGgJX{yq^~U4k2ew0V-$kzWF?tooQGRKS zyNXol;Sam+b-dpu)pmb_;$QW)Pz@2T)m5zF%9}Ulm)06H81^pk%y8!9l>_ ze?!`VTN^$E%nX?*7R$iEbOo9tW|~eH4HRg}zFTX4EZOFuY25Xh2NjPN=Oo#Ce z|M@Q9yZFAy`v-4Ae#Fh!zIwHGcXi0ZL-QT}KVs5mS;0S9H(_JWrUP<}er+cOH)Qa3 zb2Hu1(-C5fN}4F5^XgENSIg>FPd2u*8&B-`)7yA+n?Z%f*W;z#0YGet5qJ{NAV zTUhj@^&v-<#hk~B(|i0qCko#<`Td>Bz8lAjU+nalXU8Hu?c^GssE7dHHEBKl${yib z?d~s{Cd)kh5irkbZR~`@jv>)`sX`HLo$WV;ekr(~5JYH9=yFMqpN$N=z$+IY))`yAN>Aw>Onz)3mrB^E1aiqe06kJJ?H-ULe0IEh4MDb z7503;vgt(ZgI61Et~H4l_1PCn^iQaZSkcZU!&52$i)Z7Bg%0{{J?!&VMlAuuC+*@Z zZ8z^de&$*6o5fK=UoZ5hSJxF6uls%E?^R8W0ddAj4*T`RX8+YlH3!kPWH>%414FYdT% z#(!S*|6tw~nO`c~Bz0~azp>E&|A93NnnjM(K6%6MqdTi&cbc8b(wCVThQ6z|3G2+L zag1xenSbuTV?&H^x8>i)&iD^gEBP0*TirNrv-pYZwjYi2=O5p`ZW>ciGcEmLpmoITZ-GU11oW}Et+4yZe?d zm1~RU8*uhCKI~K2&BwDa_>=tNACAcr9e1au&6?nNN6&fvgo{F(Ch*Ho?$BK?Z8xd8 zBU`2BZJPVl#`OZ`+tMcHyduXo8{Z< zxUheG-m>5G+tpKRZrQMhIW<@K9@wWir+uje?-dsBLa7A;*TN=bYOFb{e7Piody*nQ zQ}YkbXX=#}EKGj_56a8(u{iyyJMzxwsld*){n`Qsk5~1-sq1jL`ZeoXj_Lw`f4dg7 zkI&WfXNfsxu>TF!H-)5H_R*49fbI|zsf8WUx4%YgzuKNxeUpJqQ z`>%iPyKwR0z&Dmh1y)Vc$!Ys>UOvuQ(a3+l24n83xp(fIseiOAWRbS1>(Y>q{VZbY z&0MZ|BDzKg_h0yVJGWGO%T9%7hg&o*ecPNrbA1BGUbkCf>}{%d9;fe~y=mLVH^mv5 z!h84vB`>YJ}bmm9N+RrQU_g&d>|8tdSYWQ_- zhKuX8%J=LNjoVXc&ma@)zVm79u990TlD1p9$L=!e&^hRuG__!^(#o36cB)=y)YJ@R z)-ialeHy8zrg$d3jG1sXVfu*R-tc#WT7`VP3MdF3b1{!y8fWHu-w0(yq)7ZOZoTD z(f89;58R!bBdl^b@n?v|<^4A&u3jfM=RbSK`*pLVez}JS{@0Q2Xik#L3gnyfEZ4nY1m-BIf$MGg%f#O4YYW>)p%XQ{fkn z+`I6~p{vH1HZrVBTCz|=?w7!Q%Ze51`>uWvP~Rq1amw?X+dg~e2bxL|LO&OY96VnC ziF-|q_?p!fspk*7cU7nzaCfQuJ!M8kJ8Lyh{C+>>*H78Qe!dUSeRBQ&T$`GdX8VnY zxFuBQsehQLIPdL;i3;rexMolwO&2z@H*?#jNqcT z%KIyQ7%zLDj||mih<>wU3$L5@e9W-0k@mr3<+tO`2v`?I{dj^^R_TQvc+^3+oEX{j(%ER~A0vUy z59TV(^&8x01A-Trgux}-L(#FBrQ&JmM;U|pWuF6Q`A#6ii~46qev zIt6of{=e4XAQ181Nkr=b0|S#UB=5Yv&OBMpSA_M!X1C19ANy`>%M}%SKQFW=R8#MW zo8h*=TTWa46hBN#d-rAbOkwrUe;U@^t~G6TQJVN8(d*fSHL>-QZvPglOn%yXl|&RimZy&J+7Q=F4t)HmPq#zF`QLo8sZ6bB=$W@;Y*D@XwNrV$oS!58F*!{lMtO zr5}^@TtA#%Ui=+SR~vyy-fH`f$9a@FZ;X0+U|EvqyN-8yaK z6$PK2`_4T5HdFBD@{?=7aXC%x-hQ#WOkU<1*G|KC+*8w@Xn*#Q*ScD8TBz$tmJr+G z!tRM%4xatVol`&U@~`=Vd)STy+-Z!^f4n|nb$~>slZKjr;*_)g0tf#mW%)FHxiTZ* zi^HA6*ZRUXHs2Ds8Dq6XAXZJ*O`)x-ARljd~MOwD(;M+{Arf zD>-i!N2iO@$H_Ge%=wbybFS%w?qo#o$usRDCRxK;R`}C2MD~h+!Y+8rs{jA|1cUbi zSGQHTE5xpNug1W@WC}^zTW1~JDB~#La`cSc9~ptg%uL)z$_)>@76@neF|muu2t;g9 z->LenM}F^m?N^ck?LBvE?#6Cja$;MnYT`6+_CwBnp1CE*PJIrlx3PG#aGw!N`<|=e zWyjLiTrNMhP*MKt+`AJcrO&;#{;MOEZF0-`muIkja%)}jlByG)f0wPEyYbh`y3LRC zo=({MtNZ#?=ViaTV@r*%y_UZh&TF~4euqfMRJZJ@-}Kp;Ho7f})od2OQ!5$%VZw5w zf`htK7wg^;@jLDN@XPVarIyU*uAy7fxYEz~K78|RS;4QL|68-SX!P&YoU`nZ$T`8d z%yUb3d2MbwysRMZvsZB$W3a>t+4&(4(iFnFr_DHIc|iMYrnb*RndeiV@$9)&a8UPZ zOi$%f%iTLQ=lrwizbaX=)RNbnwd>mwuPOY;S95QiWj#aF;b5+CLgOr^9go)tOpjRF z*c7dOB0G;OUEGkh;CN8twkJH1nrA-tB;1WUka$sE+Q9O|uU{|Lx47@-p10XSvvP~g zwTi&cdDfG(^e=qx|0sL(W%^2Y?u5sMp9;0>J}{>*{a0}+Q9{J5qFf_h;K%FkV%7hb zME39d*q!oks#x5*$}JCMi={11K4l!d{VwYthx46_OYM9Z%S~4HmmZKU(f=ekqsi6! zShZFHm(be@zb^3Jx%kZXpLj)=Z=jvb{WI}rKd1)&+tsCiZicm9s*W(@?K>iKOphMc zFKC~wRR8kK_4_}&EB<*h{I_8IIPv%^9arz|2bL?xGrW1n+`D(zj{R6lX4Z$qBw^T? zufu`oM51XkY-$m!MrVF#aQOcqV8ekl0fP%u+pKOfFtCO|l5)}lV+mHLV+`lcNLf{B zcN~gi%RC&DyES))XXp&eOrA~aBhy#UKREUE+B+>XEdzzq(lQQ5FU>zZ>$7a`xzBUz zcfDTxQ)TbY{CgR5103#b*zqvc!?|l>r}dJ3{ekx0RqF)uy?6CJ@)logKJ6LT#T$xi z#TM0yxmd(aDT!AsdYH>LNl1LLmZ!VJlKg+_cGI><_&s|&P4UguM;n)f{%_U^T=QSu zZu$~a@h3u_vko>#Y?T)j*A~frciIV&*=8LofT zUc!-Sxc*uD9{&^H&)ojvT;!yec<%uF!KFs`Z$7*Ku>FmKi-71(#f>V)<;@eev0P?h zs=U7NPSxeIhST2!6-&GNgb(d`GT+8wm&n5vLYJ0iR4Sg>&Hrfrxoa#Jxqoi-$!U7g zdd48%qj0|brgJtzrCsuyyf!+VSR-!~uV&`>Wm-k+1j}g^_wu(*nb4DTlmDWiNXwFc zyepn_>|EEv@9zI0#JM2T<&T--W}QxDf#zvPA4c~mHXTfQ5No?_Mv>gY`twS5GM0M{ z7u?>~!GB!$%Q3aRg`6KBW^na>wWwgOIBv+5zvV^mEYAAnVNG+F^a|O@h*mAGU6FS? zu`D6-z4E^I=BId0|5C24n7{wn=905KAD!KMFCOeuzWBkoPwMatU7_r{`|df-p-xsJ z4_^pgdiJdI&jd{;Es@?_#gE?WZ{_r_+t=*WQd9JFw(x}foW5NxmC+*o0-rj*O_#hF zxoy4K%yQ174Fa0Fx9z9PvK}{lFV;0@!pZ#G9DA3Y-1FU4NwK+e?u^F^-WjbwHtmMW z6N`_5T-GY8r`Ju|;qYkJ+^Nz!y!H!TpINPRzQg#NWU-=+(X&MP&hO6iY#(c;wZ8E^ zBRnTo>V)y52}gdf>3X%f)nl>I6T2=!#m=>|We4~+#u(08;5hGb#s0+gYhCr2*x6#T zCg^M4(}}Wr7kfC7>BQ^|9?f`@$EC{;WJYN^Pt$zH!_;l-WcV-sgw|0Z#my}#IjO=E zxObd#c6z7m5`So+@C3WhLS4@}0-JcJPgQhR(61Fvns{!)yT{k`c_$Q$eBQQtM`5@;xQ=wAJ4*9hAnO?KhQ);^^ zmw!^9S$oZ*a`SuFj+sK!^A=<;k5AgZ+`WKJQ1MRV_6uj4_VDSJPxEb(xh8zJ?0Ea=ebb|$YpP{ezd1`tDs}yuyp-QBVt0BKpX9?1_Gw?1 zhVrd`#IdGhQ_#jGNA+ua?(um?rfz>e|4w|^i*FNC3ir1c3JIM#XPq)pZC$;7gw7+K zWAXEE_X$3n7nN|)wQK%DyXV3|alD3hiq1D@&zU0ea{lF`xyMwEMV4;U$TbTIXi?t# zVbx;I9Ebi25&g`BlZ-aLsTrp>ZT#*pudN!}TIc_uL`Wf@%NN^F?vCXi~>$&jtbt$wyA=#A?Y_a zrwiu0O=CFcXts#iT%RG|Or3*6TzrkoPYvw`2g`LnH+YnrN}0~vIi;;pTh=xCnDm}X zX~_&Jg#Qd|t z)WoErBz7?aL%UC>_0eAsCSWV+ZAdBUiMeJPqGtL>cUgEzFEH!Ee*=dog#!&AHasY( zyskf!fq`W`q@;g4gLy-8q(IwmwW&|m1tnKsGxKV`{rSh2&DMe{?!HBD_qq$G z-bl;O>f$M$*l{ksTinzC?dA1CsyCDtq%04()=Vm`OpQL5zDaStZ}b`URIR=F-9J@)m;O%7{^_%A*1I3m zK6&2sWnWtBI+ORy|7AUE=iGdySZZc^Q|)4?k@t-CeW%&F9=tuJcJ<5OGk;7iCC{1p zUrxL;dHKnc%W{n82l=v}G%%3cdLFE^Stq;7D4=5+JZT z_8N<0`|-shp^guv910AJ&u|}I?-G4-wH3RsMk`kd<4yLxDT?=fwQfFsaOcX}Dg|M$ zSAM2DQ{SkcWZdPrP1tfF>qWWf+D67=5kPLouQ zc+Wql@SaW_*K|4KYkzaA!p{C*IlVAD`R1dHhcdH|btfEH|Gn@CHw%Y&g~`b|6|c_R z>|gV2ah%Ic{-2UJ%pad-laZd)>h3;esmlGsch_kePQ0_koON;QtPH7Im+ecmrbReM zvKd`B+psKg&Gv`EJI<-66wRqxHRn-<{3%~k?hm!cwY97F{jmFabotfAXP?w<`{5#) zvM;;Ge-T^F`yGwETV~yjFR9h(e3{2I+hR-Y{xZumX4lHPCWcRWeYz&t=|siTRdWvC z4NcX&ZocNt_g@Mp+oqbb#}pip*AQ_{O*E_ZD(O5NxW{eXM$Wi*zQI@QopuFeWmL{O zC8oMERI{x`gk@KL)1#FgA}SZ}JeZ}kYOTCGkrZUxd&6I?71}eMXeABE=Sys32P*0w*%9JSar2GpBYjmr2 z&w6yHKmJx-{-&E2_ZA30lCphpY36f|&q+d+)8jPw?f$e)PP?BUdqnye|I3GG_FS*N z?00Na)b;msO_Dn|MmYzb>zlRl%a1cF1Mk(IW&3{a4%aRglN+Z$EkAYnTj2h6a~Z{a zFFbIO@Uy%vq}~6ZW)+9m$%7g?58k*GHMQ0|Qa)RcJoID}DF(VhGC$$OEC z97{UZKi($#AVX`BJX7Vt+Tw^qO7HXzTyFa9cVJ;qX?pNW)gA9OqL?OgPUBQi&vkHL z-m-CC0)q+vbeRY26-^6FOiCp-TJDjN<9{Z(UG`gQoWtK1_ngV0;xdxYHLT<(A7kZs zE@o6&+BLa#d+d81&Iuad?zqe^yX!ZRC5%0;>2IiU)x^0TZZ%gbCAz14Qxlxucw#B5 z*kqrmnk$;}sfqfj6FODoR4blb%sjqAJ}!*2|B(J!+lhC6@Lqcr@}0GIr}@!hyKnKm z`#$ZM{;__)|Ao>eQ<+v;emLTtey-;G#NSQZU;lp{%zue(cA1jLGGWIToBUWjTXR`g z#uv}Lb+o#<`-<7k0@lC3BhG7WVdGrO{N0!jOCic)i>nYtJ|@Zux@3kSXAve+s9Tr1 z?0Cbri?fd2+JEbX!^EBc|Nnpg?WaM<=JgjJ36!n~n6>}@+t248zuT~v(~yCIfdjn0 z#=xQA;s3P)_TG0D7#NrrL5tMe?Xww1HNrN#n=#uKVM?K4gs<8OC(GTGfZ z=m~SPqUF0I{B12erXLje-WC%1MBwkiRX=}ei9|{8a_(8&^Z(LkofJua!_LApmoqs2 zv#npjI5Q_nMrwlQdTI6r_lgdQNy#~uH%`6#W-oj8J@0dO_b95h$TJ8j{JpFo7OH4* zS?G?IQ_;;YGo@Ir@94bT@<|~I{{)jl6+Rlib8q}1&pIhYL0j38 z_rw{81ECv#RCRRgdUhWxYVwu4zozC{xbw0bGp0NL>1S#*bFZ{Kvd!_%X+=kaF#gsA z=H#tSPQq^&uk@L>_s~Lz;*+-<1-4v!v(GF~=E$=D=5L!`wdvQ)Wb%CN&EWXIGAeo6;2KJv~EdL{PV83*n#Jx|3A6tS&E)Km3B8aG4G#m8YHH8 zq(jZNRY9SJ<>D(&C00{K%b+zpj~?BRtY$sKwnW@1C0k5d(~Wu3bED^3yU(6dymG-- zTx-(JI&-nsgIwQdPI;OY$8gY&@+7eWsZ)i(9@;tAhnwzJ`pRjbrj>!%$o~<~(taIVx-5z`kx7Ks= ziZ4i5HEF3l@6o!?tCsotcijn|$e}P*#qx8BGlc6!e|{Gu8~`pM^IzZ~rRzt73<>NB?dqVnX2 z@Qugo43^ILkb|uh`9Vx6(gH0-Di*IrMztN?$lQrr_B5>A^z7Y-|NsA=x%=SuvzOn0 z{@QinYHLgo95qJ=w#Ed*xeetd&6&xS^Ov{A1XV0vyZYFf+6e#3dCMEhOX{mCqum@K zQ-HQ+rX|7N#)by`o%=Hw7#MUQ<&ej+_xBY9TK*@%?#FK3nJ8c||NZ~-4gde&Klk6e z`2YR?=l}otU-e6+j+cRf`8%|%y4K$J$VQ^|p)L%LC!)Cp}QMx_wU$|GAZ-;w^y$|`Am4x_quz3u4|{|n)U1Fb_?At zEPSk{a%SV+9T!x09dC{RoTa7uBlFJvGzG6Tc{ElI4w0)xZQI{a@3_Q zbHCSyIapOZl)KYoW~VHhtAFI+_ldn)k>?g!nmO!H*{2*M^p0bCi}fMZ zhkZXLz2NgLdg&wdieq}r&P>mccBP$#i&geHPqB&ZSN~;n_`6Z@oL0+@mMt?Z)^2N; zweB$8AL7}z@l3D4s~=Z+7cKrAV`O{G`uUpA&V27{Rju}Doiv>G-@Z3*+nt4;XAY{$ z95QbAG-=nkIYHA;rs;@`i<8>xs4@dieXqufXzxlP?5Ri~qQM zdSg3Tp#6Qh%qF&ylgr-iY_Z7NCnCofyNPi}iUQm*(-?w|_INjGUL= z5%5s`SH9urth_dvGpSER=+TR~&`#*fU$Xv&Dkz!DX>CA*plE1TxjDKAW*>y|Cr4sNW7#Ud{W{`(YwWpWfsR$IDF| zj5;4}*wp6{WVxozW0tbj9|i$VNB6Q22cyn+0V*qHu07~i$h3MjV_njumcAcCuQD1{ zgbq&h2`Y9s^1RD#(a_`>WVvRV_ao~aDnD3snq*^`w)Wj$z~-&h(b}&yT||Jpyr7du z^RR44kfYA)L$WTP0@&ZazjIKvM){%8s|(tt?9*AS0>1BR_AUX%*7Sh(xYgD>T*?bN zUnoopD=*+IH#ph6kH3hsFoV~1s-lzg&96BLhpkIrU0G>A`P39sH1>GYQxM2{|^{^xUfMXp#AT>ItB)oAV^_!<)-V7$7TZTA2_%1&sl$_=em)x zvGL~p^QQehZ>4$oQ{K#(GhYU^wN5_Gv%Kj2@kvYeocMo1wGHv91m-HVx z_WRA|t6WAshqf6qsJQbR`h2X2FgD|mOBRcI)wo!s&waLJqVX=qdF`qWoR-lY_r9H& zY4)d=sqrS|M?E?hh$Nyl1;c_uanNHSCW|f8Mn+ z&=Z-f)l=d>F;uRluathkiPJ?X_DbI^Twl&*tWn6?{^EXY z&J)LqORL-Tbqn^jXy~}je#RxVL}an*O(&+QaxGKy6c2{AmM-CW7#0_@x5GH9;jyLU z%iQy-t@oZW7<}DtaH4#U$Cq#0^Do!em&ZL}GBdehBzes0ov2xhZ}M!8zDW%4-xnWv zb8~aNi}&O2{rPVHTHJ;~3u zYcrc{it&fQHLqkDD}41HJZ7G6ZPp$d-+2G|A2 zYE&-%IsDs$pmVVg4Q?(<&hDJ$smeFyY2(X@H_seDx-ooB_tDQYZ~iFnHxGX^H%IYz z`K*Z zzpeZX=O@<)UcWxi^G>>d-DI|O1XpiJ{~5NFbw#1mw$m=&hyHIm!0n*F!R}#V?dDIm zUD6kgE`K%DSopd7y4SwKy_);AL%ScwT-biP{fUdWN z%QkyKd_>-n18G@x{fZ*%QVcu(No+S``?5u#>eO#fl^=OA{Nc)Biv8om6x6E|Bw+C!V?A&MgTXB~~Xw_q3 zInVDRQ!nXE_$9VTrnL8^ zwD*-ST2sDobw5N#zK9%KzodnOc7_{3DqNt*f|-hcNR`9Xb(Fi zTf|v@Lp6(i`U=^YMP&t@w+@oaIUyUf2vos!s6Mcexu`fT0OW`&&O#4}RS{0IU>8|G zn&7p=S^FX1#ulq5lkPuAc)#=V&*>I=;z|>(J6zuVhz$Cs`BbU!$_DPTn1AazwtKYA zX-g`#nUuFhXP??PV<%mYqc0ThW<;$%=6AeKm*eO&g-JW6J+(XjV!fvt`^28py%W^` z&n;U0cxK7s2QTbQ^dEvL$Z6=O{^CPsL1lE8CqqX+OtLI z-H*smDFq8s=Qv(^_&{hjbCb}!2SV>|C_UuUd)UV-^zOw(nTv_j3*47KDg0gj=FYN~Av zDf3(Q@g*xW&wKvjQ*OvgtG>_A?>+Lyz~jJ0k9Xhh_98=SL4>C;ncDGFbr=xi!abk%`lghEmhE=wOB_2F|T8%bSw*~k9b&is85sE$$ z{C@!(`@{oFC(TwZZ<|}?mo{Xo z3H;7YxKog`e&So9%L}_JuIEgjA-hiJ&%(s%5qawkf6UssW53Q!`)Zj9e`S&nRUgs& zIp?F@k6$^mZ4xT;+2AG1->Ik?YAL0Mh zb3*9O@t&6b_giMSgni`SSinC2L;tSFk1ias*E@7SPvP<&6JGn3hG(CdwZAzQ?zyWj z?CuAa-E#ZCsg@s>&Yh=xYeDUSt$+VcD}JheHurEwh zeQ-h(d+CR-LVSjjkxCY=CKD1TnkEES3BKEr+?3?uu_NWuooO$A9`-rT*&e~Sah2lY zM?veH%|3cJGxK#7bo8HC*1o;hxoz{@2WiLVw#D4u{nfzY$yF(D^Md7l;g1Ye)_S=g zNKsSnbbj-(TtvCt>ztxs_wVBe_Pm}%J))6 z>0{sL&2=0f5A5Hwl#Rl z7>PL9=%_t15_LLsHF;i%bA`2)^aLS`7S~pRUsoq^tV%!f*yyRVR;+LAoEnd1t8168 z`yg*tG9&Hu{ndNC4bIwWJZfaVIU(YWwsMZ(evV0ssf({~pQk;I>CzuF?RhCoo{3v} z!iyLT+ti)ZJCA4`Tl2$HHc4{bBlkiHfh7C%CyyL^4riO@-fNii*6L6sQ{dkk%V*a( zkGR@&rLqJVPPqE1%iwU+o+GlC_uR|cn8aMD_Sophu}}`q`0(GZ_9{|u1?JTkb_DNn zpW^&uU96s|GDmyKXW2Ina;y^CDj&@zve_wzoU5M2Wt@4syJwly zCCii*Z9l%ds7@~P2$CtS2sUj9-WeJhq4=>P@r$#KM*9VQMcFCNT8>Y0jo(g4aS*&} zt70CI8rH$?diSm3Oo#rBoW>4MOE+}I87->nh_^l`s-WH0^Ih)Vjq)p-{5)>VDbBVP z{n_)P>w5A#;YIqftu~6nUqs_hzj$@Z*x0OsbD{PWu?HXHzbQ{sh-~4>RCmTwD6sw^ zrckJc77CC?1{xXZ>VPH!X>bHN+Cmrv$&b6$KJHe#vBcoxZnd}D)gfGDvj4&+&_QRK z;3kVggTwz>0p|r?rW@>EfBygf0EPJl`|rO`Sl{2^U|_K9_x?+XqA&luv?njtO=4hR zWrq|vZ?3Wy9Wmfx4Y>KM%dm7?&Hu^U=2gAYY2}JMAsy$j&rvAXZ1&k_pETB*UjAib zv~a8Gfm9Vk4V|^z8Wr51j>ew4_``eWnr%6rJ6g;pxkgRjHRbfG#?v>1+Vi`@L;@;* zN$VJL`Pyvb?|Me9L*Mvd%tA=EyvbhesdqsNdsbJ@`oB-n$ei!e}wkkZuYx6EXS86NGbl+^dY|5^@1!f_c z!J*zFZ0`cDFa6@O*>?FG*E=iMe%Kb4y3{-L=;V{}mzQr>RS*6rvBxF6JicbZskwO{ z*YN*a{E07px2pQ&y}^Prt`NRduE+MN2$$bxO= zSN3<2g?rCfiCA$QG23(d-uy}l-OW9UvMfo`c6Sw?NABcJy~SI2^Ol0Z?GL63vx}rp zm7F-p))+BUY(nTx-c+k6cR?J!%q^PJUrs2S;@BMUjIYyd^+F@giDq02&&UdC-{YC; z*|EitBUMO9dmb-{9mtU?RJ3C2LLa9ky^b1_CuB*VQgOK@(PG4@xqYFJQ&Pe2c#hPD zDYpXHI(V#}NToI$>GJ<-1tqmEMuus5o!QDTyXu z{>sm?&U>C}ICGfUK6y3Y+(kN-$zjx%@cGtc!y}IO zmY1DnJ{c*|cF0S~O6GxnclDd!@deeF6GRU8By!)sB9c09-qbcZ2o5*>x`FsLdj~Lg%{_sg+)Gc`_XcBWon93)}MyH z)t?bm*%`$6BeZ? zZrQou-W3hOntcYZ@9lifsCjlCW5J=y^8vaG?;h@F+ut&Y>9L4u&dH?*EoX7(99!w$ z_i)R^9;W=j9EGQslDS;jBUk=j<9N0t%4hkFcg}N{H}-tl!EoY)NAer+qEi|OXe(!p10n&duhpG%8{KL2B0 z`)XP0-g!AX7vEc7*p|0zS(3b$TlZJfi;Z&OUt-;5&ukBVFwL}jL0|pmq%d|}v!^>{ z4)5OAowt5{!Mr3};X7Qab7wE9lUytX_jxomj;8E2NjP;i>7zCU*YFZthWkQe0#fe z?Ue~-zuWKMzi)rdZvVgUKR0gs_s`JB=E?8p&p$uzJ}mL|_r7<6+&?A%*E-JMpD$MM zJA3~cv847!2CEv*{MYZ^CTXwaj&l6}Uq6pkVos*o_3wKYR!_Q|b}P(R^{u_jlFj^= zwoLUbss8(qVTt55uU&gDuDJa2%Bo3!&t_ba{_gEC&vR|cmHMPP6CE#N6o6Kz0Jc6aEU!E3KF7SC$P{~pxGylm7p_%hi zJXWr`_WJCzCn>8vmTbJa=IE`4Q!^GN{C(SSD(( z@Db^re?aw*pjtSm$Hch!m0Kc~3VI~pVR7Qr7M>yDrO(H9y{R$3(>*Ccs8fAgUvBii z1xc+xb8d90mpqtgr|-F1)MBRpkJbrOC7*Eh-&vJa-1~opf#Wv6wq6U#+qb0O6)3Jc z^+G7$@-wGP*R4Hq7e4HpL5{QdQ<|LT;^1t}KG^NzE4t$Wct z-Jogx!<1V*MXeo)UXehi=Jptlunb@N&et+&ZGa_ zmHp`*4i1rmiSFSsg173E)-k)@$gQaFRhnaZ@ze)bAvfum)|28FC3DYxuu16_@MHR? z*`oAirE9yLabSzRZiDH{fEGi0!9#DJbtXuMN$%rV%Da#!p5@%qTM08=rg~^yWjp<% zMDUaK;xF8Cu`NHudJF!0II)PA^Oc-?d0Rqwy`~!T2+1MN!={>3LWx8`g_N zR5lDb(8{K4!K(6wtIHOyhKy|DA*p z)6OeMzFc;bfq~@%r0{)vt9{yHD}MHZn+XL^0@P$ZW`6p2zGC}ppQJ4rEyX`h{hhn5 z_W#C|M1>FQTYAoZvMG0c_{m0pZTr$SAN&}-H9z=8SaBF`5U5G`AKbJiQBq8P%{1Ok zf3}_c=on$vk#JkWBQf^S4zAYQ$F93F7yoR^J;aoHdl_fPjKemm2j0(V6l9cNdqbw9 zmC^R`hv~N*c$8V^GaJ4*{W$y2;@ zubpDCs!T(q$XxE?f$JeZWF%`Qa?Y6dYRQC$#uW2`pZjPDAV;Mo0lh4J{ye%JHo#1{^eED8| zp0CFX<{6#2btv`U%&l9JKjh6QoBnx=xB24*9c!51M!(_<722i#_1o@0yM1a*mOR{d zJAiMd-0>@4oj2U*^4|EfQf={9f!9;in`h~s*1NT}>s80`wFd*;v-n>HZ|r`>l~Q=+ zev{nRWrUe>tH!MdTFn9e4dl}2Zp?qsB%eI2@0h4s$o6YMt&xQqUZHZRK9rQ-80&T7Wn z9lD?YF@C>iBJD21V%~mu;%vqDY#j4bek2LJXEK@*wzrPKV^T-6!0xPxqT$bYkKNg~ zBmb6Y&&StN$9XR{9njFu6RP4nWsoXrP?jjBQY38NdD^7^{JDOfp6bcD4_28d7~EZL zo>0TFYinPS!Jm=|;SV^P8m7z@ep35W!DoBfe`d!7zX_{%n4EquB~blNM$=)9uYF{x zV^_=dSr#448$%DR&bNPF*(=Pl(`?gckLC59sWQjTof5vqs=QF-*@~IWo>P`|7N6+r zI;Ro8#pwI&>$~j?&42d#-sRZ8{GfdA4h{KFzoh~z!%n=sX}wqe-qY<5Cw-d1#kpVQ z*Y1MM%2`sK6`o)E*WdVbqk-q`BpwODDe1k!R<(&NPX(VS{56)B5bVFqR+=cmT7S~_ zx?1x$+xf1wLaBXXZlao#d5q&~qNYe(dYaM7Zv6M&&Mz8?jTaX*Jn;N+VWEraz9&~t zywG3ubj63w4^r>Pa-It|2oyQE+jai-L*EbFyeoe4#Rj!Lqc6dSPwzT#Zqp76S26kP zNq7Hhzc_uNd!J6?siwM9#$V6RnjoZJ68qozx}yFsv(@LLxrJwK?OfNYImKXlv=w`y z_j853moi6m=QdBVa6X|RD;=;pS3xy?v0tjfTBcB@C1L@`oukqo$~x<4S$b%@FO|Bq zD&Vw3kZD%x1d(GcH$SC+&oX$BJ1_jGzFvGZ|Jo1V!g6*0ERj5>plZHN;Sghv;zFmW zU(ZhZDn$vTz18wqKC#|MeqQBW?NshVXCA2iZJ2)L?iT+&?`GO~h^s{Hn|6L-_oXg# zC*A&qL1BNI43cj|R&ecK=Q?@eq3!GnnK>WTY0|N_mGu)Et%u`t0 z1={{^*58(Ud)r)_quZYCzJ2meH|Pv{>&l*7o7oqylw}pX`YXqGJNj?Ub+59e}7gxpghTh|A1guBIoV<=St=%Nz|M&%HHW0->3Ui`OM}U zm*frdo9y|sf4zD5c^7NJqGjjR4|McwZt%Ihj5onqaxR1MvAYjsxm(K%Lt=zk`TDxv z$c4qP`{dUnw6%??-1X$`-~-#ac$il%J9gV#d-?UFrY_%7o_?9X{^N`L+0qTi_umf= zVn1;Dof_jBjh8)7KZl0jStAu^J45ZJs5w7la?u~AnmhZitDAUE3vKCHzhMid@e2&uGy`P_29P^u2Rex~f)ueRq;&)T)7c0p{YMh9* zQ=IVT#?wO+*Iqm0@m@W(GgJTM(FMi&wWnnNKb`bIXT_thUU!)Gy6UQ*%q=PS*tKf& z9h*6>y2?+FB|GOYS$E>Q?vp1QZ?4W(GfCS0h3?2?lu3N z@tA%7la&3wi`Si%{_NiB{xpJZ&*}YFwl&Qc`1iX(^?RD-FWrmt+ig#Vr1dH6+3VkW zq(aB_YQDR{61{jQt4cJ^;uQ!=gHz`@hp5+zjp8^E_?iv zxwF~Dz*Wge@LJ~$0rnZM@87ZQ4su+<{U}wSr1^ww%YPPU4h5$RJdG|a;erKf0&U3{^Uj(Z z-7D`wDMiGUI#X; zJs~D|_{E>v&nXid>a-{FG5Kv5S}FXYd9QWUkL2H?*Y9-0035I-vMx!=Z1 zP}%eRCc&JWp?ZoG2C*{6uZ%m0wmkH9@={;4cKS|%~cO0jos$~!kV3ynYz z8z+}(_ve??UDz&GdMR^(+e{W`84WRVs_9ywxBrMZ+W>Y znM;<$N?cWHy>op1vW;f8Z`}@lsaRogLQ4L`7VYEDCF;s8%`(a*DtsR1%FLVc{^i7* zj>$_z*K93XcGAXaiqI4$)|{h?f=A}GNC^I({r7yFg#81%m&>H8TQ5pIdf;)#W#Yro zF_gm-V5=702m&1Ta&eU`1qm$OYYEKTV<6mjKhOW?+Z z&2t;p-4~Z+>d#vBy7p=Df!1k4E?mEErA?j{_-kEolJKRu&L^E_N%fR8J7-5Ok(zT? z>m%E-$+z2&8c6(emzY(z)6Y%F=B4l1*WZ#Rnw>qa^}?&*P32mf9dlf*whArmxzDxi zNmi?ueYZ}Q_BL5xPA1mq>aSbovw44&s4eC%Y+YdTMQL%n>$0y#$@PLl^O_I;TF59? z*{W`AAt0Y*qj+f@U(KoileJykWR~c;c>S}MFTL{5rFU`Pr(`o_mm_B9m?uuxoXG8% z;u2P);H24bBFf!h`%I-b+$Tg#H+Ro*ey)};xBSJvHA=2l<=X0zse5OKF8OP4#i2*( z=1nCgk?lsEBJYg5a!P!a-ipsYt!tjEd}7_zJe@-}szFv>Ga3HXU+EE&G_>`2V!KQ8 z=$%*W!H#>)(!7*)9%%+AU6wGo+IRiq)?I;{tIVTPlhWUEl~voOZn&MF|6-T#@uDk+ zRiC1i^}SxNDcq*>X8rPu$HE>h`f~2py};sM%v%j-7G?#mu99}XzIOJZJ`?lh$1CbD zwW=@r;B9sIh{5A2HlJobd>htT<7PIOWAe$TeSI2pzhyps{q95d{bpgAry_z03UBJ? z@LgTwm=YzX)O}I?!sN&l{jV(lgs&QP>j-W#>p8kWN1$!fv6Ky4*A`8US~jDkEC03H zJkg86Qf)h;Lpu43cP?aqx@%4Bl9?5zQK#-C{t~&*_Uh5nHMU1w*DhLndj8qDyH`DX z!+%`*%J1~txz#sh8rK~)yAk8LoTpa(&3ucvYwzy6?aS8P7yCgwdsa|_q0EB#so}}5 z|IaMQ=sCILuXyP7Up8yD{tGp&Uio@P<%bo*366)FX4}82NdNqyz~;>j`Sf1dqW&$e zPi!}MdFS=HRIPO_*c7>`R;8$QtA}jPxk*V+)W2I^(|O9zDYe!1_v25Sll!MU`<1Vp zyvw}j(NeJoFIi4q_Y^S-;8|lX9Kys zNoA_m7J5D|Iv--^f(~$&2M+{TANViup+VtJ!L0W`qh9_0|Kj`q55L}R_z4=A{r}+L z=CV@^49w2ZBKunEtRo5nEr}k-*LJFZw|^le^w;<8nGf?64t)<$;%HL%QJ&%=;>jqk z{zbWyHOi|#h;iD)iJWUXdORFFicz>%HRB$j)2fv39auO(rknL=~&Vv~jQ zJhEp-Uy{n$)fK5I?C1IVhr4@Jm-lx0AIC4uZZVG7rTkwq_t1utn+~cum*?J?k#lH6 ziLS??kBYIURb`kj&Hb71ZGM5<@shO*zweV0zZ7N{=^35ya*@zE&)Ywely%#eR{QSw zu!~>xzQ%T`zwt)bzMf)S%I$IEt#jRzT+>tSlYdpjsVc=f96DMk&v*OigIv>HwJYwN zw*F?k@}Als-#wAL<{%=>1m{lDf%X>FdIa}e6w2`Fb z$(ko8>V9m=e!>}*d}+c>(?`*Z=auCg+2&^W_JBuGi~iv)zeA*Jw-^?^`5?UVwyW}7 z|HRw;H#;(VneIL_Q0{fO@%^x!)XQWp>lRo06y%P?AEwjD$ zrtLBf%e?fJ(Jsl6#FR&^LB?=mSbSSnGG%WhFWpAzbNOGQiNt+O1)`70lmA2!(_xJ&QD3od23L=MRS z_CV%|k1vS2*&MpSKUMI$ROPLOn+i^NosvCtg@5jo533i*bG^Lg@nVzBA-ULT?lYFp z72~(>UpFDY_X2-wP4=E1_y17_fBNoj@$TKgFFCDWrhlD##8>CA;_KhbA4F|Cwz;#; zW7luHnHlf-dSx7LES~+>S|QW8@k5Ye@S!JLCLX@rXFliG(#fnBT5ogq8~9sa6X@mX zSCFXNC4XtIT=#nJid&q@`%FJw+;5`PHs3)!&yw|!S;~(`C*1q|@9HENrzo|C+KaH8 zCjE$AQ5W&YPThHz%|YB z@5O67mSHIvm<4ea49ML|O3sE%s5H3nUtq$AC$6~-d-d$g|HTDd;L+ViM+b&i|(ky|SlT=SFMShgxo6HF(440>DQ zv?_K-N3?b5imk!v8_QM&WG|na^fn|QdpUQ~+Ys64-IhjPZ*N`BuD&X>yye#1N3FM( zF5iCg%vZlPbG2G-EnR-SX#ULAL2Kvgb!-iGTsv3KW9#mt+*^a)*36x@RwR45aMas# zmxZ&I3unE(61irs)|FeCZfk?AFK%kqo_ecuRi%%^+e3zaZ*Li{iM4Ipy88Hrvab?# zhONnSZh`R9c5KG+4eyz^}jDmS6n*H$D-!S z7EXOl`>a(hpWh3-h<>wT-Rftv+XH-ij>s4GUkd!%{lr@NhRWv{=M8CfdAuCvSLI7p zo3`pyE$(yOvGv}HTETTsWeP*GmiNCBpC8@Hk$Wc8R?Lv?+(@;?4nj9A_06}~j^?xX2fUWuRF-@It0@v5*IW{>Ks zsTXRdxu<@7Cm&oM5ejSR5Ev|JL}mhKn5_W!*>!TCI~wG0f5X^W5Vi>mE`)tQsTqgu$cZbAgeH($gtBPJfyG^3dzk<;Qo0ocW#DWB4rE z@%MuV3EA^p%%j@1SBn~Us>zn?sCu*Pmo7LTmD}?F#UW=|p)h8-NbTtbn?AH$EqMQw zecl#{SFL9rWnMmHea!e;U&~k7^HBm}n)9ZgzTfeGZHh9-_nH6SE1y_sa7-{`YS(i; zmTaNz78W@jw^d}WCH=Yl!{)rX#o6xD`WCvM-S0i$(|cg;@!wMg^q;D8cz@CSXrZ|@ z;mIcVvyXSYZQdw7$J-%N-T8*{g!-mUE^dA9U;eN@fBIiVdQQsk$@+iQ*ViX~We%_w z{ov_oZ~IC;YhTI>as9tWr^HMCUUOP~^5K0Q`^-O$msizsue#5(ddt&44GZj7z2Nu# z^JAI4$E*G=e+t&xJ$tP$^W$p!F(J1~*(3TVeyB?BR|<~1_L1xT)Xtc*tjqpsef=t# z++(=h%1H0ep4Hm>u#|+1uStn-MMA*#TIFtdd^;pm%|0R!@PGXq4fTn$Rx>a#X2IfH z)tMzwg!Mu9Zj&Vsu4(MB<}LS)P;xqKX))2`u$<)cM@&nN ztjjEwm6bKsd~`QM_MNU7Pq+EyinP=q8xFl=+^c`e{aY-!{%ZI7u8+sE*8NZud>_#( z8qe}5mRo60N8X!CNNEAIdQe;-~xTGgAC;i`M{!hvbC zv)8QaXpJy0^E1kD)x|^}j5^mD7#Iw|Eop&-RoDN&-(P0XAD{qkJ%b78+6FKiLcE`! ze11>k{Xe3vOBfiKXF}58nPbYGimYR9o(jKZ!bEtQqXBzx1qzHGcnJJO>nM2I#XxF=4;c9_HDZlk!)skmA^P^X@ZoSG(=;;8OVJn~Pk)>NIf_B|VG^NL-&l%`~+OS*)1YWQ#2{K=uK z{M)Z-j$gi2xN5A~{Heyb^5)`mOdLyntg5*cCm6kb!{sEAdh2E}L!-!r$V!W+udl9U z5O89gyH<4hl9Fu`gEW4>c(rYn=pva*R=2$rPd$6ta_*k1e0%VL&YEkQtwQz_-#>XM zQlzx~)WReFPvSbKc%+}tQVmj?tNUc3NSPAtiS2z2n=Z6$kCAarSl-DPLwRk0GC%5+}xA(`?wkEgtdnRRVS>4YF zpW!!1Xx;a}z)e8mZNRk0{~g{#3ZMV~|2O+HK$ zD+sVY*jRA1Bw>Q%rOp3s?GC?Q_IOFn_xOXH?ZTpLCq6CGIjWx;Srhu9Dm1Xm_|&3F zAB>FjkBUAG=UsonztC@{cg4D05}mtyx}@f%*~~n5K}s zD+h9Iw)#C(p0a!?OWo3IyA%ZfrHT}ivyC1z@c2q?=VOruM-3^np zeYTuvxXd?MSLJt-&{~!HzVB)ig=I2A?f=g+x*zdR=8tDYk-?qGVl%h!_)Exr{mtL< z*yG!YwDTWUJf66BpX9&1GBb@Qf^YaP^**{@;#}u2Pas2f|6TV9KL7r=uI;CsKo z>4VGJ|My=C1%*CpnrV6I%HMVTxQb*qE)t|q%4y%;pa{k1=d=&XAdFRmu3VXlan|<=@_tPRv zj=N;PGM@NCTIPv?a8Fvh;%d%$*P5^Weyy0;{AgzWj{3cO|E_v|_IhjI(#<(9cH~>% z{}cQy`s2CnUi^ow?|)G+eP8o@LQna=33-h&pHn$DIl5JQY?f>(@EQek4XK%BD z7MHg^+%8ivz1`+xQ}uu2X>F(b>eqgXU7%p=%EuFI`SR_#1#zP17R=RpV(dQ4t!{Ic zi{0LL8#`AS9(H~#KYOOyrM0Vs|5S^r76OJ=)AU?v5*XLf8sFujQFATOs1p8lHgJDpAJo zX5Ne1@pMIc)!Ks3S2?^TUxYn1Gx`wo&*#0TSlZL`Uz&VW5>%adoIX1Dz z+-OsT=*yI)v7$3ipV_3bulLLwuSe3U8aL%lJ|0e=u<{JQ@#A{W2^(|%&lRjX^fEOs zfs0vU#(m}s@BhE(kK?~|BtFXQxEueL?&~H0lwu$IJl@09WU4v!Oqd9^ZItXz#1t(d z(AE&H;X$~#jg3uhZSC~w(+dg;l9Q9e!op6UKK=jy|4*MjEm^XptE- z7K`@%FMcQcc8SM@p#6`xf4^BjSzt0lo%Ok=MQdM8Z{4*kPVc_ov!b>60#C!@&j%In zzs9SQ`ReuG)1e{eCmw~>E}VAVe3{dQPv3r-9(y1+F|%t{Ysvw|SHC-rLRMQRzq#&R zx%Pqbu>)SuKd9gP%FisnlI!THXl9<(vj2{Jl@)N7xVxlYaN?ysQ$L*IwzX&4>;knhkpI5Hhi zV}eu!M{29XevQnya@8w4H%vHq`%S~%L)IHM2o!8?+8@(ewWd+D+44t%!t}D(SH8Q_ zqF)_)cYQmL=#y_YXLhT9^}crMEfYhA$PB9+p0771XItz{Vq5R3xKBR8KI;>6wB^bv zuRcr{m_BLY)ug?3OX8n?m~n)qI{u$t(rmFy+MlXE)H{c5>o@wqy_@BGtcT($VrD?iUPK(JWK>>!K^6k`UDKe#P;R9w{D%a)R#M?{}*6Caw4-{n*>}p#Bs;cRu&y zuWnmq3QQMzB)?{k*wPQ1%vZE{&T!loYaF#PPU?2XuZWqV=AJg~J6tC znR;iNQ|XOYitX;Ri@2MciY~;Mg%{mF@y_-=f6%*WzxVsTt~~n5=KC2BMj_X;JN!F@ zXD^JtV;sBd(XB-OkA+uVYl~~A-*sn={xYNg3j=?MvD@aE>Dp}zxw$@Goa4stk)_bh z;W>MP(#B5H&?t$r9ebTh+&Q?N4(gAKEBBOIC}_ zzWUEaF+{nx=W0WSzlhMZjHgaAeFcjIzB_tsU9$O~k78ZryF$f|*hEFX;2MD-{mM|s zNgLM)oWA~^du<$l=7u!_ho3R2q+H1LRD9MUuxN$A#p!n|omigN?iF~|_@(BElG=`S zQw01Unze-JN{TNMTrPBaI-7Wt2(O`Hh~;V_&R(n1LuWeGeb1Pttn=q8bav~#=^S<9 zPo<)i(v6wN*@X`U?b)DvZE?r@BZp>}Xt-+5v;T5rZSdp3gl!vIzn-7FewO+Cee-5r z@(mFv(YWDu_Wg35!*4u2mKaR>zIctW8pEUI3s2hRZFb^b85`rO?tG@A#$R{B`>6eH z2UWvt@-5vn_xDxa{<(lJVAi5};^+6w{n6Tevcm7qu}&)?9^-uVisr5VrpK@uN+&$N z_t#3UZu7xin_9j;Fj~~SEAP-$&D%117mMO5F1_5@vqR+SrN+g9j$&Twvpv#U}hgsm&5y?>GRP^ekTY?l&)Lt@v)?HguW8tzIuY~yrM z%PZ?;g8a!uIr)69L&j9(;L4}Z}k(7Ibq=kd{SnAkdQfH zeA1V3(i+3bdHHMnp3MAW#;I!8oZ8Q>aWD7K>@9^VYvbE)ODgGYOM-uzIsGABk%(H^}4o#Yw@@UojPt$BzPljADXTHC8 zl`)^@g;_b=zm`2uy>9#X2HV>*&G<9sr#5@6E#ljxlW8IHxi_sZGp@MrTfnsQ{_7@J zeCy_{J8kvm%H*A&i*HTXobn@4{pXMA&U1bz`fFXZoXTPUPgTAnxUJtzrN)hQf|bDW z75(owZDTm3<6x(BBAoAV&y0f{(lb7&NA0c2m}DL;bF_Doy-eWSKjwFD-br3k!`nUC z@#l_ls0)%QDHZt8ol-TJE%dHCw@{>9JFtxZ#& z8(YrRaeE{4ub#4=txq0JZQ6Grl(Fs7ywd{W)841ZE)sG)b*CwVZ~3Rv4#Cq)H{5I~ zt+ZzO`mo#X_Qprf$IYFNT+A;0^D3ClO!2U!X8+T8HsKdB>w2CAJ*tY4x&7PaWZI9f zJBq~FB>S)EWIhmQ^Nw4Xvf`{~yn6gXor0AnwWkkfYR7BomY<14XJiLGZZH@s1JwCkU;k~;L9z1w->D2RO9T4>|=2pEe zFnyb2@VeUVZJzOq8AXpy?SHy;-ou+$Uv51sf_o|>8yIRL#S0)s69kXu(RaU#dng=XML|fhnrHSzf#&UPtc0zxEGCn^hSm=B|Yg_8ZC%R3SBI@s?%k}0fojubwsdDFe&E}hv zF56vTxyB#5OrZAT85v&RXO`YK?ACg^rS&x~+dRkC{;GQJ#y`{BmTj(^V=H6Ll>gDB z{k-MGPmU_BOLWbQvS%Hw+VnB}Kga5skNrBi4_@?WlC@8)K$$ftM^>zN-IlNy-;|-;LMwEUJIDT4s{hJ?q6*p>+qa6;`HLFf7Yx# z&N5@>q8yWt^~$w5xi!~01Z|2-_RfrC+WvX6=+&1qXP=m{>p`oA(TxDfIycr;y*wTNP9@VH*eIL%OZ?=+q$MwEGvPzH;&0+2GpQJb|}yy7$IaKWF$B z%zPbETM*`&P^rgqOe*xuy=2wG4NGTj&*=I7%jwdWx>wE0&p%79o^T_x=>OZ7@BS5i zW4irRQt-MV_mbTIx&5sIR~V*GlsvWNu}o*Xpx7$Ayq>w&&$>?7b5wBOW#J7IVnrU! zx_j>&tGtHv-G7_g?Rfj5Z;7`mRPUA&p23`wec0NHv;Jy$YX#fcKcY*`jynZBbg9%> z_;S^RX^wMs-5$pK$#@wTm`0>tHk_1g)WKNUG4a`wk4g2yOeJl{mZd){@DN*fd+~m& z9x)~3FPU%ZGL7#newaU3TDRrUmueT&!a=_eKWA zGt$@F{hss2rqpV+m^7E=ZOf3*G~0PS@?PWNRrf2_+Ztc*n>5k%_y34h!d86|x^d@L zSDe{cKDp`2ysIyYTuQ$dB*r&yS$|eU(R3D{bmOl#*99YEZob@^cj>T=`1hNSD%+>K zJeHdnR-T~fBY*SSSFcO034)Fn`Xg4Kn-wlvymsok?@}8`8+R7#pek@#he%0iu8g1>jGdKS(UitaWBxz+MIsNO`)UOAh7q9vlu|k8f@|JGC za*=v&+5!3Xd|pXa6J?se#YMWOToTKF!t>)+{|fKd8A*16a!yNMMBJPE@od+!iw4a+ z>QQk!7iV@f-qKSHIar;Q_-so)|Lxk`R*p=5hQO{l{GKK+&sw(MyTWqq>fNV`oo}B! zw@*0Nkl-=HchTO%|32|>w6(bIn%Vh>J$HZ5x3U#l)^GP-cN9A7C;6d&u?f%l8$7yf z=Ot7(B|a#YW2j!@!qn`$%)>W(=d8VzJ7>LCI1#b_Zcg!hBTG}E@Mm^2+qp7DRxH>w zKa@p(@%BGwRvmfiyJ3;xjH+{bFEa0N-v4+t>-o&=`8jF&o$2%1H}WhxDZQeTG1@qw zQ~mL0t&2Q4KZSoC{vit1Yun(J;ytdeVaov~N_ze+!^S<3q*~d6n!L?)G z{wEukYSyXC=)`dt{ZfDJShj*Guh3gAq_u~~$eD6y)m}`Df6?}1L?foSTy8imw zZ}+zMDZQWOQE~fN)^r1<%eT$`@rzr#H_xaNiNsQiv#cbh7B7N!i0|FI2dR?LNUY+= zjvdR(%d@fqZJ`Vg4_~=*<-B?GYHDg+U0t_s-P+yVef8>9cu!hiUmv0pS!8#W@oEMJ z1~qWyZBQ^{|NH;z8yo`!6z-n~9W?~0wg3J9uQ7XPf#6log!c_gj~e$gFfbp0)ZK3` zT}@t)>-uR!Z2ADd@gQx$Vc5ujk&k*|D#UjCtvUK`wM@*iQLI>^TCXD+4E}7du?9$ z*=_E2-{6q1pEeY$PyQ04{IKy-?K;n@OWA*2?3S+=+uBsI#ZY>Qy&Ui3CFfQ#y6Pn? zURSYa@p>tSFYAmBmw&nFJ;(azy2uCW))jkpF8nSanecF%o!rNbTR+9>6@Fu5=xOh4 zeEjP6;p#n7QukhL*!r(z{&|;a{pW5kw)~*-uPsE>JwoF86JD*Ii*EXSYu73`x^VJu zSuqnkrf@H>!{=6fw02Y~`8z*BHCQ>~Wbg;!FU{X}e0=I$)==qRvH$bQ1CCWu6?|*I zYb|(jrs+w?44%sRja}c`T9{h`Q|%wKo#@c7>kU37o%v4v3>&-u26jWmgR^fY?={ru zm3yeR#kJ)9)=!z2)LsZ?EHb&U&CXp`jmx&l$K%PfXQ__rBDsGX%L|NQ-yF{G_PKBU?_M&$e{G(yiUkjYyK9H)gP4}yhFAlBtN91d zec6>Tccr9*Qx@BVMmymf`LhaoJwGw@@vdfUetm({Xu_oy-pv2J5AW&3FqWB4w4SXNq5Ro+UmBCu2c{!?TkiHrIrTPZSC+il#kJ*@cu1m_ zfQ_=vw^tnHrHkFd&sYb>9T4Wy5>eRS@}KXY_mB4v_AgOAyd<{$?Ma8*OPZIRjoA6J zVH)rA(D`9^&uu8P75{vv?2CWRu?@z(tN2$QKKHEnx^-3IZjST8m$h$AxvO{b`pzrs z*sF9uzY;q--8%1o-P-JmQ{SHaaq#uUQev?t5>sN$gqB$UxBC){b_D+4?tA#k&8IIO zf4sEt)%_E1Z|(ebDCg|$2ajLBgP>>6A3_)x?>&0_`rX&losVC?yZ8Ln;VU=K-T^85 zcyZqG>vt~Qf4uYTrJZLl?Y(ey-^FXY&RyPh?(&^yFL#~03=#i!eRduL1A{TRU=vUX z`0sGPKjFN=`uPR#8~0ll{r~s>zx(|6|Nkf47wG@5a4Du^*M88^-U|QESO4F?7W2Yhu3{F@| zBu+9mVE*UB#8@oX*kC=`Va7QXfj=`@n7-LCHAY%-*zv`)I8EYHn($_Mqk$K@7njQ?+aJ1y=7c`K+J`^ zd9~@bY4=wzVo1GP>Ye#XHc{)>Yi&b~kJh0*GA&oHZ?Vm<3t;t;eygdXY<=wN4YAT| z%S&CgSG@_X4*tGAz2D3)jCb3l?Kkolyzz^h&6U5!QH<|s{^t9?H*oL&ux>~8;Ugy% zvW;196)kvB+0Uhux9i>cweRG(=g*k7=&#%4RcC9mraNlry!wCj&?FNzis7gzbQu(XV!>+uxI|H7h)tnueoqin*XOQ8q56C{mnz0v`p<*1XXj} zZYwk4+Ot}^X7bHoK68KZZ#$;!Sh=b(G|%^D9A~EWpCzx-#hj)mOBgC{Z*kdI7diJ_ z`qHRb8>J>2d7tcUPhQc>mU&8LmZ<0f?T? z9GuEeNN>?}r z&vd$1E>d<%(r)SIn~n1n`ZSsUtm^8xW^#NA-@dzn9gqL-Yb!Th+wFJzASY8+70Yg$ zW^axQhu>Y6xU*Kx%7d9xZPvuYWk-K!C@ik;ykV?fxLWAMiA5c{FLU_1*Rj#mOIXQ}?Wf5ymUE|< z8_F^U+Nr z5hzxZ#%uAoweRgb8^v7ZxfKt8#c!~6DtOyc;~8V0c<1ecYi~WJa>XtS76^O_7FS#6 z5#`Eq?la@;?`08-oTtgKWIu0P?Y(L1&qlt?(1750*_|DY`S;~hU3pI~bowWJ(yU&K zeTy&i)}KvU)pb_S9@Ko2?cSE*F-h~?G|z_$b?1uamG2H|GjU6h^8QqE^VF1;)0Dm~ zmiT1KbNAg-??e9&|6O@<=GvpZGIw*G{5#*7El}RR=yz|Hu+kcts!o-cI(?tN%xJM= zs|s=CZ<7oEV%1_R_k``$VT+iMTRSfX>+1_Xx4isEar%noPYT>VemQ!?>sZ&XPprC+ zx&Kz)^gk||xp#8T=L6XO(oZ+@TyP@CWSy$x5NmtJ|>~H&%|LDLJLoPSa z(n$vEpw9X{?h{?uO4=@BO4=3BlJ@fb$JZV`LoOa6Y&f~|+N;N}-yOVsqX5J=da*6*^vdA`E=f@w*aQy3Un zA|a*knQQ4)%?3OTiHXx@2;NA#|9{Tivwf0>p5#uxf4}*Ogunw$dk&_h4+0WJ9?w_# z`amJG=eiLqJ4f;!@uv?W;=6% z%%)d#ybpY|c*2VxCr`xKb9!l-@woqFJmnd_zjnczlu);T1s47f*8W&fYWq-+>8G-` zzIvzl3w{c`fY0R};dwow-%>@;v{wAg3Q3z0>$!8$Xnu zCL~p9;{7b>un+J3*Sg&Wvz=ziXFJbWKj+6ek7@T$UA$nqxZZ5)!Zz1a&*~1$l1rcS z@}9uNm&b1>Ry@4mb5@{ggOg>+<>k}PAN#kcwddJPCjo;ycH(P)|NGqiJUd$;VEdk{ z3`!#TSFR~6ewZu5u~PfqB1Xfw)31FMR>Z^yU6nsOBYoZ@10MIIHFw{=z1y7JYO%NI z|72hNIMrX3V#3z%89w}2?ZWtI)`eXxuO{EGpZ5Hy;f{aZy&u9)o!-yge^a*NQH9VY zi*KK%*#`dnB&HLhbS+?^6#t)}p8^iX$Lp~~aP+Qt*z;yz&EM;f)-P4O%zQmjQc21} ze|Puq<)7O3*MFOSspmp|(F)>bvEkWaAyo*GNi<_qh_dnx5u0|?KHOsgCIrFpI z#KZN6-`m$^Evh}LN)J>-HYu%)St6B{HF|ZbaNn`SR+~F^AY4v1d0qN56 zZj(dRYn9X-G;eKto4;a}*RJVrvX>rc7K#^pbz}E>A^TJ9?(4O$%rZN1Q_%gc>bns2 z%!|$@ZdJTTl5TVy-(j=EGu$a+&CHoxzx_-FnH1&t)t7Z$QDpvjz{pR5S%BY1iN(q0 zP`Avp-ytay0WEXXGQH2WUr>5`c!$i1uL3bCN{^Woe0V0#nsRj4@k4$2S;rmopHARj zyT0m|Q>)l|MZSs!v8CaKJMCm-r1q#Q*zM0w$L4HIzsy@imol2g{4SlcED96Q)?~zeuMuG0yp0G zFG;8jP}rN8m&w4uv>j5^y_wFuKGsp-`14!+@(a>F7@SX=b7foZZJw;#Wmk@E?d=cV z{{PL+$<^iC-&ybf5c9{#+StU z7pm5~T$)@LBP4PC*KyU_%4huEOpA9c`Q7jJ%jk1aG$&J{-Y-YbmYF-Bu&dtwA>5v; z%F$A}V=GHzfg)$g-buDuZh2CiOb?5^l=gLtx^OZH8e3Aki@X!cPnAsf!8 zo=-MSc8YA8qVn~PreE5@(8x(Y(q5 z%DEsd^6`)Bx}J~b9$hK9^k4SWDU%gmGn~}$EIRAc#FN*iY;fAAi6`#b>RyG;ha34O z31kP?Eq?h=!{!vL+2WYIaAPfw2bVAP`ab8Ga{1wh&69HFvz5h`cl4+%y{p)HAV+Pb z%7er`<-IDAla}~Qozm}BJnQ+TEm}o9>yOL~T*I94rp%Sd_d~RkhtywJ|x%>jA^!3prJj zI7^=}2qzR*c{-MrecPw5a)D2D+kS-#fsVZ@eGYF_r*u2KQGF}W(aU0M{mfmprTRF( z$2~=X>dx}K@AA_F*uNL)D((Ms^k`^&)6PZfx~*DTW*VFdX_{XD{mIj0%a?-3nmE@R zd`)>WegCfK+th4@Bz~`*dn@P?>*@nJEKM=lja5eSKfe5Nx~ujj<9I^;=hxai&nD=} zO>^8^a$5QG933O>FQ2vi;{tqtxop{HGIPuH6+%W2#k$X^2q) z))`H+1N5; z9=W`$Kjj~hs@;D@XYzE>f9gL(?>4J!+OlQKmM@CuKQ}AhH~uu^kVc1aZTzfOr*kfm ztFCvoM7%iO^{F*%indN?OUMk>uG2jQpNi&ce2wUdSbnM{m_y>pTZ5T?)1()QsK!4k zYWaA5hs?k0J7moT(4cf{A|eE0Pz6uCI9$~Hf<@j=(rM@h3qoLjt( zUC&2ks)>`%vUQqz0aw!0k4U|Vct3Meh~w&Qxt)^|PB~6#;VcVKwJZxzl`AVyH7pBI z6)a)k{QhFu>uEZj>#TilCUL%RQd!6m`RL(u-SA1x-}$$xgxG#@{}6a`3QLv6-1F@d zmBk-=2faQ2{BvPVLW_Q8h(2@5o)tBo%Z`8E&-d6h)jLkTm`R>b=j7{@s#;yq$`+L$ z7Bf{urm^_2>2OTD^2lIum6TeuIEz=*^hqB4i%%|b(@|OaT6E_N@7|8yCAW80yT7^b ze@uMigdH;eM!WVOSGqRol*OH^7f)`T`i6Vvd~*lCA5WA{u2_3UPfFqMkDK}WFP+%q z_e`HI>e&>D~?6XOJtuUVw;?|y;O@c?a#*m%c&I$Ys@y!pZ4L_)(z)4Hvc;9 zu`S*$NKdHS*=O2}ch(-?cDsH`IQeh2M_G5u#2S6i-=Qj7r>0CSd3M_4$!d?T^-4Fn z!jrfkdT0HVn&kIl>JPU=(-YX^n`CP^%RZ>yaLnqKeUkO&f%k^ysEdD#LvA?cgtrvU zpEhmUw0}&;1CPyFQ{mZ)rKV%+BPN5whItk_y1t6cdmfT`M9Jz^WZtXDye9#v`y>tb z$QbRHG~5S9ORb$CjD3=Z=k#1pYC1r;x1A#|oBKcTN_ZBWaYWH#kBrfE+u*l(4If%2 ze_gZv|NsBr51#ye@5fHub-qEN0JLEA{(Mj$S z&GPp4XX`JYm3un1ynpk$pV}Tr9?#z=@wZ0N@buAD@&6+g&AJ&ICQ0ZmiNN zuTzYLyLVOT2tHRis+brUI3>^FkcOum=jm_XEcYzQyrQmX=@HJ{{Yz!f@`H|-WL{0) zAhTpOqtUdpSIbUJXqdj_mq`AEg{sGu(u-3ACnl>NS6ID!l|u9riIb8Ox8|;vHz=9I zDi_(k?1o%q+$WJwzm{DQ(|Gsl$45mrCc1=z7l8YW54*-`%;sT+>xeR z7bFk;FgVu4zrVT0!q&2Fl0dXoh@|v2#iufEQFjl%bd;28={K?S7F!VGDZsr>Ieq%X zNeXOt`eFn)&o*C}^g(zJOKNvh$NE*TrRHdIFFK(6W+yliK-7htEPN7 z)Xd_cVES@Ov0J6UDw__rhiiq?f2X|)jtF@D(zNhZ$-k#6*QdJ39#Y$%t!7neCiS{9 z+;Vbkm-yvrXH*mtm)z-)$UUneyg741pkD8}toe0UPgnX>mKIFhb6G+A$A-+{#WR;| zEMom?)m*wbhGS}s>H4?JtIbV!Id>$dbWJ~!oh?*vDs!p!%cVC{B~=gZe7VSQapBAT zr58GH*Yqp2>|DG-#Bu%(v-_4k)*AkL?yngg7bS)|y)Vp+n7-$$+@&k)d%4s5Z9o4= z_FwJtz4N0x%hQP_`HQ~IpSXPMU%?ZcPwQAXx+i@6dHT9q)?ZbXg?p|=-MruP`=Nl{ z#rwCn_P@R6Xuxs6{`s9p8iyWDn|eL5iGg$B_xkN23r!Ys#XXHamTM$cZZCMcO{RlI z@j+b7Sz7~Pmhwkl?+k=pY}I#qX}b2N&srvFWBA-FC2a1=b8ML(dLlG8X-Q5zV(d1# zE%@gL#tr$WSosXt}`X6K&`f>lBf>{skat!}@T)Hqx zetK}EnE#O#6+zRMduJrJ#T9C6ov~EkUy*X?;^Zm*6(+$suGtTLDo@<}?US%6{Lqy* z-VF!R)~SdjWptj7;fxPI5y5%BdU~OYwsxilfA7@R7Ox9IVtP6$tdk4Z7u6~zSNrZ` zew;a%@1dcE;j?X1WzVhGG~8TTCuNx?G%Igg{1X3JN8bJXUbV;IWwFEiN`*H6d5iCr zyEpsKIsAU#l0?noFI!@JzjmLkj+OKHTyf}6m(1!(5mrs#+jsMNUNE?|Hk7k(Bd_P2 zd({zADmQ0^CTrGQ_d0&M+O0jKeS^qJv-lnE3NJO%8ctrE#X0TX#rJwQgP2SWu5zh) zNNr_PKKydWg@OlPyA<}6NvxbTX(CsC%<}Z+g4+x$Uvum@UVSRsRKt5TNI}|g)i;rzd(?S_gB3@qoNt;O5zn-=d7Vz@Bv zP1|yh3tMe&{Qo~Uzg+#|rn_QVk~bW}=PWv6`-D#}!RgGzn0U7`M$u43} zvOF#?v^*FZ)?YsVf>Ggvfc8D7BTFR~vBc&)n=8d|-f6>GhZfz|BbB)<7L%u6erzT+ z_k^QNO7s0x55+I1G8QDdh$+=5w#@q{rpXdrw!MmRiEhgRg@^l|&8@R^WSVJe<8s33 zWaxw+X79huRwzt8zvu%?QQ(_dH7%+W4&1UHiv_Y4eq_TfBcwyU(Kv<1Fb zIOQO9_VC%}?Kdap>F}+t=-4!&k>Nz$oAVrB1q}L{Ex0Q=c5k!^*x#1XlB>wDu(oXr zV?r@UL%HUW%7$14hGp{=_cGq#{WL*Bb^>#e1D{9b1)Vzkj?AcEUHQ_Rxmmt`cK3h$ zO<-l*Qbw;l-it9wOT-;M)L8TG{mH;0J73G{jN_YvUvit|9=&%T}zx-?yc{h^lhM!&bKKW|;%)_S)=!9&FA%%p8C zj8fA>e<@dSx*Yx`t6U|}mG!OSf zCMj0Eo*DOBXpv104`YqxQpW8Co=`1sPBGEE;#?Su*iQ)a3C;W+Y1a@JYrbBDk0)X4i= z{Du2(bc##$>J|Zau7@i8j~{4OK1z0tZGQW^XpyU&65}u7mqrU$G{ms7C+@P(6i=CP zJtE`U-+bLk?^Av(;V|#YIdpY58T@>n3xchX0_qov(q&HU>=_s^d+c&Z*Tt8t3;jQyr_&kOIKc&xQC<4)D7%*Wgw z+TUmVZu`NI`8RHI!EM14q0^ZAcmwrBae*1E&_ZDTX2fZ zc$aGk=YCz?@uAW8|Ns9AEIaowFfj0eOI&5=niCKHZ}>1HLEyoI+{~zc1_s8zkTQ13 zm8DTf9R*lF9K5^rp+KRQ-?9ZSUpaE=32tu^zoQsbX?5rO@B26B{9pSJ z`p|Hvq?^2Ze~9Ew-#gj3-~L+m$~nQqbHk%kOY^6|=h^Lx zE$7EM*xuC8Ncm*1oPYepYNgFT8|rL*8|rK~2S_a9&km5dmM?Ljn`Of0_+yenj?zV9 zDQyKs_a}0!bNnLd@Jja-PhrCn(@(sPOU%qp@pv|I2g+ZI!DHj8}K=zh3V4cfs%MLOaWU zc|RYU?_2PX=XZ1+8%w{I+$@`YdmS$+uWirn`)OWK@a3VvvBC+>E9ECzt|`uW!Eib7 z6@RI$zV(Z;C+|M|zb>HX5_5Kk%CFL?-NxY+dcv{UyAn#TzP@zx>-O%7^(+aN57&GC zY2{tt$KshVVd2x0hp_cvnfBpIk;p?#u%<$YnGW*OCrtLGK&6FlYHg01u@>59272cM zlpph9ln}p#_1rdXQ|1b78IHX*dko*7t|35p_|No!*vccg%zy;N9 zLh^`Y{Pr6Aq{j*Z4j0o}0!x&V@Bg2-JA?Tgr@@p}^+zRde+d>#koe~Lgq`b~^MiQa zrP{}CZF|j8qkE||_w_~OyGn|m@)X~|vk70Bw4}7`_$|=#VTyqCX2H{qE20$G6gf_ET-@s5QY$c5B+0IQ2dm?< zCsps3QQGwq_i#3Q6P?+MWAUy&4iU=9V-QlR9j#C`2KE&%L*Nr>r90l zjvi(w_K9_@7C3a-siMvI#QtVU+sv!ZG0#uGy%(`=ar#T<_#rF>D|0L{$v6r+3k)CU#ANiP$E*Kc{`4`?g9C*Iq!DsIyFBZ4dcHR82b| zZau-kz`zeKg$11cHy^l_yhIr^aPlE^!oxNO2ByW3V)*T~_DPEkcp4ri>}>yX=-T)C zv(aJm))eu`^=s~0RA24+sh5pqcBiS<)trjp2|-MP9S;A5I?QIYPBEPkCz+I>^10oa zMM5BS-~EfWt+B>8GEwm$9?X5}oyj4=NwG7kD7w$uudcMM6Q+&b?vZ zj@&?@8wzs2w(Zt+via;##*rw~d8|>PrEsO`Z<7h^Dfd6{u_)Fk-&B6GS}dsg+FQTk zoZEYkD&3zK{_@VzC=bnLZ}|m>P2xI37xRGS8e9y1iO$ z@3*IXW%s|vZ`|=~>G_92vW*SVmAl^`Qz*OJcqEWxM=1Ly+4dV(xBuo~xzfelnaj1n z*EOP4g^Md_b$4v`+omax?sZRr&W97@uj_HIQY!HkMLYhJ8zJ z!?`^IDlBggE!*={!K9JHMPbi`+YbvKv@h9x@Y@mIpAA=T_lg!Zxy#R)5ZyALuV;er z1Um`E`3_a9L2AKi)lsJd%kW_Ug&Wb4+;lQ#KH)^iCJ>Tg(o zN%Xsw;sKrh@>MF;>$wG|a6GmRYB}M>_f6FLT8oQS<(}&^byT!&?&sZKmZBJV^5DK> zDv@R9R|!mvykVU^DK$KLrm)Md9|rl#=l5r?WYaiv=&*v8r`{2V#ntoo`W6YfYj1W+ zoqgnfO~A=ToEJGy3FoCKT4>%a%G|fM`|8xl_?gvr*XsV=nO!)|?Vs!P7>@&$er|kw zmfm}Jal4x~ds*lC*aNOjf2yN{6xqTPj&zoJZvWk-o$+)}^r5$T1){4hJn}rYpNX<@ znxC`Vyn@4gi4ar6nv{#Hyu&tqKec4jRGBTWHchQa4Z7*2wRTsI>SUvpIjZMRUG+Wu z<3Sm}$B}m%i_;l4Ox5u!z3Jt)bXSRLcTnuMNqeWOPhIz9fsa;fr%H-z(zD;&s++Hr zl;@TgGrjQYD@y+1m9^8bM0K%^LXB$ojhKCt0_8&XO=3GMF=Wt-~7;PYI1Bw8f$Z$@S$V8n*{7^<2%-=>=%gi zWVf3%Npj|mkF6R#KU+P#tezxKY5nk0M6u@C87CH1*-t{v3s`<$vWrzP6le~Ruya@Y zbK)<5WVzGb+veN$#WVd;oX_;~lbQg-R%w%1vCQzjI{Vlezi4?02RCSkD|59AbkuD; ze7$RR*ku`^C$oHCI(Ef=sbXZ@e_|m|lK7rD=MArAz9!9DKTD%#|0ky73MXz(SkUpt zsBG)S%SKrq(>mN+o}Lcr+|(IzX|B{FUEUiTCifb>ZZ(&EA7_M7Xt$WucwDg5Ca242Ll5`19CfYJ~ZpQw=ORSPdrNIEYd1n0?+hl z4B0$rkx;wVYMYW5On zeVDdUMu&@0s%g)E=X(K1%9s|ipZK~yr}lr=oQ3=6{{Q>F{=YHLujn6!XXSs{9p1G# zv90p!(U~`DVx=h4o6!V#|=_DKl2{S$j^wp*cw?frUL_Fqj2+mD*$i{H3nIV)T} zYWCL83eViw0?jAbu074S?ZOlHXIBgF@*HnoX5o3J?_+qX%5#&`Mej;vtGmO5J&hj~ z2Y$M|l-u%ftfuN6hefNp=fpoXmAdS+yV)I$P<`+y3h3&g=_1-~6nd-@YheKAn6jB$Kenk{aNXGZ#Ko5<4BnjKPyHH{^di2_RW`LX zk<)(Zi%j{WB2|a@`V=`%&b}@*D>7)Rjb5vQi{-^PY16jYtZUV2k>1nc(Y|yJKiknu z6PVUJT@qX<{Fz;|Me&r!HnWNUT9@m6`l#$CQ*=;!e#wn_Ma$QCDewiZXJ&lK@nJ&B zAGKy17hA?^vzIsO_Jrncaq`l+X>pK^|ElZVSMp1R-6IzKoyErQxiYV0?gXa&IiAx$ z`m8kidf_U^$&a(0Z}Etii@$W3;CnZr+U(`#Z97(8Z9L)3b<*R>ca5z%3K@~1PIf{k zS9e932ym?PId^FJ=MbX_ZTIK8Dhqa8&}L!wR4Jb-cvj?&e4&(&<>%cpUAnru2bXa3 zSG?XXHjN`?k^5KKvto{F)9-rRG?~rc>Gp$1x2YJ$)bK z6m`n1nk{fg@Oh0oEl0E$KL&-IcLNWf7`|Wes;+VHdDeCE#yt3x|BCxAp zH#jYGR>`X^C-%uK;(1bPyJ^)2?@8O_Jcukep?J`#y?^wuBo89L8 zCX_9yf6v5{{11yxvN^9Y^-FWF61TeMJulbt{H$G3)<+Dg>$fD!hb1=~2sBK+C;Xma zlFpsRzv14>M=N(E{h9pDx8VH?nblu!-Zo!<&GziZ-OLS__6G@cn(g7&U-kU_{BZq6 z$9-R=wQb>+n-kaEa}>JEReq&i#`f*2h$!3Yli~RfjdV-h4+=E( zlmvwP|MH&rUjCrzsT+NDQqFyieu>#4F%MJZ9)&0hicOz&sESL7yR#zufsScq)P?0@ zpJZr+1yi7K51GRPvYBW%9)lKf95Qa*IX=?#Fr_rl-m07R^U9Z7mF08 zd3A^vI=3#+3On(w=4*&ocumT_V1vagW%i0bsTcT>+f?xLq?FIo>G=yb{Am;O_~^9n z^$L~}>F*PZn1yEqS)M9yQhRDTG5&ebyxBiFa|(U<7w09ke=M=TR^V{DeEY(O3b`-M zGG-UYhs)k=jJ8<2ap&eAD;rJD9{Cv*G5zyl^FZ~$t}O0qVztavo@P7u!A(D@ zcZ;@&2|l~pH)E$*=GJERC0}Bg>zn=8ZeftmV7Xv{rBY!f>NMnbXr%(V2oH^n+I$uw z;=TJWgyC@DdC;*}+2`Nh`uzL<|NjdfeE#t3U(cmLwhkjkcf(Hb}- zvwL#I;+8D)h5q4lRbyaa&;?f>0s##h4t)4; zaG^lKAz=Zc%6Kp#dftiJ{|^K|9Qfb2;h)2Y{~6ET-95dCfq{h^T4@{vok7Xau;A}X z@s&)VtMsByGv5r9;8?_=)5a5~bm#wq-9@XrCM8ZV`}4i{MPc-K{|;eY3+Hg9K) zYnr-`V?&t2*`zg^u4h$JPfY0B89H&w;oKb)izfWNzg+pP%6<2+pd&6fdpzZBCVTwg zP`1|RUaFZ~=;?Xxz}v->*-|6#d1?B3zIvwQXCS?_hxgGE{YSq&8Rl%`KCoS9>C(f!f$L8k-H%14}UrHB(nPiXNO|wX>wGegYOc9)L z)2$&=LjBRT_C+GhPne%db3!;8}u%URmyHazB* z6?YFf($!ubZ6IRxb%*^`y9-BTt~4L8PPz7QcCXTr%)dq%Hx3!IweS69v7r>8gHLFz06rCK;j(Nfm=mnw^jy`_uRR4kF|G8p?(`rUd%dc&JuEwNW6SFIIo7iWiuKjLr zIF?TLPEVMB`UUHvHFaB)}d7(*@ShsEuW~oHeVi5zE4>c(ny=TE2GoR_aEjh8;w>bh|`*LmhntzR-JJa;8pnD`|t3oe_S z%KiT%q`qUpjsw@^OKfbvZQsIjn6>Z2oA*K~n{_)|#J0Oy7jQlP-fr|>^x%pkLjD?k zsqTj^+G8pn|hCxm)7JuI=B+rID5b;&nHVWo;oPH)R{=I%24=yCFuWHHM; zg_V`%e?BsuZB-94=~v#~@NFIkk5aLXr_)#dW4X4cK4u)eFsJW!;kvH0vb$yrPJPL{ z-6W;&_gwIsiG6>xV~XL&c1s}z{?4X8;~$?^{YZ{k(pr(AI4SahnDXWWGDh5I6hYMF z9hw?K4^DOVwmcN(J~T05k$;h5v)jR=6I|PG$E38eKiV&QMT>jsJcf4|>P|5jeJFzf9FWh@0Fi!?E3OXq=v%6R6ZYF-D4jp?{#38*_+_L5D@_aFYBpHPxBDO7C)x8WGHr%|`)ghY1F?+U* zQ#&9;DrtpN+$&Ma`^lnlvG?B-Hz zF>jM|YLhVHe!vhZt)swQ(9pxjeL@Ff#_9u%PHj?~nB^v1uWwdSQRMXWa1xp{p+!YS zQU2`>&P$86MA{w(yIzfLhzWS|_N#aiQyW2ZehcTb3!VeXDUHUN^#_b=}8f zqCr#h*_@4=SVMO>a~)6cFlCQlvr*JoQP);NeDMMACA>>XBPFn}NxApCYU64Ab{Ujm5jx{dg~SX=-ZVmxs+KB_|Y>WNfaJ$lrJ0 zsjkQ0`FHn|8;oPrW}q_2NarDLXn3tUaiF)vEMZhE2pe*>1m& z5?}hJSSqS2o)bP^7&AqNfBA#8TaGn*Zt(MGT<$VYKB=&_uH)z>nf`^-{}+n%*`&_7 zuOwOVNa^_98En%MUfPK-%ahO%%askzW?dMewB(?!$HBz49-R^EGB5Nty>(e7SakF0 z$)#dlhy9e6wg_yjkxzZnE2b36<#*uW!4-C z+Z=;;`6lq0!*>N{Z*vTO-#+u_$xTSZ<#c3=B*& zpk>PS*1p%EYlDq;nj|`ZG}`n3b*zN`6P@UZ<(nqePt-kiJ#)&D<}2O?^|dR5@p^jqYX1zv^l2cw&$K1Ve`>^OP5J zs{B2F!r5%{Jcn(yjXf6)C)amyI6r&OfAg(oQhs^LiwVt7rYPL-6Jiqma_!Wsb(6O5 zXwFq=xqWwvaJcrHzKbh(@m+KGu{d-wza_q{7 zf8|T-j~q~UfBGPDRear%`TF_mGxkS*SnTlFd3%zoU0z(>?>Ku_miftlW(zJ7Okz@q z?09Tk=q}1w#8*(GxGuy{VfOli%!Yvq&7ZFyXbjO}Ytj6_`@>efJtO!;L2#yV~7Xwr%H)*|{gxirc68@D*7F>nb&ysN1K~ zKPLEX&|S&=#Kn-SU1o*+gtPn9Cp0}#xGt9B{+`|P&yV~5ebe_>{5-wB{(o-yI$mWq zCI*f?=0kcskC=D3|zwkjebI~)NKXN7BAIP7qdMKgOXBtPd>ZSAjF%pT9`p4&+ zdAB5Vh6D;JMks|&ak;Tbg-O#}X+ydv%Oq8&4K639ok;5x(3z;^rIa&`*0Sh0Ri)BCvNyFd7vdMWJ%SsSwcurKI# z>aIs@^LZ6}zm!kt`-LTAvuY5Nv5TM?8=k2MGFq>HSp4wIlsliY&x02AKl=J7;>4>x zFTa2J{mi=J_|GibB zdtBoQ{Im;)Gy#SG7nU?k_z>{mfB~c&0h0v>eE$4@E)QZ)3+v?l#K6E}56OvFroX(l z%1XdRHK0YagGJ>2f5-DV>p$8`*MD@ct5V6cCod;>h)n(bYAJh4p~$RP zTbe67W3o8pEfkmqH8(g-pBtR=^eMks_Km~SZ!#53x8EXgPHw84l9Kcur8n$qYWJ&$Qu$I+8&Wv)jW7T+=za9zUQdDC1#P_ST? z=f=8wd^&&6H7?k7;c}I1n{=GX(Yi(rCDCh=fBBbH?yo-1=3=y__`7{&Pql6#qif5{ zu=n?U&eSz_bZjUzN}6P+R=K#tK-Ip&aAxXP;S~ZRg^hxO%T)gsd{PU0@^Y`i9zOND zVxB`vp#@>B*JoV0s1&>A#GC(VhvbunD~UW4fr+e0_#e^}asgjxr(oHqK z6=s$kf~6Dk?s5D7<at_f`-5E)>rS;uI=wl(%3`E zHF_Aiq-2}Xre}G*yM$OK?=8HkaQ*+jtj+(5v}S&3Ee=gR@~7n1`?r@{3y(VRv?P9g zu&_CH=DPnvhc_fnoAacWx8nGIKfC&(PttR)Oj}$QEbH@l^W9>#qTRB zOYECgmtpQWbBv&Ts-YcUq_QPs;Vo1l6(&amioN8=Tv zMar9dX3Z76bMIPEeaET?{?gy{ika&tl~-@KyX7x=m+zH~!CB^vM+fXvuoRel(}^fB znHiu3W>!{KVq#)sQeu2!a$;hlYd~ls3^00D!I6Au8KY;FVo0@VOeT*{<*ipA_wL=h zaMik++S;O`BCpsq#)8#%-hSD(d*9x@dw1>HwQTwF-U$=dZQsr4Sv6zU?B;cwYqstw zS+^x)*6P%$vwG()(GJdK^sHid`X7XLU1V5ukp29B&7}WAYyR6zTO#CN`ta*N|H?W> z&#H%C|H*X!SIhd(e)=JV`|#^OhNu6T?tF>J$cM1yX1|V%Pv!8g6z^Sc)G$$dc%G!W6z5}XWsqY{PfSg zFaM6d`Fruh-`k)6ZGZkJyePV^)!RC;`pzcx-v_17tk%sfuYJ8!HMzL@z+&6q2c;i= z{RbxxzWQ5JTMI$I4@yH2gj-Wv`(>}<@+mP8?&9eny*0J9r?20gdvW886AKotTD#-a z#dG(ccWo)C+3Ym!XlY-2zG-O8rh~_)EM9fx)$0?_F5dq5xuLav-pM=!@&?SJ|A_d#i{@?A{jdk`QC?L|3xgnCfs=F%9|fPQ??#_a9FTnYxDMt z29r)7d-BQL-9KgBP4r@-hbt8*s`noe(|~i$xClMOsnhE*>>4% z*R{0Mk5)bSa_a5Rf^(1k4&9D8cE9cD6W#Tv+poQH-gl$s@(aV(naYa~Yi&F)GiAGC z)k2<2xsyC-egp}BY8O}hD-RY&tI0|Ub~aNAlSq+$PjhySn6zyE(e`Tu@}{{}|= z_y7O@FQ9n+|M&m@|2zBxh4BCX|JQ>Kb^)^m{s*iFogW|YA9OAy>|%=qNRzz({QUm; z1^55MRfDzs|Nr;@|NZw392)*N>`#!)aD8RFWYzzI{{N3b-G7LZ`_mybh*W@R_jnKD zfHBx~1F-7zb?g7bPSv{K02Tr(`TzeEcyH4G^(ANSuV-N3Du6UM-dtlY*LD;+@bT`h z>gMp<+vcv!y}j*i|Gzvl3*nsebA4a^yTAIY^=9Rl?O&$L2uQTBvY(iLii4A{R7C7Y z=i)}5bqYT>%RF4TuJ!c%R}Z-UiFhQeNavF1k+)Mwj8jl!F!=vF!oy+3bR~vhCHo12 zqO!u$&pA8ULnnO*>^ZU|WqMFhaPZ|va|8_PMO0L8dcW**Z%(ZdP%$<&Ha6C_RyWtz zSGTsdzZ~T!=fw49g44^xT3W}vyu3e_Mp}ji#&k~5+VK3g&PuWNDGy$AX)jr`(~E$oA5NUe(0Kkq zaMBGmwu3Q#dw=LX2tM{@-R#1)mv-N*xDP0&I-P%Le)5Q-Z|K}_7avI0JmdK|bv5%M zh8bL3Tt2Z4f*Myim3U?{cqKFKuKj9pnbFgLL6iCKF|(sz9C#dj7QXv_*@u4#=L_Ep z>Z>eL*jN_zc!tc@J7F*2sVG~zOF>d0M5XlLinCr{dK|i|I_Dk$59be zUd%kI7;^m0BX$RlzNMA+&S$oUc-TLVj$7iK@q5(~=M#NXT@5)>Pion;yoiYXY=0!< znW721pMYbB(+-9Y0<)OaIi9@_O@6jdy>Ua_71<}Y3I}TW&u-lG!)}6P#Qhr`>}MQ` z&aAsB%gxlj{@N$g+&nA&je^m)ua%jt;@Uf}xcJOc)%N6h6a8(NGqy^0zvauFbz$T7 z+^R7yt2ZtFE?jX2tVq~m#2U3eM;WW z49jQJO%%Ux+_?SurjoB4df(>GXt*WDUfHv?ta^Rcs^=!M*_(ZYmF(|6T3@lv>Pp&gY)JqwtgW=I5(KSBHJ*|9#`=qkWQ>g&s?EMjB7jd^Pc!kI`Az zA3`hkcb$9|V|%tH@V(rwiQmu82;Eq@TtFj>r>FOlLyD^UrjuJL-Y=atEokPJyY~-U zCE7h$ea(PJmf@DQ)oz1;yS95p1(#m@61#Ec>Z9-f8N^TYeWTp+h5yd^Tq^h%lb%T%Ue(*0gC41rJF~oz2rD_}iPEuU5Pv{rmn< zleOg?Zp+*My`6jZ+r+8WKK-`b*Vm-JO~{`qu=C`B2RAb86@Rx(54v&WO)+1fNy`78 zxv{cm#TU1BKVKi6xlTDdyxu?S%l50Xw`MRGHO$w&-_RR&j(J;HQE2JTg}!&(D}M3! z@$y}hoseVeZO`Vised7R%7)$@vGdgXCM@f@(LGIh{qyMsasu`)wtU)p<=56Q^KZI7 zP1gO3vMGPmUia0~THkgg&s_1Ss8UW(m_0@N=qKL#3b_f3*_LjbpeVOT>Db~gCvH}? z`<=H7vb>ZK^g?mv!u@lfwhQyGnaN+rD&Sg{xKrcI;cUHAyB0=gzsNtocsGAgny1#g zp+3APR~ z(^HDkhYy`vv4HF8qZpO+&aRs$yj`9g(%B~UyI@h)qzxLIyrUj5iYu{qICzG6i8CH@ zTy@E~MQNJwRr|NGvhID-6FaBD-c3>RGkoK?KW2krS_l z1a)Rs6t1YgBk=C<@x5OeHtfvy=JyGXI})4Y7QgS$7Tdyg2`4k6Hcnr=@SsK;E2B(p z()Sy085yS=zkjuRx_lt2$|$WNE&0eRpq%P5?uL_MOt0 zv>M*ym%k^ytl#M}p{z>u-}}8fQ|4$cGWf-^BUmrOa-Del{r^ID7RuCf-BGM$cw>6u z>&jzKkKMg%t2lS&y$@$|)|Qk$ow9De?cLht?(t8=xqnXYxKHLw#4l5E#CH2Y?`IW z@rY0VW&Vj+tB9ZeWc#w?&1SRv7v`)F;qwuSdgk$2FSF*@%g#Gr9;=Fd()C;yW+@_> zcJ9<+CQFr_KQ`;%Ec>M-ZtLdqJ?enA%Fa7Qg^b1f9{f4@UU`p7c+c&!UrOq4XaBsN zC-`T{q7aeP-Srv=ytS@wzT_AGSM_IJk(ZmCuQOH6 zlZjFaw|mvuc>I{|q}=Y;IuA^&zr2-^QZm13oSc7eW5a!`KDXix-z;lVPnany7H4$q z`FW#u3;*>)@~2gv%+Ts`s`S;9nsLLjD`}6LmC^>4-`yqFYfR>>-+Cw8Oo&x};xvx8 z-WBB?|E^7DH(zdIvwL}U&BSCTOP|gk%~=UN)|@L1S9Q(e_uG2ujKOn-c1OW_AKArB7$gd>_LAeNMw;?#C~u zU(wiH%yaF;mJa(vzcVyK)4#_QR84&RCfp^>_0T(sIk_FrSWMpBPDpxTQn3 zCqiqblXBf9TPCeYyVgGh(z-F0)rwg5*8Ymj|9@xgf z`+noG(;Ij3&JvipQF_i(izf!|x$S2<|4dG1Y1go+yph8vA}O-@cgBGiAL9CayK1hA zyzN@mv{}Z4=}m38ftHhXvZ71%l(UB4wJls657+RCOw@`_Z%wM_-6JzwY~q?)!xdMv zge9c2x)-tS)1D!GbN>6~j%m)8UtA5^cF8#RiFP)y?a^Kn!Qy5g(-*FzB=>GJliu;w zVv^i}xjkApEsG8~^iA!WkRKz!HRG4IpkrB0^TCALfMb^FAy4ct1S+uFyj%GkOaGK@ z5)u7VhTG8o>E+j-FFb#L`PHW@Z@v`FT~@kqRpGqlOZFeT^5zQ!70g{$ykKR)++_=o zoVoJmOKMK;nlo1m<}T~luyfDNN0m$0P2PF1VD7T>&)&^lzG~9U*^tiH#{EZXYHO<- zn^tVuQP}{{kzY|NpNc@IMFCjz9SS|Ns37|NkreH~9a5 z;eYq@_y7NY|Nnn~#{Gix0rU6&PXQ@<|NquM_5c0<9riRdaGYMZj)8$y7TVgs!Jfa_ zM&Q6l1FNE!kKZt=#PFu__O2m?D{okEt`KSZx(&LdRLQ=!$EUv-ct(B0Y*0sQ}xpp zJd>EiF8nN^RO!FVai%qGF$Rfg<|(IImfoG9t;X}V?M{hm%F!0jaHnSqzqvVg2{AeR zbIJ=*bd=b-=DKt;zsXTyyJN!Jr#V^7^U!HsBI&iQY+Ku#sBhbk*)wanx%}G>w%RCqD6njUsL;YU_R)%pr_8oFG5veAV|DE9x=pk8^X>SxO!4o! z7Kd~vwr|d#WNl+N-iY8nnH=XP$<_K$fNj0SqBR@7STkPqJbvsNzu58gNRdw!)1&`f zek{n^F*RA==V?U=hVIZ=-0I~Cn(OD z_*~)U#h!O2WjzteocYHEP1`NjY;4%>rK~d5+(771P{r)zwk13Z>hG^swW|MeLg1d# z1CLD-9q(0Gh6V2}`#ah#E-vc25lM%0h*<*(mHID5=B@^Mt0V3iaVav{q06^G(xPlo4j zT--OGU^3K>`nddeW1qk#o9j-(oJ(U*EnUAt|@-OIq0Q0BW+&pbxPv}=x)ot9$r?x0qkY`!+$!XVQu3xsAF{^1pw_LvI z&n=9)pEN&n7bSoDVKd=f;T(kxx&BEGLhtvrP7%H8xbCl{=4J0IYTq;ys)Xv!mfYER zc+MZEwFO?4M%&*9_L<6O8eh>{&NTCEZsX=fCn`eXWxsPW1|GWK%2u1qW<_W&RG-M;=olP6z$0|JE+*`UgoSs z_9<-}T{t?t|9`366>0Hdn$fnoEPS<3lV=JvB<8dEgeX@`w%pnwcS6CQzKgh)8zv9E>~Y< zE<4}p)-%b)n?sjOeA2u8(^<3pJ@Gdpl2y_sgp0mf{-{==XZ?xU(MuHzGILj2u*{pZ z^^riz#PX?+CU}2($EDn;eNy1yd5*9rcbOkWPcqluIidAI(Z{e&lYY4}-MJ^w$|1)P zJt#WvS0$BS_b*A^lPsTh($B5a)LPPX+MAS+hPhrJQ`UH=?Kk_k z|2FGC>o!FOH%5j>DgssEbrX+ZshU_e5K}eHfmTg@Nj|UU$wB6J=jAz1NcQeZ@PCz! z*pLdk{-j0ma)#yG9D`>wMBnBZd|e}RsMO@oA!!JDF`xhC0)7Y^Le9-~I@hc4Vm?1I z`g2J7V5`=IWN(P#HDwmpr$~L@A^zu(^xG9epEiiRm=85%d!1ote1J*u$1(;61`}}I zVj^(hfAH*Qr~kiN+3N5=Kq1LszC%K5X;i^h(BRhp_xmr;KmY&#deHb%!2kdK^A-Mg zmnxgQVqjqIhgKt3TNw`raI_>oV(ENmpZz!NMc_~MAM=#{|NC2A?yD`DwR@lZ5{Kmb z--EUP?D`iL%(`fEWeVd7Bm1C!)1Lw9Ki#9Cj$nMDAD6`#s*1@iGYkLi)_hsGgQk6JX zBB?Gtd(-Pvm$p1^bCk5#lrpW1|D<_0-X(?ao?^3Xx7WH%aT8;{mnY|R zPg$Q^?%JQ^SbX-g@InUJFDNw$gtwI^FvY3ng&cJj z&O%2weNcbyAmH-}#`{P?B7iHb2m=`b~(;CbQ?)E=V_N zdJ3OCJe5INast;8sbKxcS3E5&?7_uW^F!I3E;a55dg;N!JaPSxD|fbjl=k$~ny_`J z{>P~G3;B-BVqYrvdaJ*cz-Nuq{8HLHEnYuG3(p?WKg52iaZPWHO6u_z-=FaGbh=VtIPV7D; zopkBfT(NCTo>}F$8vkhjRh)fm`h!k0mpZfJgF*+zIzQS-A3XWO+00b_#P1ds2cKWN z9j=-7`}#PrGHf)RUh3eW%3xT|{r1_~n);<|8<(xRX__o@XaApfwdd8H6^?r!oy>1` z@IbK+$B{7YbIFyqDuz=zMb;%4)jmxwHko>Mj#Egy)wE0Umn=_;Jm2_W!p-8Nr=#Ut zYjkEZFljVw?65B?^Ydez-p(cUVHtFU6siM-}%hod-XVREr{pM~& zSD2{idmV3=h4&ZA@A-Lu|F!@77(4E&DjWLjZpBt`Jt3yxnhY(tZkD+(n9#JUyP|Hv zvWmrPSM*k`=_*~{S==^v{*-C`@KrIdb3jGen_MHf$o{6pC4F`0s{(elq{9XG#Tvxf z=`Rg6(AU@R^VNr3u9%#heCEuV|NsBP*U#W#B*%SjW?*121eaIRI}85*pAl~J=V?g6 zfzSUh&ar-Q{{O#U2^$(ftz8JtcyK`AgTaLf&dU@UJo5Bi85o$)Lkg=iH{0_b8}J+} z)HF5Lt=o8K@Ata@&v*awnv*-_+)?I``Wc7*I2#|9{IL1vncZLbjFe9C#bg!#+U9Xj zanlx6?_cRpW1Wmwt-Z9qCt~+Ov!C-~*yjfxu8D9-c+pZ47AdMU1M z)b^lvUp%|MU*p22-Kza|%#9J-V#DzxQ1^KqVyzEVPgpEaFrvX<{pbvt*d^+&N= zZ*c1o<1I(!6ve0ijVWz=vb5;p7ml6po-b2Y$vS^*X01nx#tkEv_W~EKmbB=Z^W9u< zcxK@VNvneY6K?O;|8BHnJ=^wM4*ZEFoqL_-$Z6jCViYc!IxxOg|)Tbw0u3nP!?sSJ(e&uGikVU)9 zE*dS#*jwOubFG`=^R?pdY+_HaiH13IofhcdU!<#|@+09$VA+`o0{dP*XWIIB`L{gQ z`KLa<6*anNXzT6O@?eAO?VX++7f-L2xv96@P4UY&z2Hj+qgy>Z`C=cQaayvZp>1y> zN9~@nznrCy=B9Ggp2`Hso>G z`B3kzz$>BjXaA;qhd*drE<2+ww(G4vxARs3XE$r_AM<=U4o*}4{O@-tQzg@q8cvtJ`n4tyA()HWtYh zb^LXh`NN_{mPonh`^6o^J~awY>t#!N!rFl{n}lYX9(cu?V| zWsNy3MfZ{zml&Stvd>W5JU9JJ(+BrahBL6dFL1=&ML1NY@IP2_NpSz1`gX}IQ%%Tr+7F<2eZ%m`sCS#CrKV( zZ!b^U`{70Rqz8tN=VeZqCowmF7yrkn8b8){DqMbZ;>PvzI}P!oyezLpW?U6K>uT}p zfblGzq=z>9I25nVSvFHB>8NK{rsB2YcCnT|Ns9%pyB_1hyM@qR~cMX z`2TMbXc_R_$k@{i3@k>F0`1Lp_DL%gcp4tE9Jz3}=>O(@>yF8COgs7d{uSN*v5Y^0 z7i_#7e(iv6bl-=D&Bkx{xb9%#|Cu9u=P^^Q$ebX(10K49rbUjYu1uR;bx!n^_NkqF z6xV4y|J1f)(Tw7ilh&y1oiqDo!nb?%e?*D<@PN|e^~9aGxRe79R}f%2SF$~=j0b6;#&*(GHezU1}sylBa16?W70a|OQ(n-t|) zzu?iGS+|1Aa(YJU!lRe8G@tZH?pe?m=BAim+xP0lHD9jEY;U<+f3~T%{`ud?p|f^D zZ`ilQx?gKOo3G#2cyji;HeZ{|@(J7b*J|`-MylrXiA}b6%_(KMeL{gWZ?4$XJ(Yzk zm;Kvfq5bsiY4@uP=~}sOHrF&6uG!LkBkpY4n`b{=;y!-*w5siCc8m9lBO+VpaGMA@ zJdl5K=xXlC9}gTN{#BfP>6q~1XV>R16D1bbR@TVGoKmTD{P|Y=3Cr{Z1y2$2HBAi# zS0{NsSnzhLN@b(+~Q*>qU1W5L|-3{{>c)mvOj?SEXlFj>&;^7q=G9XGGkoW0O3 zR4^%G-bML@M%}oM^(hs51SHQLZtW1-A#l{`hFX_HNsaf*n@f~ML_atAYBeQRW?D=$ z@bKQZy?v|VpGhq_Nt~XqXC}{@XES??O2g?#8|u?`@wiW9I5#P?eu0Rp^1_qOPN(Lv zRCrh4l6Np~_?eO7$yU)WZgn;>>d>W6wj1)c*2ueBaK$-D{|OXUV}ExiRp*1*MxVz0 zajh$P-mNz|ZNhKPq4!F3{o%w#vI&!CWc+X6-uaZlYL5?>+*_?2nYRrW^^U*o$YnYE zcYXH6-UV?I4a~QW6n0bvrm}Z`OFMdpf$d}R=@6L%O^fzc6y}Rh$k?uZ=^Vo%TmHCz zX-_&b;QO4;Ch3kFJ|3ZT-y4RmrZF>aLA5<!y|<%;gh^Y2{$NKxjKiAVCwOo4j;q8Wkz_1bz8PfVFHv6l11 zCu4_M(dQX%dQ9kNzZn@_VYKAP`GXFAKW#lYG`XC*nkOt$SYiQTHYh247h%-=q@Sk{ z`R^F3%BL6&CZWna5ynoZ^>@p>IwJCx3Mx#DR8H04xb=Pk53}RZbs|ntg33V*2M?BJ za4Ej+n5cPIK{?n;;ZeqoH!U5T7dEhHvLWnfso+wa=hU%SV39_P1eao$Q^!IOlcTF) zf|9}l4h{__CN70}P94jyFiD=8&*95>B#>dEh=UBPfG3n0vh?PyuqB{CD!pwv!E^U> z*UErZ*y_PdTycuL34IYXP6Kybx7qVVe-dKdxx<0yXvk*wW3jgFtVPQia~A2Xx~ew+ z3}5XA(~Y;0+wRbv?7e#-f{ZzfAjqnHg989+tN*SNPy5nY~o|&*k6mCyVZ6{QmCl?(+BX^FM!h(DYO;Yirfw$~9NnqPJ#$ z4g0)i*4&9NOlBpC9a|Eee{Tirvel;f&zmmZIiBXppRg%!ai*w})t-6%9d+yL*$NND z==C0Fs5kv`;vz$_W&OE+yExBRX|h*V#P4|}DkQ5t%UI6eA;U)QwCoiILH4VPlQRWa zj4jUpEc|nY-~H8sXB~A@>!pfBbXnRP7VF7QY42E^7MSX8AS~lr5W2i_w_?)#{f8zu zD=bo;VC~|ucUH4PQ?gch$AqZV<0VB;IqFWyikzLejnjQ?5tR$_9|>#zGS zpSL*P);{ojVTD$t=+d{#_Vk^SKYyq|*wxZ#_G!sap(?!FSIFHDoNif`apd9~F9pM} zwacHZ@RZRD%YCuZLe4QL?byWv$DoX37g-}abJ?fn@t)xq7dbUyzI{-U#eyqYo43AO za3^Q~=64G&wHTPmww!#lHqM>>hVFOERVELte~5YWZMsnw;2CosJ zcCtHt=J@jL-F6*zw*|XR&Peh#z0f_q|LKQ5zB7*HE`jAd8#(HN+jV6dPRRaJJj6L+ zk#oa~_YbZ4OlnlaGfZ4gtvl?_#T&CTr0Bt^ea#B*k~S8su`c*(Y++W~Yt1&D@6P3~ z=9l?Is(Aexk6H1wb8LL3aN^9SW`*GEOOpFiC%ineu314!Hn*=?p-lG5tu=?0kDDG@ zliaaXU~-?^PG;u|q2cddw6Q7NZM(xb;j`i`nSOWnl$s8+c4k*=JD1hWVf#fNZMh=j zD#(1uPTi?9i-t?O8=N zb$jc1@~v0=d9T17pmFl!u76JpSl-Lu5SMY1Om=yaY_&tC?~vjCq7^(Rqm0~D?B7?5 z9}cvr@h`h-w5DQ3MBV!-ZHo&YIQ%l$Kc#quMq|&vA{O=I0gp7gB-^_t`4(@B^y8~n zDL?Q^twmr|CtSvz9k4zRKzuE#lRf#CvLI^1r#Wr&fzR zio36NLj63Wx2{0MC8r0TGOtc68*pdZrdTDcXLV}+RPy%4YRekTpeu9d<@^`TJtq$~EvdN2re*T`fUG>z#BIWR zWA`*o;J3_Zn$X4@`AKos^;c^vEP~cf;Jul#uW{>RC%##V@1}7^8u7VbS#HmiJ*i=u zlA4Opx5_GWzU+DK3zjqUPf`$VUZy0b;(ChJcV{#o%ePzlN1P8eTv++|8-vts1BK($ z5@#$~U|jVfpKqIY#{1OxNy^W@$$t3%_MZIQD}nP|_-F3IQsOc?;VN;FYf))vi3=Ig z#U!iyufAqrVBiE-qz?ZD8eS(TEGS^nR%2jbI14Spu5D#J6d>aEFyu=_zuyF(hHEKI zWe(;EIWm0T?wwt`;s2D0>nmr~6nSYbof0%P?BOh@7LJ8F`dKBvJ6HbT-QSd`UB`Sh z`$pG&k3bz|UZt;gUUyEYIWD=hb;@h@jgr|Kd-@cvpZC(A`tD285y2@d5)~3z54!~% zYU^Fl!Yl2_DW$e)z4g9OgJ(Ol({C?GSW}s=+|Sh}?0B$1SwkX^h4panf`lJ}B0Tm@ zO%L4y4EAtvwTU}MzOGYp=@3wKvSavpXG)Nl=F+n3GMV<~OfsMYM$j81EK6|(C35BE z4Gqeldrf{FF#EON6hs~{`?=5L$8KXNdynzYeIVJNdrjUiQ++m3;#t4glOEA$6U1N5 zl>N3v@AG=?@4JlNEKqztNy3yx_&fsxgCscU4d&nYzdl^xeUpR2{(}Fvc7tk}|NsB@ z23NYrGB7ZIfJ8--1nc4ik)EbN1JLbT3ZnS!-TS}jt{->h7J=E{ z{+@A|zxCr|t#7J(SJ}w;|L-icy5Rdf>rd$4Rr{N=y?(9xcKY4MKTB@Q|34(J+Iv;$ zz@{5AOBSu{6EN5w+_kPM^rNW6uHc{lj?Oz~Wo~JhbY*1^`<=^svp9B~Ke2It{X5Bq zJ)wT?>Feuu~mW^-69*V1Ed@}BFvh4tAs#wa9o#H>5CA*aOBW3teU6>{_L zZgf3dQ@N|nX|l0`MN%c(X$I|}hs!0FoZZ~XW?`38JV9&;v-9LcO^>PUEe{S?^7U_L zHoRyuA=ymeW#%e_kCUy9XLqfbX~_OQ_;+M0pL~FFr-CiNmV?;_b)ApyB^C4X*XDeh z+%xx@^O1%9Rod?|Y(BNlVqEk3ogr&NuwlpT-iE#M%Y7bjeEp)pu{h`G>WOs$JbuPS zX0;Meyt-%oIVao+R79>s~F~Rmrs>#PEbecZl63FDtgx#V33x@@v)R zuH_B&;CGxOmc3tUiGW3xV24nyr_#QZX|1diJ?GSl$8FmDJ4-<8+O_oy4HN{HhGt#A zwq8MiUE$Fdudh)P7MD~}@r9lrLLKKhy5>Y6ff^{J^}wGSEaJT6nSJF%zW-x{{S`6hv4o%7xJ zq;tC*rbQj_H&QATy(ls7!Cv;?r)DMuzfSA&yw)7@-mU$-!sfa+vX?Dd0;~3&R<7ld zTE6#7>3p}hpXa_T=1w@%c=dL*&Si(JMT~Rr`7XNh(p>XUEPIeoT!hJ;b0^c3tXO`< zG9FzPRsZ}hzhLT%mx`$jn#p2KazB?V=%!9cXIQBbTe#bg$ufv7v+C!&SuuPMuUwy9 zJdfw%lhYrZrycO{*vIp}h{etMmu$&I8A;qGT284VNz78!1_) z5>vgFMkHKaaV630h-|X>7TIKTtx&x?mozr92(IShEKmK&u+jUK?|13&tyPYS+@}^^ ztnl8mK&axd&IL}B>#sYbY*beC^5dGo}Sm`I|q<7H;cX zZ}clG^V~0$|1+ab%bv4*KBqWZj^WbOwTr&Cvt7bc@H4j&Q(DV@rR+T7;oneNmFMo ztv_xaFO$zqn{{eM$@;b#5&D7Jf>S?UolwxhFoUy6xaEl*kQqv>-6Y3 zr)CsLf@5{7N4#1~Ki9??TGlEm;_COyEtHN3TJAZ``>sRai5#~n7vsJlj&jSYB^F{= zCkPc@mX%0)*(e$K_^}hy)fj zpMQ$n-?jVX1tm`Ix&OoGysFQ7^C)!cqg915=NMj1;OLBQIq}wlxnGgzWZ>xulg}_* zk}kh~$?5T>zSEriar<|7PUG^nR@n1TsdllzMaAitoFBC*P7k*>5Qy|p)(tZ&JHTt^ zD0QoK&gwqTdAC|)>JP@qt~L0d;5Xy63Ad%Lr9?{9;q$T_X~|K_=VVSu7Q05NzPA(b zUd`eYZ8E{-^^MB&0%ycB<{G_D(c=vZeK6Nw?Q+y+r@kNM`bno!4?4)KowiZkdv)oJ zz(rrV%0x1l-*jX)cic_6wJ2D+B?CAoWU-4(5RbNI5`n(eEcLZU+tYOTv^F4f&~ zcY)~yw&+PSz8&ySXDzJI5treL}$g`Rh9z8m>bd5Zfm_dGU^cfh7)-RiDmc zpT5L`r^Qu3()e-9_y7Md_#T$+^=Yo~-}Phfj-6ql(^AS0|8Hjc$2cXl*M8+{p?_hs z#LRd7%fEW@;W>rqS9O14U(FNk@&;eExOIP;!1*Fv2?E-$%eK4=o;oI7vAyNmDT z9J>TH4^Lj>*HqhLWP5Ve#5W&W-gUlWU7}%-T=5{8F=-3`o`XCS4u9AinZnPT_^>*d zQ(nsH_`lcc51pN7+_-n;P{ z-j+|1s#kRKxmwoZ??w95_h(m32yHVLO%~Bv@SgYDsmQ0*!58ut&ko&Z zzUOIJ;=L=|BiA}K{=6m~azZQr-i+O@d?p$n)w-u1+IQ;fvWfD0neJ`rDO7Q~8M|)X z(b5^E+akW1<4eZ<{GP3T){pxi zd|PYG_C>>BdD52HO1CpF&+pD-pY^5UP>An|Tc29(_DfX@g*R2XOye_uC1f|@^rD+K zul`+D625!yVU2^_)^|%b--}K$e0fg1&Qt5|xr6#A7wM?5rFmYdez|M9O4RJ2O@jUs zS6d_g?^ZF~`QZP7wKJs_@8@BCzqZuwuxys`3w`I4`;RYOvHd`B{-e|Ov)}j!MIBzJ zx@5%{xr_6;3%`AsY_{|It}}}B706EA*nLy`v*O>SGin}0{hw_5$kMPjGxACP z^sk>XJ>@_0>2KIy*M4kfsa-(2Qk>A`<;SM>`Aq-Z6mZM6E>d0f=Tw1|1h3Ag2GTp0 zD9OBXbK%hB)K+d;H&N8dYf^{#Dle`js)fgoy;3U5@IDzldHNIa)vj!tzbJ=R=yu*- zb~|hBuR{?JTsfu$c{on!qxT2%_u-SS<(`@F)4RnbQ*rO@vo{}g?ud!|!`UdBtqox(zE zjxm4P*Ox1ISK#u=KWmrR7543SvyDBZacX_HDA$FKJ2tEreu|wfj+!fe^!XVp{jT#X z9a_T7SJ(8^xlGw3_+quy^JNTnvutyNezsjM-ojgkDX@iAB$L1vMBspEhuHXIr}dt|srA4`ZSA9q2^M~0jQ z1ksZo(MLU?Zq<_>(T2L9Cq1H1dPGljsPW}Zf6^mrRa*CEp2CwJ(YK3~pY(`c>ymrY zBf7cG_-U``+$M+Y>i8!;qN=66FQ!VpU!wADoBpo@W*^sR`BfDCIshw+517GA;a>;L zp7x2oo+C0x7L~IdsYX&+HKo*@cc9e1_pCTW9j_= z`{DZ)R=+PWYgI_w|NcK{mt4R<0RxNs|NH+p{QnQyrw1yZ?>WqWU$B3@!ukJ^|67um zyRSr=YP)unkwsC!<)R!{`=86P-=A&^Dt$5kzzOGD`);KPVvq~S6aCo9xV5|Sj%bOxoEpizG4SM+`s$8GGaAJ`3 z;s1B3Y%SNW#k`EQr;-^M)50g)=s5qF&nJ3j1+&4tijEh)OT&(uKAbvJVTR^Dqj-!XF&%7}6T>rMQ4n*N zoaIirMJA%+8YdEd?Qv9Dk>TLPYJ6Lncde4{j6n9{jU^F$Yu+6EVj~j#W6M=zcH+3ej#(bNqB-4~?4 z^FH0+Cz$D}$Nv1pqLRr?k{{nq&`%0DSiswv<0+^#$uwWDNwzpMBYow7bM_xY@_AynXK#6|C08o%qgHKip*`nlm8HM_iSSR7p(6WN z-(JXW?UvJ^7OcPFV;oOY#NPsEtK(B&%oD6v{_NXsers#mn!~xwmsW1n5DSltl$`wY z$o#ikcbENQmXn%$bVFZb`{5HQFUt94ub0l25?=IkLQB4J*WI8eAK(3)?i4GKw9Ds+ z-v{+C%bD_nIIWkaZM;*X`{hvI-QMk9x35O%y-2b9m+*5#tg_Mbvqf>+fB)&TZG8LU zUHmM+%=JP4Q@VZ#$xioQlk_6x-v0zqXZ6ohx3}L)sWWQ*6LLpxPJhbo4Nr&pfc*7NH0x<6O8{<*UCz~+g6u53NGy|=B~`}gH7xAxE6xU_ik ze^^{}&7dK0GLxAo=LwgRlR;{r~^=?f(zoUVr~@wBw)m|NjgA|NHX)|Nn^( z{{L4fzL2ot*MH~#e-0k_*juYw{f~ixbi4Otx3-{ge_D*`@2V_q|S-6!Sl|yYGN#rOc7MjWKJlNl%V7D$y~!HuqeW)m+Xa zc~-j?FFC&U?$bx#9(Cj?Xl}MV^X{2JiIx1^(;Atpmn-whT-$kn(kj{Wf%{A5t1w_jC_ zJ7HDkagcY{SKSx?KR3yKIdt*mbJrQQ6G{&{E;V~yk#~9FX2~+Gor)!M&9J;tv=Jo#6 z+O@xX(hfamJ#Tlys`$m`yp7Fv?`ClF{hz12vQ1Ia{e<$>w$EU-}ftG&rC6HP1Sv z|Lr4<5U!Nib2Ba_UY^<%x&71}qvJvrEo)9oUbebnZ(7hW=hd^+_m?*FZdd-K$&HlzNfg-)1;+HWSz4mk8EWB1tvE%sk z+O$iOif5;~1s>+ydhm&mtD{!%sWU zxR)5mXm`rgaPG){zv^Piq}CZ{uP!i`N;4EY{dCoZEUUBaI%leWo{rJJ;qz^?!{(>? z(ax%gXa8(GCED>USd8ne0;jp!R2LIw?Kn^IsYlG2qm3k&OnQ)ZVzaT_M6aaTjmK7> zd@<=HM?PEH&cvh6vl@3M8YRtYytCnv;MoIN+vi_R++LHrEiT10a(~>!ST<9(nF}Y) zdQ+il8gc&B+9%I9Gz2m*7zPz`OC8ye^p#cAlH0s{jOf5$|n zJyR6*_4PmOl=*W=IwL}JQ?HV>g`Sb2-pP3iods%(n^dkXm#;}v5AoEVTA})QgY1TG zr9(3nCYPzYJLqIZYL+HyOs`aJ%~h*QSC8`3%8t@BGtq0!ReQ8S?vSLGDFXw82DoT< zkx$(4{{I4jGY9^+fR4TZ?L_*H4_zXkPEL%8djFrxeb#a>wL@=C{?7d`{UScKGCEkRagn>%j*73- z9&COR%eOgh>5OTo0v`R(eXwn6LPoODj=gI`Z~R+-Ryp_Kw{=e2ytn?$;lFtICeuzy z?GHgRd6pkmELkFSdroN6!dU{b+`1>NBlc-TYW`oVE}Y}+nR)pAS-peC(Rv<1Pj`3l zg}tuyTx7GoDLCz!Dx>V0S<@@_>(vKNVk_NnY=iS#hbGI2?6_wq&Gs}4rQdQ_;_JKd zvi`u=0j=N_HmuZ>4t$$JZbE=z1scD!X3C2IdXC;x5+= zuWWTMJbvSwcHxpoeA|9|$=qIlWMZ9a-;u-Sd*c5!GEZbb{!iXwo1Bc>?fq{(YAt@S zr=1p;$=2s9-Y{eRta26WukqrUb$nuFZzeVW)cGCk{`jS93!libg5rNSE>@K-Fiw_E zWDl6JG3EwiwL$XC3CezRzKh3pTU_DeXpwtT*-dBV#FA3JwS={`4Wa2tk8J~Lx z>#X*rxo_%TwEpnIJtCdfH@xl~OsZtB7B1i5aqnQzpQ|-ik1qdg+JD2V@>R)F$18<< zq8zR`vdvhtxIFB!^RdF!hHFoy-(WMNS^Dyf)?57d`L2Dotlp^A)689D-d#FRcFpr+ zI$^)cHt_YYG4px9Z#(Iu;TU%Pf59}T7Gl$i{sKx+?^S}mV2kx z(nVJmD<2DZcBZFrwM1K$sYqpU!HnE9Gv-$6?@4~KWXAQm8`pnVE}nNi|5UNWs%eTc z>0y=cj?7Iowokn-)~|Oee@@!3QrCC;=PNx|a91%dxv`XWW8nnlOFQ_YEt0>kvMH~Y z6SP{jDKqNrzxkG0&&s=AbS8hBoV31aPN?Kzn&0CTO~9}-{PC>gW5KO zZuhfmoWmtnCqK34$xV~_evGZ8;J|kMzFO9nk`Ldk`i$Nm_~UO>#wsEEecPsrYjZ

BKdc;=f{h*)wguUYC5tq^yeGRxHsa}DC}%7(B!*_H^-#9Pe(6GN{V}??^OuaE8b^W zcIt2Z%h2}{hl2f|%{k+($Pp8+$f??hi~VFu z?2N@6EP6>h6^lh$3nu?LdnQzb>Gc19T4#cJm}+;oEE2HVn_^MToG^%T~`z zm0PwtU%IVd_|1{ofQQv^3%AG5#XJoewYHIr7iN}zo4cd4zVCm8eA4_JySKHBzrr5O zo|NCeFYx!ohwanl7yoU1ckz&O-*H|3IypyMo@$+P2aSNE3r~JL>v(CRSwr^m8gagL zb}@%`@MRsjVjZ6H+jrm2HNS;(Uoc$`UF98n{j}b$*q!B{?q_r8yX=|uangzvtJhWg z9_^UaY5c1hv=oAoA#U|@A6F&6-B^kV2AmBYCT0c(hPCY{*Dx?J@IaH)_eq)%WU;_$ z1p@;E3pfEa{CC(Mckl-T149Hf=`7$p!L%j$IvdYn1`(IZI@5Zl#h$sZJZqtm@qN=p z*FC4I6gPMjDGG3;m{hL5xZce!>q~n~U(b%0*UdF2J(<3_;N9wG2L%BR7N$mrS@KfR zQ<(TYo?lRT_wWN2A225plPR=dKA5ceod~4#%)gC+0eUYf=o07|kpc?)tgLtw zmS3XgG3pgqb^Q6+v)kt2D)CysGaI^paqQWlm)9h$H>+Uv?iKI8DV)FIDR`zRu$k}B z(fAjsHZR_>Z?!uSD;FRyzwTC>Hk7bh_Q?A*RA;K?;Jj%tk;lTd!5v-rY)RL99l1&d223FCOYDJt~?E4g0MpKi#*#XJI*$9{Zh$4;=?jv&B_^U~GzS{HHnbzVgq&?um|V z;*yJ#7EI1?bn5GfR{1fJ!|RYi$J6uNPQ`Vp|3aqzeY$ih=N0n+700ElPp$037%s3k z7%;HgvIk#fHb@ni*XFapm zhb3wWAQwwcWBG_H zry(x{vqaBnKc;Hn$#TDU%Kcod^5>BBuZ;@dCu>?v6xL#3U=RiuEG-HGpQ8UiaJaC* zpy0s&xBtIwu&Ax`Wnf?lf#klkvtQ3!t-y1HnxA+-f#C) znp7?vuQvKt$Zcu#o#A8SJH|_`58fZR*e=j!-EicC_hP$t-utna##8U?ic|ITlH>MGU8=&=_hGtoGmGUlRu_4djm`{<=S`mBe^s~0 z;pLX~N$~{*Dzme9hPv_1OWBZ{BgNe(#rakDjiG^z$E7QqIwknpQg)fy=5h0|dpqrO z+HwC);rzERR*LxkFd}};qSoJleG~xnp&JZ|pl4tgPf9|D+-41Yw zU;C5yHt$`<5=XxsD*}6&>u=95b94K(<)Q9u{=sw%CwKMDo6zz+LC#=y$*VMWg_T7rX&f5T%Xh4Gnj~3$pvT>dX>(fA>uGL%%uSO*|YF|;e@qSw$3b>B0pKY)WiS3wP0Yc z((3d)utLUND|cU4^dZjs(o#$8d5(ufaeHcTvPZn`cC0CtpXgtv7p!kRd&WV9k1HZL zEd9P0UG(a^Xw>tFf6>K_v*Wmoro?V2|ELlnN)Cl0T#{+* zhj~prO1xgacCSj-*}bUB|Hj_k`L~%k{1;q~-+m+F>{%}*9v{D%Gv3!u?A;T+Szxh` z-}49V=WTADSkit(!u9Ew55gWH{QGyzyU~0}bvyI2>$@X1+S#)Ay;x^ix^?|&*`1er z%k?a+Zq7LS$e1nn&H3Bccw{cj^m0z}7Uw^6F2l92ggD*Y1R667E z@pbF(9w~BO{Q03=TyBco$q(AReYdRQ_r-p*UG7%yTNAjmhx@_yH|*==)*hJ<;p5}o zw`Wa^PtxVz^Yomi&y^IqZKRNAv6sz(n?KnVKA$^rGrw2=2Az-Nj$nskCjF{_4(iDD`%dtW<%^1rIV+9vSb`K zWfd`W^0ChoYq;cVS0XGQWt6&p{gRgz5^J-CKVO(~@xREzf6ui7z9-~{HzjQh z0k?z&|MfmRm~i1h&4z=ErtN27U~Y$$a&NA)_KP?Qus*Q*&Qf0fowu;W`OlZR(LCJ` z-)%V3e7vB%yu7^oW3t~aqpfq-CgvCIwTS=n=3;R0=duOURK7}IZRj|zOpFRD9ZYXR5t5Yoz#uCxB7x|6gO-#6giMnoqc)F zKhO4eg}(MqulHs}r}u7M#mhP=D>t|Ax@UN55M%42)(Px+hjb)E0$z4M)h{~8Ej7uK z^_uU$7H5@j3EFW@*Ne5kF4Q|1-xc~fyizgzYZpuWw6!g2Q$Ir&Pp{55L@9oNlk|JRQ~(Q zE7$i&mUM5C{`jekWyPFpZbnbG&z^Me%j)g3T&H}Uc>2xvWiQ{W?(W?xylrav4-XUZ zM-m?y%?Cl%B$EU#O^kwiTk))Xio8G zWp}-ld`^+Mezw5%gKF=@cI(gnee1VPL-|)`iOUyXew(;qkFU}y1;(XQ8mfF80?jw2 z$+I#Xau8uHbo{=aL4M+qUcXl>Zv0O>c#`2b_ng3j3kSC-C?7wgYyamDi*NtKhdLfc zr+pP>geYE2`PAE@;vXe{{pFeamuAjqYk$ba*J8(Uh=Y$yZdq4HPL*J!-L+PhYm8C?f>fbY24I^7czLzEi72L8_%4Lt4V~d zV1OUQfS)0?#U-*YQJCoJ=(qe;9-wAFS|*Hem<$z zob&A7B7xZ@E?ns`TQr`$6*baVYh`{vc|ul%PHPbJY}JOtE06ATTBWak^la?9-&~RI zPIs<6G+4^>uUO(xrC~&T?04Z!=T?0FwT`Ln$>p^AN=F^7#3>Oq*_xYuU;aG7CvxN6 z^gk)mNwbrduPS=6>GI6nj=#3H=Bn*a1*Xfqsy}osCHfS@$wcdK({^P4eq+%3|Cd-0 z+s{qKwk}07d2RRRY*_km*^`HQI~V#ptCTb5w#!a&e4}jG)4W2$>)FkJR-T97Cou>d z4*TG_`t^xxq1+qnZ~LwL9h3TbQ*t!(221Nz8;{0)6*aiM;+)wV?+4ZQxdq?NcFyT5 zWUh#xc2=T&6+@b2`Ul-gEdxGX_73TEqp+VX*I1IQ9S*e|Z!wjh&$z_y)Q)L|3%?mT zZ2u9&f8hR1-q|-d@iXqwytjmLhk_D=f>Jz#fM9(Xqr>hi3g%K{Qa}GzSsLsfpzR{!9L*VM|V-FQ>ZH%a~ylBL4ex&XF z*Nut(r!9V|Sk;_=wC~^kwW(ThF|zj(J+)rmuRqel8O-_YRSW0i-{1dhOg7_wRIRGW z^-hB&EV1*d`Rsq&%-Ju9EvylJ5%2Zu`r?1CZ~Y{Ho%FWveWhM<^pexU6NXQ(UHnkw zz5PS5rsHLXo-(n+T&X{6IkN@6?UrU)8|Jz{^HTnO8>y334QChKzVyoc`mfx5#|}8A zepzVP5-7=@$+IlPEk)|E)zpm(k1+(NPFZDmB~(&>HP5b4w|82H|KB?M@4SHNZ|-UV zO*^5Jdu~+!n-L+h=+mFSC5vBkorvAw`16t=!!8~T;m75H^RQIL%o~WwbBfSz2xKS| z7r9jS-ChO;25xY7L%-p}e}M@LF6@mhIvO&Sfq~f=lFyP9SX!n`5s}nj=~2_uJI5p< zb?6Bb3m0=X$6}3!zrWHZNp&|Nr6P;pL_Zs_s&MI(zD6cU{-~#CzZq!x950j=aB? zS2Q;43B7L?26525aLbR+BXS86UW{U2*rAxbv#A6Ic6$yoveU>QBxb zj2E!n^3C&yWN+h=?b!W*TfUI)DIMKFi!gSaIKTdC59y}{oO8X zOcOb-zn^H)q#_u^G0}s$<#atqkc!caHUlRPIT7Wb2}v!NwN%`tp6uUk@$-dfCy&UX z6E*w76%|Ab4rOvq6&#v&P8|z>crZxj|2E#e z%T@2=oA<4{amQSqBwnbztG+3u=R}m2>ovQTT?$i`cwZ?k$!M9dier+S$RlO1iyVr2 zmlpXXE@9Bj%@g0|o7Nv7A$UUB^5f+Crb{JDHv0Rn?)E>Q?sEEJDD#7`nTI;s4zG?< zSYV)Z_fx2kn~0lWKWPuPtN1G(*=J;vT6=%`^*H{I>jM|AdH>(({_oAl-s9E``)i??EOD8(nR;b3BzJ;9(yCluM&PgWoJJ9d3SLjBS(FM7Q-x)eT)-W zJh&f7CHylkO7U3C`1NC%5Zem{g=Gy&pEvPkI4c-5da(wHzerWs)mX&-Nj{xJ-sRH6 zy=G^h7zP{()*ky~Uf48yw@@ zy&fJmGKlb=G8Ie4Wx=_T3|nP+J+hk^#MP%-1g|Uw95NaduKqVT@F8Hv2F@2(MHv`a zWFVP%&-CW$+L;1JwI#B1Z*S{eY|4M_cD2R3-7mN1+T5-?etui;{%0GPeR^6}|I&wT z|6$IoT?P4}D!pf(_S@<+tB5l^)HPCg#mt~FM~V4i`kaJk4RR@LegeEt0<#wW(Y#u0 zKE;1Y6_Z9Q;}jORubU^e2mW1Q!oa*fN4AG=<+SSwU%XON^dC>$CFLgm`qL(F)kf}y z^Li^yJiaMxxMlpX^^%_*?_&3uEH{RZeIn2H?6_pX@w#Y|fiz>^Imd|U^SO+fW#%@2 z2v+{&TX9f$NwkdHi|&{yI#b*)?M}|x(enG;{AUWD`tu(J*OquiP3W1%ztF&6-Q#V} zCBBoJ)C>J~wCFf&+UxU|=53UsR>gf%*r}3)~*;7va;HQB6a8)JpV?8l)`&CYN5 zxJ1d#M@FP~go*p`2GYGX$vtvZKr&- zDB!h~!a1fx!AqRt_B`rTpLFijnP~#6_G%E|T9``k&Vo}OoWwP*H` zhk7EM*Xtt7X328|Jh3(0=gxWYp8j4%xjBtOc8j_%DMn>)wfW0%%!0J6rp-lFC1dpI3c#pL36| zxsu?#B)7fV!UvqyV^^Qi(hhewt|?i$`1cHrfGX*Si=)Mt_wzMg3T2nK)qJ@pS9-%{ zGu64*A3PScNHzc@+w<#Iwl z-h{p0ANOs!ybIIhJz)(6tM^UkopU)Ol3~5*iJcn-T(i&RcKoZn$8(+cu=x2Ti!)Vk zL_SX1nPeh!tmCkEt()z;kKU@Sm)}|3NxxElEd1Ex>9Lb`7|BhQxOw{Bg{g)go|@`p ze{p}b7tX|P-}Gt0j?&AQ>jgSnjQyO{^kZd82NUj)Y}GUgJY{H4TZw z3DcMzHmumhoT2nX%^^rZw=ui%r;`Q4*NL+~M<2?WXyCwpcd~e}$3(_R_AQD6GaQyO zt>pf)N#L${(7U*QlX()GI6RCMgc@U}Mp|xd*?d^tMqaq~no8r;C2>M?egFA&sOvMn zvOKuo^G7@HC#z2k!fZ3eCZ$crc2FDR4`P}bupPv>TJ+QJcz`BQAUlW^W*l%Z`0ziW zC42%G0|R3-q-1(?d21wtqd>#Oqns}p&Q4^Tz}2yW;bnv3o}Nt;IWPRZXDGO>zG_qc z+P^Q{7GKOrEMLEI^Wt8!>#j$xT&Ow{Iy>{J+M{&~e|OyeT*;xqS-Fs7l8A#tW#fcN z0>MH~UQRxq9U7d5s)|cgj!bFkKoZm!2oQ@?@MKic{42dhg7Fl)$C0q_>fVC#8VxQo z5uco1I%`Do1=%?~I^w?4JMz0g-Ff9J8f`N^rFLkra%ix2Xs~u@eijJk5(t2xRTJcv z^1TdTVQgh&>QY=L5wu()sY|gGjhVy+7GelmDiO5Yr~mCucg6z>0xp67*9m@Xc>Dc} z!BgQ=3=WDS0=Ol5!k#CvIM9VeBIWHJ42d;9CJ$CxN<96lp z_W%2MA4)4(TU%RKK4VBZ8l`LyoA4b=b;aaCOag$lGm#U(hnAqPt2=%iUHAY0|38m! zyv;YA+u$<=-p+KGf8hV~2jBkx|Hl19YCh=17f3=#Vqj8C=4w!4mN3{Ez#?*>ts@|< zL-~e)=qa8;Cg~)nnTqGG7^hsB5a{g2%gKFk{YlfQ8x-Hk&h`E<^P%bD#VrdIMH%d# zFX>2>;Al|TA;ZC>7_%tAfO+wmo$K|kzX`t7SG9Jn((kDL4xSWG!A*4{$_`67B)J3? zf?9ZvatLTTEbw9B5K#}K_K~O1G$zcIQW6~3&>p?AN z?(ivJ-#Jw&?Tkg8N_?AtYQ zfy*3^fJM0~8WYuorZh-!dO38ks4BQM2?;1Ua&k;uz|!Ioz~rQ&;be75L{WC4(h_A~ z!ApXgxVem%1T`36a)>CL*&X{^i-DodQQ_77QkOk<%FDbP zv-@oMg99%Xw;MDx%lKF-6-PY3ae;B!;*jQDwsC3~cu&YasQ=H)D6bR{c2X-+HK4Oy z_+OHc+>MIPJ{ddZ@4xk9%jRQCP(*cH)QRf2Ksq#6BkN=s7#MiL-4_9el!grlG(Y^G z9dNy@NH2(ifk_*Zu-@J{yi49ufb~OH?(J>4>yu}%j+lMp+ngKMjLJom=e?5p8eVU^ z-1^;p<}2oxV`oi#P@Z8^a&MPYF;#&PGkP<*GKz$qCCpx0rgT>v(T%&URYW$o0E5#B^!!F*S+u9)EUrBkEyh1mL#uN$w2nCA++OlUl`%5!`AQn6E=?F#0#EIXx|{uDYk zDg4-b%O`q!-er!$OT0(z%tc!NUihi9Mas~Sk$3lFUd5Mp4YN+{>+RpV-fRl@J8#DQ zo8LAT-K}MOs(xN4L$PDKLgk;g73U`J3dsAhV(wqNRTYaSq#53S*5+)fw#Liw?{=rm zv-RQH)!xth9<$6j=YQZpEaUs7+nA3>xva#NaJLXs62cNLAAe^ zL*NuY{|AdNr0tSvn%;3$E(>Ef8NlgCjVrS zjgiKGhquksoo?q@uw}{rF)3NQsy1Njsiqx5yTw-pZc7eLla*;Xk+(ZkK=f}~aCer` za%GoqbK|VW$bw0aLeJZ&@X>--*ky zZ;9X&2eBvXxhI`W`M1XE@UyegS0o*0eO#O_x^VTg9a~!Dt;`p!dTr(3a@#OybC6Q+ z=Jh7McOSYp&YKcu!q@s=bZLF1+r_46F_-n{=D(i2$?5p6^z=}vU>kvlPc4H4A9_YI zhc3MFCt7iJ?zX+_Ozo?h6-wLA&)&X*-KhSAb$8s(FPB^d_Fzf8jQfd6ys$-6c#^F^ za^rvaqA5*>|Mw3yW(q8CE8p^*fq~Htl3?G?G>vO^6mb9lamgXR24~6bT-FSFvVPss zt;a_lhNlI|Jrj~-XXYrlImBXX$SPa zP7<)6=Ws7DWBLXbG200?|GZZ<>{+bJud@5oyv=>jY$mu=F!&y_wtCp8a*k<5+@v4V za~MDMl~pQmZk%`8n(L|1y^BeURr^1QFh86pzbiqaEzv~%9W|Q|ExBx+Ts5l<2fFAMLT`?Ec~;>$IeUi?26)p{->q)wHcgLo*Hsgeq+M7i;k+1 zI|P?bO8jUWRKV%e_mOvA1;^yvJ5#6GPnEgDY5T9{vY(kZK_!v-~P=J)h(E$5UL+@#Pe#74U^WP zDwRbi4xd$WJy?@6cTt92kwak9?6R)F&lB&9C>Km#B4H-)8GL3|{}YXK57nGE=GX}> z&oGns4ESGiN^nL7&@<+@6GUW6ku^&Q=Ogt-g?iU z{vRs)x%nmkFV;Pxv`@39eYO1`gUHU{TS{34e~&yCid?I=R4$__s{|Ia}u z@jS-h=a>3$pGocf(2M z;v-@%-MN?&aVO)+$qa-#9w!*cqh@PZDP1 zk)0!IW>d&+@O`b%ot6q7sR-$ur;peAx%hT_Cpx zt}$h7>~sFC_|G}+_E!EoU5OHG3qqcR_WzdO&g|`AxZkl|wo+XoNAu$^Wye)!9tE`% zems}mw6kG(cD4Q91yK{e1UqsyZHW>uyT(`}>u6=3n$LVLy<%#wu%%Yq^XJ~7<|?9& zKWEBwJKnVDvyJ@C`|!HW@sp|}W#a1d zF;3rjc0Mgu`(xFAJXv*q{2!wi5t;dp-%Jhv@AJx@q_Oj3c-N81TPI$%RO(b{xARn! zd1n-%Ec4&k;&bY;lcy(havfTmd`x%Omm69-_p+yc-Y&ZAwWQE%2dnu>)FUHuVtupzIOSfSfe7A%*C_-SLQ+QFzw3usnF-oIIf98d@^Y4rjUFBZB3zBH<*V5Rc7^?22?N<|X#@lP}gk^o2 z_a5v$?Gt#RJk-y1CdW>(OSa3TSVIi17IExUTNcH`ld#G|E+Ad&lckoNa;CAUu=dJ` zrj`wzT~EKS=qaD?r?V=r=FN>V)>~_aJD(HFgG2~LJ zQdj8Z)I_rr|4lmnZ~FTqJKot?vWjWfn;#$lcm7ZR{jmNG|IfGDbFZr`o5p88;eyL% z4^MxeY1%7WPbRCd&ik#Ev+SafM|$QJE=~8vHbHkb&+iR+_+!EnD=Co)>kgR<{tw~0 z5K^J`XucQYuBhYc3U5;*qZR~a>1>s|d{rW8THg9v!=Q-cd?J1eoVWVwXzpq>nv>|c zIbhm9okTvB$J;u1FS7cExL5~lyBuP2C}I8IHjjsC%OZ-H)Ep<*IxqPwvh85b`a1%< z3wGrg+`M|?`}+;o_ew0iy;X^Sx$&pBR##36B!(*{Pj#MKs}$6ltaQmclH?9_kk~F$zkkat- zzrcbGqKUhAFfcHRKoaMhTc*J*1|mm3wqJf|8u$3p!i8>|idFek{km&E6dz3e{Ne9a z^Z%busC?VC>tN@ek7eEg@&O{hd#=?qZaOn|#9|q(3;!*>=6u z&&E*tgU6ogUn}ZXOEKkMJjFNh!6h%f2@1ituT993Ug)MWb9|((vHFz=D%s&N(tLFjPWf+f;*?yf?5XFH-8S) z;|uw4@E zslFVF?|D96x4X*tYrVqV;7|7#|6dUt))pTJGNvKEfN4)FcW05QKWLg4ef0+8BVxP^ z>l#3|PGBWb_ETtjBrksZ|6GHBp~N@PFmEQr>u;`^MzJ~yusk@Vc$l*=Xb$rOmmRL> zUq>5RFzQL3D=mEKxmtYwe}>1Gul^89jg9?UAQh?XEnFb^baSf3mXBBYQl4hlguZH6 z)&KsJz|^%LV^_+}l9IZ8Va^2)g_Y5Z19vqnYHDQs>#?Uj=&VCnovNE%uOrtdUg?wH zd5w-aJp9e~t*>$I`|6ynJZ~HWk2%vyEu0W|2e;A z)u#LqQK54uHcy=4v1u8{8kMh;Ug&%>=lqx?^xzn0o!Uco=?8q*bsgcwEZb)Ui`HJNcv%?n;1ud3GYzn(n z1w@$&nFT_bF6uR!fN9poEu0M*^$Z<-oJ&d>F8*T>kQMIOXS?9&+5TM@PxI}!UQqdW zfi_d1x_~^xB6p@hMFDe$i@J>~1UjS}RtR;JaW07zNijdsS;}3s`L0_fgZG5#llm3( zUui#i>{{d2Tyx>O`-J&(9xK?_oI)> z1|}U?xHqqlaTH{PKVOJ5exV4U*np^0Ue@a5xMngbsMO)Aknect(UvYY11uIHcT z9GDZ7)U{k`b^N3m)13EySSlhp^?u9aqk=|RX6*&)@1Dl0PiifA-9O3Z2)lHWbC)pR z*Hf!4A9`$)46<2k9#iT3?7eD#>3h99&8rXZSYmi&x5noRjuQT7Q$9^deajGQXSkjr zHeru>iiVAy&}L3K{tMd#Bzv09I2dI#c*JGC)>~n_mz{BKbhKNmSLJoC=whLYf4y%5 zTg?v{28MDo?R*vf_5sI=GsPeDy&_lNxgM*Lt@>y8s&JR}r`Uc>zofk=e5vF<)(G(x zep&4Mot{MTKV4Dr?D*De6}L9?*4e6FPtiy$$`#>1XRA^9=;6$z-}txfH}Q0@XkJ)$ z_R`c~c3+=eRVTJe%;MPjAb0|ApP9|xI(HBK&$H+7{`}k?VU*meDD7L_QzB~aWE{Aw z%YM`6=(!(eAF-aDSbc|K|E^E*F{1A`eq2A_`u3COJ8uQ1Z;Uu-o5^k`t*}#jW7A6q zYXyVGh^sXfPF~(hfnHv!f4BwJ_qV)LU7Y4oqPRG8!U@&I#R4-u*m@_NRBsL!nC0pt zyrhWLR!L$(=!Da=pJtx1t!Z}XGCBM9gD;c3=glkJ_g8$ipOgCb!`r6MlU{!d z14Z^VbQB!LC$tQvzPq`-lfMKmb>cB_u5UPI+K06%)cYq zO9bujJ!SBXf9E9ivzFif^CiAHvrK>ADOhvqq<+G|^Ns80|7oi&YwYm9e4ejzPbqKo zigVwS;~yA#3tsqQD|j@mn8Q5Z$wlAkkO*UMf9n3H0aA14{0i%8Se6~Zv`VjB|B~&* z6C6T2S6}j<=*{=p=h5!@H|Ki%`=HKe^QXf*)@yrxnn}a(t zlz(rTa9rlw&;E`{2CnmG&Yb^C}v8Jg>I@fq=(~^semfg+P zI%928T*6Rs{Y$Hjj;fZjecBvek(AyOA(2xzGT44tduqm`=tyJncYhbma&eb0e#Wcd;y(waxayghd?x-5)0^WZz`7>@HwD|L>ZSrW4EILh(rZ z)d@WecCX!*U*F8+CcAIfcc=^g})2p+dGoS10&f5E?ZH}eriaFajkNQ8* zlM3MOpDoj6%i6o!BRxMX=5SZ=in56fTH1N9}ex9dbsN&h&kqXY&?M=tPXUE-De&yw{RORi^WgXaBk(-yF1n2>L1?q;@8WWT0Nk1xyR{E&CrAJ$!GW`e8@&v2VBE zOt%W_)eb7(;gWni{>ahW8WE2t_w3&=bCLA@cj=W1N9*k^<8vO*yRqnJ(L;|(YoBZn zT(e@f^t+gs6GXEAAHULjtdT!_UE!qs44D!Sm9M#1vP@NG{gQjRS!$BUPK|Wi4+1Q0 zQs>h=t}L5 zKejGxcUjl@f9s!*vwOEry6!00$)h8+bV`ud$_6{eNoOLMUTxjkjU|CF;@tR#JgNfg zC*VmMD2>PHG97{U{}(u%-@-9fhJk^x0+ujL!;=F=+&>EYull%hx#a5)V%vrCFMjrD zz5M9X!mp)%i0*B^KI*~rqg`>XCpIM%jG$bn*4M?r+~<(>Cj`w~zHq`}EsRTIac(-_OVVs}}y=W1n##AhSN= zX24v%zmI;`JouIpFfR`Z0a*mc@mP49M52w_wUh-yTcF@kFTC1*` zzP!N`z~G|6pd`W}$koQt>eSMt=yXtEVL?ZLg^Pxak_ew5S35_m^AsfkznMZDOL!!- zjo--qb6Os#FavDvGLDuYmL^T6g(8g!T@D(qP~oLlB6P&MkKU_z?yDnNB2xYzbk+ez z4>6UPqJh+y7v0}z^XmVF$OYc}L)sY_7~Vi*e#X&AHb)Vb=MTeW`Z74A87CcNYbfEE zeQ=4x9+|?mZvWRYy!!1nZ<~M~IvNH4VTk2gWp||p+!pldK zVhc|mN}0g(Xp(8+$wL`X#wjo(xA5et6RM?)t7G2VKi#nR%V#r)32jB9nqMd@y9E}6{MUSaq0wPK^Xr)(85kI)p&@={X;pTjK@?Q1I_mYOkB$Byo>|37y)!p-P z#|0+olbVUG4Y`SPnKBh!0}OQLNN|O_waVtu(bN8$AEZ@jmkT#4xc=#P{BeC!JrI z3%F^wWf)8Wwn`qvu-W`vzQe7%~1fl&<_LDy8nT>}N$ z9=_itGN-F7M#(7Spfw-wTMN;*FZfjrPfRqeR=ZbuYwF_Pv761Z<`$pZdCcz`<66h0 z$pIfH|M2{yQYU2JIp5`g|08t}KkC}PT;bWz^rtHXE(&R%pphTk^|H9bB)F^agowt` zq!+6U&T8EaT2$+isu^f~WS-_hnI}b47Kj(keB0vjigBlZmubI%Xjf^!z|(^_JkAL& znVOWN;B#=2jrGzF$(CKFD(8(v0{atIe>pF5=qb<1&7Zba=$*PezrpS3Bpd0T`Q2?_ z%ohYNjgMRSMP_C!zj%EpYVR+luFP&+&PeVNm?M55Mrh#Ey3x)TWGqBp@rerR(>T0 zMvb;49%YLJ?SuQpwl)8|y|N*ObmT2~ zBPry0RB++a74Np19W^~2`&vKap^Izj-=#a9LaxUPTwk<8ZuXJd5Ywy4vn`%~{_OC@ z!>C}-_tJIs|L2tZhs@t$)uwf1>)r*ccGf+gv;E~)hc6zJ{&t*;dYx}wzU#3C2Mc4w z7U7I{Pyfo7yczrmUc!_ycd(72y4{IF0c4V`K zf6q&MU%S@y*pDysdkn8d?fw396aQqf_h$PJ9DBIn+T8_7#nY!Zy}r+LBll>01yAHZ z53vNU6J^&dtWvm6oI5CSY{m>tC2RIVnFh^HoyL`_r`s+W23tik1=~fQ5n28##nR{X zzpLFR9~p$6nc^>I{B-hD!>5yv`ut4!>0=ma7i<@)73@=1G(+gby1##&c7B(7^wVL{ zQ%5E14-RbID}7Jhc3bu^aptBI-(uIytY3dq=%B|B=FS-%{Vjh2tQeFSJQvu_x3t(4 zm#^?CO@&o}(c{$b&IFYjr5qI&rQ~xP`&;~%{B})LiBU@ar9M%DbLxp7-cItrJtADD zMW#GIi#M0f}YLi zb6;=ozuIJXy~AaX&E@mY95#b9?z>5)p;-w#h0q$+0WU;F5!+3Ue#|2$)2 zAB(_A&O3(`ly}bGynW}~lT*q+^W?vQx{M zSEeO49z5-DyGv2AvtX)P`}Mg~zwPI2I#DOTM&_wP*w?wQ6l)wsukv)Q*w$>c;{EIT;ODn(Bj@}U`6^yN!?ya_nKdpN zQeP(XU1DI<_xWP}vdxpJV2j1v6^>PF-HME@0u}a74L>Ga`oV7cjA@-#p8cG@(|v41 z&gE9{?(@>T(x6qWVIP-0p}9q0*DSl`??<__S2X6UI_azKP;u-sR$U>Zptwx?s2=A9 zFHb$TY3_?uR@NUa37)mKMZk?qKjraUR_Q!bQ&Ayx`_!X7B1}PAXJe*YxzD)~Tdc6|hS>qx_WnHYKEd@{Z%=7bWp8;+VLr8O$F{W} zNVq$}eoC`1%hnrmE1$OUw+WoHZM=AL@}JrpU%eKdG>GIBHhsWlcTz)_DWbvfrk;tY zz?4I~x4LDVdcdlER=Vnku*g#@9=SD*2d;7Wa%%)Jx)n>@-O%-BqD;=V?vnh7iL#%% zAHMTFpZ8~O*~Gh(nvb51dQv};ZOe{_iP?K@n4e;p_BZ3I-zo-%B!RYjtJeR!+Q4@2 zy8*XK!*T{2uLqSX{H8yRjy!kW7x-x*=;Rx|PVmV$T8B3DK3$@4Coc5fG_`>H4ij0X zicQH5_{>_M@S@p4qOqA{hEj*m0jnln&I2MEQypR(r*pngI}v-Jevx8}fMS-Lhtk5; zGb}!Hoj-jfu6%)MV*=|cagX!``x`shCo>rMF&J|i-cYzakwJbF&&eAh)xlWu5)(Ty zd5OFsApwWzX0;V}{udnh!2RpMMFs}OHb@?Ndu8i3;Y5+6A7!VrP3LPD`p#Bfu65_` zLf14iz5IsV@iR-~^{N)#pP5lz_x9YcbeUz!$0U+_439|&&)k@ISLekyov7_);(yrx zn;DlX&U@q3VKF-F4mU0Q5c@I!}tol{QIdpSp+wD)pODmSg=l@8kZ zv|60LC);XqzezE;iaCx=euSqj@ z=Djs3IRpvAWFI*xYhPo7`rF_MXte1=<}_l`18hnQ^CCe^kySCXK)0wum+reZq$+Iq zf7;-~><3A2I&L#CFg=8(iJM!CWxNI0KG;>gKXYb=gz#qBS$kiq9y`$|Gwa+hKONWX z^w~3JN^bI9oAF=g;;RR%*RGxWa^{f_-AmWqn>X)Wpy$7z&*w*;=AR=Lew*=*sCl;G z;~6_70d)uZLLL^SKn=?z;_+*rdL<(P9cW1AN#TnSoW6?V{3N7(cIN50hxp(#CqRcek* zDR-WIvFJ!t%J9R|gqHaB0>*g!Fr1<(VSD`0AR9m$+cj_#SJhskzqk*pr({zQ` zmtCGP7TuYW^!buY%06!a&M5EVcN34wt(9B;?5u=H@#hJPRmCPGd+2o?#-O3{ZVGogm1l* z?!9WczwKJ@r_O5ri8G@8_lvxiTI$uxv%}@sqkHaO`A!=zTiCmOCR<)t?{5Y+X`}3g zS6v?N@BOZS*3Md>Gsv`j`RhE!xGu5SthE!gR+qHgd*x+4;rixNg(q!S%S>;!lVat) zxRP;I=Xs&3c#WeUE@<*USQsp}=y=NuofEbCE9cuz{8w?u+Phe&`@dwi*>Xy-LgQ`K1b@3Oqb*mQ0}b9S)>ymr)XQh{ zyd-l1Oq@1oFDj6eTNTvUzG{k){K_{Bhg<60cCCFH^kQ+S+>eY~tG=mCUcIGGDe&eB zpO!Pf7x=WWoO1DSoz2lXwR6I*WTh)x=N~y5HQl8`!Q|-KZ)3qNMif~RFSuH{9b8=Y1%MaQY7hL$_y>dtRZO*cXldL))xy`;D z@p#4(;iV5Q6m4o%epq5C*8g+Cmv4f*Ig2N#DV{wzzr~)tUg&e+vA1t)x~KF1R=DQ3 zT|2Z(}{mGKSs0ba4p%eiFZoJFZErGDJQJ2&3tG0 zZGH}~%I7H4z^QwWe4VjD`D^2oUz1x~CfpTIQ=i7_6z9~zx6Q!u^R6~_H;%w<7G4Gx zukQ#Ot>3ZaTT=s*b$~yIMs{%iiI8uNGVjWJ_8!?SZ~02`hw{uxsj^3EB#auP)P7zF zwPgv}x_zF&hX-rEhzdkGT8HpkUQs>H%(C6%^Kr#_5nKw!GgiqeB<$*oXO%p7qNMdq zP0B9E4>x+^*(Hr%-_84cGh1QDnaj3@uRmO2a=Pi45?(KS`0mD+W)mC>I#zC9vY0nT z=YHAyOm|Th{Tkykm19RURy9BHQYsfPZ4O9Vm*nn!fl)A zyj48GsM4#b|As**v~=+bT&s9a z*6Hhni5pmaS|;yP_fSmu$~s9mO77dTLuO5TgeT33QeL6 zdbL%B-{-VV2>W6#9Up8HlX75M@dT#>T^o`)?zOBB;`mXPw5A}eCP2AiNA%4C2`0X* zV^ti|9L3FZCS9L<+FfDhyj#L&nEK5PS>9T`JFXVJuB&0Apd-)!^^3a9j7|jcbJlcy zIJN2V#Kf7b0tQBghV{yFlGDl=S+-2I+WM;_Z_=8n0=dD$#$sk4ws7fvN$A-8|Cz_9 zo)?qO2eEUmoS3-z>aP_SLsDlx5wHvO-{ET9n!li3>cp}6l59sAnd}h|H@`E>ia}C3M$qPke;-4*+0*$7!GD*Y{1S6P@4zzWxhLc2 zTxYxP(b*B4uzDTe^ZiFHdc7m>9*uG{{PjQWodam(*i0tOCP5AXC*<>0g&My|457d2#>$|Np=5 zU;1s^jDO!g|9NurLr3_}6Py0NefInIneV&i>G`J=!^d|NOrsk%91xiM|3ksG2@J37 z7#LXnVMW^UMpjUf=Dxw^%l&uHZa?Fnb-iKnlfo>yiI1J#cKGg`S;a_TyzpU2s%!i6g|CqhYPjyRnK0ZacCh>C7&E=iUMb(=3 zEEdImojadd`nW3{8W;SionSSSbJCno@|?4l+;1(I%M=<|?Cr6! z`Q6M=svh zU9Ntak6%0Mq3r3MnYoi{3~z+1E&o4rMPsy}>vDEyHMc73MEz-9J5I>GOq}|w()-`h zkL5mH&ODFiDXz$Jd@eCD>a&`e^xx(^PBT{T588RUWv|(6Rl)1p9Rj(Q5wjN;shLQ1!qbFytoGr7!$?k0L(SJ2xC7c5JBEIMyPc~CY`xe!-e1ZyFYGy`)gf82J~U9fw*+SN=)#qju?+pCmUOgP&vl*HSiqqMY8LF%~EA(axv zRdLMrUr$ARQ08lx@U&9%#@-4A1gLBn9T}7WGhWfK-eyvmV{C2`mF;VOBmw6M^szp?vm}|Q#oru^zA!Ykh z9hK;M)4xjlRgZkyqpf(?V#kc>?`0J|bslY=kho%Qzg^=5X@esPHr$zE`~2@WIqYU~ z*7@P-v8`_ko5#)7-X6lUpL%+1DZ9sZ>)ETyJzPaDvsyP?jNFi`mtk46V+bwsoy!r;kw(tDYVx1Fi-+9P9 zEj{b3d;QtP9ZI&ssOSzAg!#?jbnQwBhktcKH(msx0}J{#Kr~`psA4e?mZ)g`d0h-`vbo zoV6MgrYL%GTvP1Udlc7OWB+cp@7nERP3_CqbT3~#@8;PptF~zcdqf;rpi`-PD#H5g zo63pDQ#v$Navv?d5xgjHotKxDz#-Q=CLyb;!~%k(W;z|xy1zh5m|=s}!^llN_0+K+R=v+2i7lG)Wmmo9 zs-BpKEid?mcl>@=AwR=%=lTsltkvaY)-U&}3pjotd&wO65At{KTohywU~t};{D0wF zhN8Dzf9qZruCkweC~Cgc?;p3Gzp%UTJ>{TsU(B^f3;UP*%QQ2}JwLcWead2nsZ43z z4>m5pA-BAG-FtqXKTDmjo;-T+?eT*G+$%a0ei+}^6~KQ|K2YDd(Qpehhu-QCjNPRwI58wa)|Nr6p+vl(UKL=R@!QWYa1b$^;V0DGmBS&XnuUl*-!5-TvBCay~=njT; z@Bg>8-@hqRIUzzbe#7&;^+wWd_Nw0;P8D1+kh7V2(xmIZdZnc8`J_KmN7+t3@swMv z!gfAz<`J<;*FSEy@%WN3b^8s^FLpI^j$b%YVmAN$gHN9frn>$)XcW3DaqGExi$2NK ze{io~w8BW%)?h-6^okPAAVHQ*7aO#?PdYQ5oRT;3+>SzijwKh&x-3JF*|KlC)}nQ1 z$3JGp)oVjs1vo-mq}4fEw00IeW@%*jd5n{3VOPmxmd1uDTKW9kDci#X1asynOmL12 z3&_mB!^{*IdNbhaalffYH+*;Sd&(ZNQ+`^;jbeq;pT28%6q>x$pHQ5+DgW$RL!It; z?v(o~oPASY2Ch8UJNr+N!tXNnS0S@xc0D)yIoE-2no9QXM#fi{pRiBuiE3Q&O8ewo z+X>xeg}wiU_HBGzrXc>=UGAUWt5^l~rE_cM*sVXP6r8OP;HY5zR_*`76WM8SEJS*$xL=9!9sfQI^^*g?mdavHbGAU5S zWI`R}PjbD_I!UvOh3(RTpPS-eedFM46q%)z z*tjFKK)=L6kt1a-vx@-7jjQLpWxMQFmMK`dv@}jo4mqQxzemg`--zXb>BmWYVlya`}dL$_qh```n3n_IEx6rL{R|INdw*_@#8mvQs-{Pjoc~ z9I1PEu9>OPE0y!fDTgCUjPG0DG)h#gx#@PBvr7Mn!;c8#uQRV6%DyGYk*H9yM)GGz z%F410>uuzJOLE9(FRK%uRq-;!a(LjzNwp4CQNs1 z@Nj+>VmU{(QRkSPQb^=W2A9TwmYlU(lN{8T{U=7M1x#ddni#Woq0#drUqv`vf4JwY z`Xa&MDiyS9$zOIS!McEUX>pMgY>h45CL+bFR$Oqn#-S3xqIF|Og98_vkVaC$?O&_6 zFa`3sC|r8tCd${HuW-51;mAKn*;N&+lX{ja@n-o>RWg|{qp_k(;Pf3XCc%yyX7949 z&agDHbOf|Yho5=U7?85edPmXYYunYHmB@87FZ5_mKDD#ZMUKPuQB3LToVP-s95jT| zf1Y}OxZ}$XPNqf|M8 z6o2+p-O8@?N9~Z#)kcL07ZqkGs#?sCQxg+;+34`pbQ1fe@5g-E z7SvB&V$T2bnCjy6iU8Mds$oCR27gL4oO{CLNsl}4qvCJ&N9N>RnK0#$1(w=_eHt;f z#{p>V0lIMt75n)3`1$!gefsqO|Nob7-8p^wbW&2%hl7`&^sIl_wBqH$y}w?6+^}im zpYK2JS1i09*}ZSyzOJsW&u4DGUUT$L?yOIrK0TYh-P+oE@sg#tk|$MERJ_}E_Q!)) zU#~ryK4bc=XD?UQ&Z$_ucIDAC&)$7__xbCVGnYE1uh@6_#-Xf9bM_pbxMk1ezQzB) z-TC{V^Y6vLzc&m1eK^*zV$+`!2B7Ne#oCT_+n??=o42-U@3t)It$%D77#JW&B?)9K zIPl^BgTIfM`K%Zi*lHm4%$phQlQtO$G_19Z)nq)}ENj! z6L#=Ku5Fz9H7jSD&XHbIgUw>*V#=;|4RibVJEsW$Ra4r?!1u3PW#yS7yNMe2*0J=s zi&m&63g3+7Q>~c%zEo|gPibp;k)B}3skPf%^*&fjPCxOjsDuAOY!Z94MJg>j{q~VdHfuJzuQIu(ArjtaGW~EN@08lE za;>!w{JLAJFJ?7&1Z|x9{#S{fvO>ugqcd{rZZsZeP0c-iBl7&B`AVGMRx&z-p4Xlh zm{MwE^SK~$!Ned(1;Ii!-O~>mq9m6@G<*=8_@m*9vceh5q>r|_3KL_6r>b(Ei2mfD zbn&Uc;kh#RgB=Yf25(W!eJyLs(&NEW&Q;UTCn*?idaCvrpH=Vq4Hr~*O$*9Ct-Gl! zcGJ6$PFMHtQ_cJ!9Q=Hal5cVR#iH1YnNbV*XKmfw^)@{J{fRr@7Y5WQ?M~*oP%EDy z_1AZXi&vo%W5B(=XBBU{^tu14*IlV#Z*qT)X1fySugRZ7&PtX&Uw`+;4>8__X@Z3s zmuIi#>^o4<>L@cb5SWjJ;I6GbR_8Q4W`|aH`pF5hU>dsP`&>>^9Poz2AY!V;S;zJ!X4jOsc z+|f&~x_XsO@Z|oe!^=8n>)x@PGb`=-`iQ@a=YCEIifL#3uv*UDZ=LG(N`sq+6Qa0M zSN{I?|NrX4f)P!L>uzoSI(u8~evfHuS`1C3S_NM2I&n)Y+9-0#^xFBoI(trJZ{NIp#X{wV6JDOvXYMm>PK=m%affrWV47RqiH%$L zmRsLF@x%o@@WLEQ+ot!T3xB4mnyY>EvfGbh!wqE9`$v!!`d+ioa)zArNK{r_XP z;(T*EI(PHeH|oW&3t+Y_+j~mDJT7Rn?Z2sw4}HA8<-8E}+E5{KAmm>;<4@U%M-|sS z*%*DX>*l+RG zzmuZBMBWT5V3f~RiM_cb#I-EQW_4}MvcGka(`vI1PM=sVcw^o7P~*pUTWqF0ymG*& zit$*(QyvM?*Y|A?YgTlwe(?E3SFDNfK?R8noP+H(DeSY({u3oZ_+71tz9RGOq_EjQi7 z(6n{ZRSt`i>UItPYTlVTX$4-}_U?V^+gzJ$w_N^Q>xH=A95H(e);_p>Bu=@AbIm2w z8upuhhr7;Xu+~rZcrD@7rL$l6(EMXB8Gx<+$V^7q-@bk7aC%Pg4jl3(x+yP#%Ez;{JcrI$~>JF4W(IAMaCz=`vRX(Wq`Fp{$bm!j}c4yPK_XB5npO3&>lWfmdUdsQjT$B#awyD zlNl#?8Y)b-d~283;__Ef(ARdiGl%cedjjp-PL#E&m`wZaq!abIR#Eco%yk0&&#uiA zX#TcBUB&6bX5|(IjjzoX9!j@)gA}yBH$~(;pLw)K-{U};Wuo2Tr>nquhd_4W(_6@!XhxCK%ml_>uI(hA%&4*tT4(JA_ zOO{^eB#7#smMu$8Z^;pUDsa%KDc6I~vniG3wuPa~mYxUJ@mwb-rLx>Uz@_NAq36xr zQ~~CLMw^(YIyMzZ9yD`fQG96Bl)H%K(-b}B8*M5RRN~w=^a?vXInA+6lc|GUxbQT` zHcqAv-q&T)eCzh)O<$ib6AMXN2bL%4e_rV;|NiB#??2B>`+j@9+~>}_`So8So=uK= zw|#%r>}8cTr@vI}uYGUatC3J%BDs4OmYm4cMNCe#!I=~91-U&b&iwoS-T(jpf84qC z?fjXyi)Me?x#dM`EhIlaN{_wmVm?=S84Cjgg9tbqI;{EsLNXJY0l}03w@YC*0|Vnr zXfC|NzHPAqPivx_lHjfz3D&>kUw`@5HKVKMyv%>?AD41k&1zp}PLtF9oLhBG=kBgz zi+SGjmZYD4dsEu!<1~-^X<{c1F-`n0XQaSvq_FE>P?f0*@BSOpK2<5IJTBk#m!s`R zWEfwEKW95bn1_NxkPyckg+>N;ZkDO6O=p-69%OP%Zk#d6VZ&yJ4VxTxvcOE}n7 zIN6U(VNUYZP}rv|v1y}2f(`rURXxcWYrJhPzUyvgZ92wub6v|4dE+_L*Eg$F#%ZTZ zToyPn{hWrSkkZ-dGu)icskm#n@Kxk)6!83TDdGgLho?)+w>=Y40GX7m=?;Rz^5#c^t{S33K-T-VRK-%J(!I~1ZcjN&d~J5hn@4>3v7 z411D%Qk?mA-t>=~*L^#8`uB@x|NsAo)Dl1L+o@tpeAXaJL|DPbl zZtlRqz?2V3es8Xa&dO2baeXK>OF$^+U-RB~mlBnqzTWxtzfhm-zEYdHcSWt{_qE@z zDh_|0yPtWw%-zu6JLgW`owZzk!sgvs&*cTmpT&K)U{F+H(vwo-RGAJ7=7CyUrC*APWUV;AmQ#S}-vr;@(vbx-D zrBwCX=8U6qF+Z3$e{&RibwG6`x6qrvw^WPG&6YfRE@HcJBm1Q{?qT6KXRPL2`19xu z^TtbziPhW7zR7P=6qM(%6MENhWBdch_N!0+R|-1`&t@!h zHWnyKNMt*7Oqi+D%yAF%=h*CHimwjbQtN20cAUriY2)181`PrnNg7p6)_={pMIU_H zz*cZW#s09(nlrDX*Z*Izael>vLTVG z&a*2x8D4W4eDoCfm8aYTlZi@4x22b&kG1hF>13jGBcCTgA4&cpN_e zkI{_y{%ZawwiCWP%qX%7zMjq|p`k3hMp69Cjefo(6Sg!xf2J;utz1?iCKDJ#GXX=+ zB4i{`y24@N&Y4GV{r~@e|E(A6FFtD6b}@6s$yZ-~Xti!S|M;EO=>z82ascBjNDg>= zCv?(l2LYErZ!h!9|IB|E99!|NAk=NgyX_Af$eitUQMu&;Z#Wz^H`%Z;YOrFC##S)_mYhcNq-eR zK9^tp!*QvOW73An+PQikn*r=OjuOksq++Lr0{na)4D2e6%tmwUo;l<=>p9!?B|^OzT+R$Rk3~HRvKP@e6z0C{b4g=iirr+FTIW> zv9M$klUOXFi3P1WeK)}6Npa?*^w_tHW`DbI_T!fI526G9e*XOb|Nmc)AHM2u|8n%; zv%0dp3A#Dhk__`rNRl~nj+OC%0R!`fOMkrWKC_x|H8DRGi8ylF(QB3|6gyuG$Cx|9}1ZY{cq2Q=8(GmoJ^9ym{BQ#83O1Z6>gP za**rzTuPIJhm9hDw)o8Hs}ZWfqhJVAKx5>=0RjVWJ(rYWSdO}gM4(Rje$ z;ex-hL*I|=B1KVUfy~~S|4P#D>P_zAoZzN#l}%B7$BPNfD(4s;Iyy^*2sDrnuy5JIBH7 zTVIQfRX*Q;B4BsUNlCf)k6YjVrH>{ZP}o*j78@b!)Dn3@;mMI@+hd>Dec87xrrvhK z#AQxRY&Y*qySd#u`@Z(}Z!00mOsOS>9hq~!?qA~k>X_oP!fW*tN<4xU=dNO}J0rbr z;lyUMreMXu)+6^aJyJ@USR7ka_AHBj@RwQqvseCVGowo)9Ftf$?^;y^32`lZeSV z6F%;HK7psWXF_p^5Z_9JV8_su36E0ZEwJ=#PHe{)UX(!9sg$X9qlNLPTrwr|dbA`btmODVk< zf_MbN)#haj9eES)%vWb;$&z(z`h;WB=M)*UK8a7TeXQH(yy9N`y= zV=bOzALFhhZR|O)?|c@A}<@fH}d%5A>{kZs5_c9{n%h=;SIXYKw)#s@4%*c5! zTqG}Hq$q5p_@<^KK6=mOM1jc3_oj&-XI4nPm|Qv8I_KK$Kg*p}GL+-jc3t0fzHLq9 z?6*%%IP`xV|Klm(_iIT3m&+zQT?d7-_N)eHi_CCF-p*Sy4?CIdWm}R_-qZ47-Co_6 zmYiF2ot<2MC#$HeN;GotxcE;-NJw`wqf=Lu8gmQF>68Y6KxdwoHOo#iDDF-*Qs}5P zayXGTi$~zntTX#W)r7>0OeH0j7|wk2BK+O-sg4uA<*OOqeYW~!f`WJQ{w;prvWz%9 z^41+MygsW@;9~Mj`S*u)Sz2~n+kZ_ll7;hQl}3=Zipr~nMl748#aOs5I_GgLk&&6H z$HbYeu+MbnM*&G@&bIX&B0|#k_dW{Li=MFJ*z`I!Rlr64$@<0*F%vlr|Mj2Q|Ksib zd%qricmGhGQPHvcRNNmUHl?Z#{jw$I|8AIHe0rX(V@`FQ%2t_KKkpd3Wq)?sY5h}X zmWhm1fxxZb=d^bH>E&o)c{|}l+kUHuUluNz<@a-Ijx?W=|9g$1!1}F^6{bi{l8Mng z+8UcLERz!I{ZA=;gULgMDOV;vP}p{JjRnW*r4~=Tc0AnHdqb{1faS=)(~+D!4^w`eZBStI zR8Tmgz*)l9Vo_$nAn^I^677eIUj<{2Z{(A5y7QyuP3MORTAV)_n^*cx`Zo0l%gUtf zPkw!z)!1*>`8m4ButNQ_3_S-p~lV)29xTfp$w~8%E`~5$@_Gwr0eZBab#wL|2p>v|rj9*;1E99Z{bH~TZ zqTL0*{shdqn>VNYyMkJLUbx&%%eUG^ySih(iSE4Pdgq*s(tb-9zKPCH1T0 zI8VPLtoeOuX~5dLXhHcW$0p2KB=4&7?3*K_uKQ2d?LkM}D+6Q$o{9(mUclivQ95yM z$0vc46T~K7GoAKO?nsizLph1bO!c0AmpLbH>Evlj*s$3~VvZ8$gIuL0rnPeCAC)L` z800HHY7OXo^x=`l{>Bq3Ef-@umzdUtq>F!a^1M*$TAuh!;;qu;fOWP-V!kbjekPZq zUAsJtO%Fvc{xvx?Mex*_bx~GxB~_wa*%qeAY%G~mAi%iC_XxLoq5FNgDzVuol;#{- zz5G$evYEL`3u9OBwYi+wnX$-o2}gR`!{ZC*KhRa$TTrAO@k-J4a)@5(Fc{39NxU2n{i;Fl30f2>!`I8mR(eMRND9c=KKxG z=YO$3U9XfbaB$J=1zBQinpu0BrNWz~X8)}cTocNlI(Y-%B(Jtt*>kJPd|$gVv9MfT z`fr*2%0H{Qvg7oPK3M;0xG8t%a%#Hhnk|hSwa-2p*-oFE70tdnL2RO{KsXd0}N}0Prgc97P)0n-~M-* zpWBp_=l?4d>^V0zN9?7Gyt`{xUwwhzR+m3sf)eM8qL0+ZtNi7hxKmL{VbX$UZkpM-ze$dP%Rf(J#2hsb_7k`=e^>BMT|9nxArs z&uwj5Lu{Te67OWW_3fK#LF`(o=R(`e5-JopxGnf@zrX(C_w*8lsU_Rxy?1(_6`QES zs}-}YWaG|45w^p}1ch2Jf864_iP^pS`h*Fe;!?!?e*Aov>qz#~V~wtqbH?wE(y5sgXr za~wZU@3B(K6Vcpw^Wm~GeV-#2H4Zsn+I-DO##G3CG6%osg0(-l)tPmF=zDxK{+amt zM{xe^tg${2cq_^`>lxeRl6^-u;o+Y&e;^y`tgx)b*cVZfZXI@{hIt zf5zOH3pw)oU7$7qdJBZhNYLzqLXfX~fFf5vub|Rg{)5%R zHz#~3=a#;-$KeVi%k~xG9*>>Pj##EtG;&B9)zqi+T3lbNzU5;MM^D$TwkNDCLJUlj z=UWn9Ng18peQ%SVJx}KPrYWW>v+k;J_%TlAY~1$DiRp_9v(fGIAr_j9n>wr-OA480 z#wi@+USiqk0%f|)b$C@9tN-8Vox=a`KDBx*emCSA|J-qx5><4a<1kCuLsWjkIzI)+ zISyLllm6R3is_IHpUNFrQPnB%(oQb^bMlXKtuuGx6l7ADci~vW zqQt^CJH?~zx|9;jY?k!c*$sy`pS)7u=y61?@_qbCdwHY88Z{@THA0HaZj53qvs8=~ zFQ~+Doay%AIMeOI(Zl4!(ZdwNVZtfQ^jS%m$@fr;!{h?R4?!RQO~}f(QMuRawCJKk zT2$JtxI-<+6}$Fp$G*AvKl;;qp6K>KLCM##zvo++r8t97%g6OM#PyyOe18AypWT56 zCCOIj)F z-TC_e|NqbLe&0R+>BOej%UkbFOue>a?$hnTtM?-k{KEf|ndf(iY4S5LFv2#~-DchN z+JL9^p^BICZ;3~L^S>F|$7)5STm5R+uUp!X`19hfPVd|M{#;edi>;B}mLht+>@jCy zo!61=&8$j{oE{ELpWX=gx@FaTe)^8-BG2MKk7u*KU%hRexs%YDNgvOeYrQRLxbf7F ziSd*|Bg4|k4h^eR1g7{gF-mc>_ZI>)4`&dD;9wdo*J<0c0! zZkA5gphyJ|{^l)T+-F@{!Mgs69P7qD-o1~WesP?j6}Ixh(qkbV8Hc&2?i85VCvLUe z@!o`Gd3Q>Vq2UXR$ax z4PTxi^|rTD`P|AaGh%!U8UL1_+UcPWxsDeL_Ar8;uo3(tGJr!?BTE%4ukZDM=RyUkA#iJpHi(1A&4LW7Knz`nP?R#%k0 zIlW%*(T!a?Jd=`R|7G3h<3C#X^XIM_wrzV_!wy+(Nx+imSbT^{bhr!J^Y4E`8mAL( ze|rDxU-0o)g%{r~c6KyB6V;AGIC7CX41YOw47tEmYFb2lDfU|`+{D`>kX ztv2IfdvI4HQZicT*)2GNKmTGvEwV#<%zfNw#k7F5g=e)i?>pgqS#OJSnuRh7G zciMk{@}4Ks>&^t|W+yX!6&bWn zy6JEFBU=@IY1gdlZkyEP9k=L4-m~UW$kgAo_B_J^^T*YuuT$-KPtFyn48OMJ+1^JS zOWG8+$^BMTWw~g*ajnW+)7beyE2O$mN5$C zDc)k2o#4Xgaj*Fb9|ya_8ttq$rrUOp8n4)K{1*;NnxM(BP%Nl4^IR^!%0zi4U6$_( zZ<-3kU7|P`14M$D1@0uOnoWMw=;OyRzrBHb5}(4<*=HDT8}BoFujI+!@?TadA*nv0 z^8J?Ca|9$gRz91>-BjmsPt5zaHlJr)$4qACmAh=?IKDe(-8%Be<)^}??Qa z)OpOZR=8B+)SAFBY43zJ(FP)$DimiQzj`Ibna9D4oh4W}_(h9KkyD0v&~JsGcg#&L ziB-?s;>{9NuAo-I<5@eQh-G7Xh$Q#L3Bpas1wJ@*@txc{!L|Je`^xsdM@=cZpB-I<{MU-R4N;D3d`UPqlczx)q7Tl}o~tN$yrPPJKInz1jw|2b>d@%2A{ z$Ocr06>Ug1+=Z=BNhhXIfsG#_x88h?yllSyVZnpXke+bCg|`tWUQN04>EYKupjz$s zzdbL%r<{2M(ekmAq zUjF}o?JVDo7mkWAH|$!e#;w%)p-u6#vJ2Nn<_Svr9Ws-C37EzUFt(J63q9vnY7}8` zblxhFEUeeTGbxl^Xx7^B`u_(WHhCzlv7W&3y-`W8gC)pnLX(XAZ|}A~r-($4W5wrh z&)aLo*D3I5ceeY9(AejSoK9!nU0;2VQ{BNr!Gm$POnzs~3!VhD8_U3v*Ma^#dW^>xPrF43x%Y7$wsxJG-nK+yVG(ZWd| z)_FWkYZ4Gzee9e=jP#?{2?1wkDo?Or3v}{`jkIO>m@F{KspPKtYXz z?BQDU+I*KlvFH-JDlTrtZCW+uXvk6i^Cfp zl>+MueqQG@JS}rLgxnPhxfU_9yg91eF~3QJr?6m)SYGPvrhrBP?)6Gr{CzLWxHx;r zSZ-Lke~P-|6u~3q=f!KaXU}dGVF|RkVE(mZ+vW+pjv5cU<9KuCv<5g$xMcrz{m!oW zZ4xYo3HNf$Tb3y@I@;{})Mwt~#G%Tt@YwHAkvTP~0=){XIo?t8Uo#7|DhS5sT&nmx z&2a^TM}o@1^b{%l`;5r>nc!=rmkO)e|FN}j-^(4`u9TtUuZpH?E5 zY;ypUfPTY^#RA+4TZPmv2YNUN*z#;_SDeC-vPb2ig^ER{DE4kv-4WPy677Otii z#rDOO92)!o*lj7`a!F;7d?n+&S>TTOrE1a1R-B7w^55ON^P;DKSIv{UFyG~lI&BG^ z3qLDFvpd-}uYBXevGnEc1E!pcJ9rB}?fbDswlc_J{?{cAX8-r5tDoDx$JTez)xR}o zwZIkileRVW7Ju)5+wm`1_sR3q)$_Dv&zrldMm}8e>GRH%Bm3;`|9V>f$^NX()XIzo zY~{^zV#*uX3>l>GfRnMOUKd<=>vQB~&#jM#U;lXi9a_?yfB*CL=ii&3eS-|dO|`gt zi2=5(KyS_emzhEfrv7DMU=fEDFK=$&oV8d-r1hcSinIy5i@w*d|9>MmsAlhi>%AK-16gH^5yK(0{Q>7*M5$GDA z=T0?0)Y+YrqBi}VA2ivXOGvEx%&dZobtfmA+Z;LX?6mdz$(64+#0Sg$i!}c6OhLu$ z_3~eRH|0KMFHAE0@l4{#dN<8Xwn_7*m*izT89vSto-nn(oMF6i~FTTmJXtkC?1uxU_ z61I*ts~V163T1gd=l-tywy63NB8my z#h8DdP|GEh==e2pGKd zS(_a$MJoK%5%`?mxMjQJwV#K@gY424n6?F63Y=W}wr>)%0_Uq=`=&ES&aXZEE64Ul zm5Pe3m&Bywe)sEGgnqhadR%R{FMBEZNa~+1Z{#txTV^abKknPxmh))?V?O(*s>PQr zQslFm&@<{?VH#;MWyuG+r94>UY(e|dh2KB_qE|0OZ~#C(m(ya zoBlL3o}KR=n}DrX+B+?_%0(MpCLECV75Jwg8g|vj@r#C|N3ge$_jVU*pBZHTCU5(#lvp%=hLpYk5^Y-@oO{(>^ zYf>%5pESix;4X4J_dW2<^kl{FpKD|Om;E_cbNc#z^9$^n3NeR_F1&M)`F+qtVR_ww z%j^tq%jfOTEAj&EAw(bDVm(Jpc?Fv(K%3EjR#*0Z?TT*~&O&DKf4_JJncaWc)%4@e zt=H4~?*_O$hz|I)bIX(B%r8d|%3OM80x!4}rat_iwAZn25(5LPDWu>+nc836Xv)>Z z4Vv0N?{Rj8ecqwwl}dSDQwxe$^+caq<{tL#Z1QVAxwb{Z`UUUz{9pWUZw$Ar%8rv7 z88bGRN&ilW+4s9^kJ9=R+Ml{|c9+`Su)Vi1$*=3YOVNk_VJFx^?{t5^ck>p{3Kk2m ziD7@zr=G};_@BS?$f_?>lOOv|6tmHMm$*tpTK3=$o$d?Y6ij*6I_3+R&Z%-w`R>E} zfYC=m{iW-!bZz6mPCmbiPO`{sJ@J4s?`7@z&`1lhf-OpSo3j+oF1V}cuDz*x-=XI( z9ypfH4Bn!|$iVky!viIDJxQ;LFC3Sux~^DuVx`wat$T+``cHT5HJ_>!cJ9>&@vEwR zfn64ct9fHLxg2QL@|vh|+~D`>BHo@fmk^vT_xh_t$ilfVwRym=%o_t zrwwbICN^(Nvi1mDExzjFns@a-rzFwf$L_}0C3j}{Jh6<<@|t+E&hw*r;XLJc zwXv4{*GvTtxF6ZH{>#T^SGCnr3J;)%f(aEb!5J~967L6K)Gtc_LJ*2cm7%1k^Nz*qTs^$3#JO+ zVitU^A3W*7o8kmPd%2E?J_e(k8ZZK#m7L}awIcJr{hK{3??`CN|xiiOx zx#@6@&4ddn_A!1THRd{p3O@Nxd??7+(GX{C;I6)DrTFa6PAyN5L@TMqyz%ti+fkVA z7v9})wK$V&qKk`xyI7<5?Z?YJ80Rb$XIy>mR7cEKm0L4bcnR)VERf&Tuyn@ja+h7n zyS_Jiq*#QhH^nE;f7kuM?^@RkE~&45937q6R)Tx1P4hYv&aD$U*iskH!m@w0>w%Mp z6qIBPZX+D=jO=i1Y)eo6$4OfGMCLae2--Xu!Vn!z(-#ymbvMpJ#h9P#r35Iz6 z@>7o%IQROs?D-(tF@ce9P3ynsPo68yU1xvm($C594{l$+q%738EjwceHZ8Cemv<%mbd2meC;KgYEL0a@{d9_F_4?CF+4=0R{oX%qWSLf0&g3rC`ES*! zOD`78IkRz-$6gj5t91vu%NBlinW!|s(7SeXre%bSPttOIv0%ru2bC^eX4}Acil;EF zXI9OWw(M}0lcu)p-5mWwqV>0pzs#AvT=-6w%0sr7MVF_sw=*Ryyuq~3?ODoPkKzsA z4`y}QySp3a}xrndcdUdqjcD@tn{7=?3$8$_7S{VC$EncmOm zWxOfJsEI@A!ROwyiTtAM-3f;h^tBe8+_2`?9=1Cw3uEW}KPGJ5d#3Q~$$a%s^&J;^ z*UVhAb#YwG#Q#%Er!>2Ie4W*2n|rn<@?-wF-@j*tKM}2Tjhh%B^5i>j)7h8J`Md2N zA7JBDJ~ffA`Dp>?v&ORH3oO4eGgRr%3+M33h{n-aZ=RPC;m=;!@MK=w zx6M}kCR^I`Pbl-g{V46!Y^|vNq-D+o;UcGh#T^?z%jkY8yC!na?7`cZ1-(keK3W}9 zE2kMK2dFI4srJn~s_|(We|?)pEeKJ~a@ABr^iFNiaj{+4eWmuGIL_GLjPjvR@*ymMoBCdJrVuvFFfv&eCI^y%P z*&V&|JN~XYvB+Uc!RgsfHnmgVRPBGscJSd|1;P1|za55=!yY&!5{ zT5sv?y4+-o`(f-Ge`h~tc|6-m?VyAjOHmZZz7u=+4sAMdChk*2kaNPrNcO@_8sSyi zKC9VZESsRPx+{HN%G6Njg3`HsPOei5nUBOVd|Y(K)Tu{E$W_wR;m`9jDG#C8ZLEi~ zI{vu^Nh`YYCI(K8QV2Y&wg>PaIj$9`g6p3&k0HLYtnYEoF8o z_9>24(A4Hr@||!ZX0p_x8_mALM?{YDiivbRt6AQrqdrSi;OfRD0m4UK+s(Z&|5s5~ z^9%cfm)=_53=lq|X?Ho;eH_Ey%6F2U_aAM=lDSzvkdnF4&MW%R5&n5<=C^G# zzAUbLU+498P51BX$NvBS|L5_IA4k{xef#v^w@>d%Z6#ur`>|zi7U)GtZ$PUs88{dW z_S8S#t>!R2p};Yz@IcFl#gE*YZR&(Y!hg7&Fn98Asa5{ta^$9qn$g5gAC<@>VUNx_ zM;3{;HHpS>qlFT76Ybxr{+?CEB>3|uQ|_Ey-j5zgYT7BfF7m%oFIVSo ztP@mwD8i*CqkpD{s}N78|CIXeYwUv-o;c~0blPA3?EHnbDd(cn1wFg(i<)Rns&y)v z^z^=zY)6QeP;AMn=eu0lB}6ygmX2sQ`rKqO-!#cnecjc2UVJBFRDK`fR7&cO)9{E{ zVi#Yz#dW8@`kWY-b{BK$Jw{I-C_VmpX-m;rz77YMtF_nq~u_tdWxAkycw|qj+Rle=|UnS(jkE~--cX8RyRM_`!k$U}{+dbVnVZSw% zuK$^>6@6{5yo<|rZIh3m9=q8t&h0wVuKV10vaH3sBEie@EC27Pbr;;IZKWmgVqt*G z_f7|;Cq`>xT5`EXCn~yJDi`o9KP`LBd&0q!%-tO?Z+SdE`yhbBwZz*xUun`35Bc}5 zSEe(bd{Oo4ZTE{$t5aW>^Y6X8FZ4)>N5};K_`u`Qf*V~AUdwy%bAI=WWvctmw_9Ew?6An4+cHHacnLlyqtR$V2kJoneI9hH(X?`!O79`fbxR0;-Vtz-Ai}`1U`4Ve(A1iac zbp2lG%D^3)ZE_6+EkB%hooF)MTS@d{@%mgFr`AVJc3U_yGfM*(Tf4EUGAebus9ZcJ za?QcBq2uS76}#rXO*QirymDzx1GB=d6Oo+P@H0^)03RYu2c2Qx_^b|0LF>y~|^l z_oP(`O4-8ZuA97@?#Ml~?)Wh6TB%6YkAF(ruAbXeZz`xXU0~vyEt`YcGA?Y$I^|}) zy2yWNzWB&e^a=5}n(W>d;}r)t6Hb%RKXnm;E=wp*}C_cYw zam}Ig|JKY1QCS^&@4j^vjkFjv+Gnqd&c3eMSPDL-|F{Z14yZ#f(IAg zNbAQlFfdg?n=&^{=ZORgG<=Mbl#dDe!r&pFu=HANk;!pgC;kol6t7ucv#ipOiMsc1 z-^xRY`*^Npzxum;_tLxiD`Iz-$^H(`6^);`?3H-9>RA)rd8cN*+)=SAW7+0MFZnXV?b_H(gk@`|+^PJV}!uFc4XJ!5AUAF7l;S`f^6N>_Z zd)Fvv_MGfin{;T#oz=>kJtv)dJraG6x!z;Y>^Zr@gJ+3>nzE9%16T4VrzM(Hi z{7=DW&R5;(@~nTMn{u$@q{EB8#}fo6AAk7YBymx@)Bd>iyux$&Vx{;$#WZWro1qrX zyT9IDEojz4arOV7_8267viLKrH^She@NK*8(U-p(tKE@EUUVnySc~JXr9o??;LD44Fs$pEs|_{Na1P&2V9^*A!1n-)dPy zP171aoAXPq1YTsb|B?6T!|oYVDr1_3?0@wASfTE5%GFJM5&M1FKf6!aObiOE>&_O? z)IO!YxZ9(1>iLXLkIv{qi^lv-o2Pm&v@T#-?fFZ5=Cp*RXVmXbDEsgIp5gLK=ifq| z;V-b|gM4E00ePoiI~-V6FQESN|Al}A|9K@785kJfLG!@P<|5TZfwqTnw{_M9#=RH2 z9+>GBsJSgyz25(g&(AxKJ-fRNW&O{KpRZ;-UsxV4du!Q(1q&7w>u-O3I{!5Hq;t2^ z-76jDeex4+XW*D^$e<*ud#H?w;h`AIA!m*wDhvX8E($f`jZ+i_CNntf5O3U~AmHbq za9+@Zoym}+#W`-mvwH2l$v4^cJ($-{)0r41>NJz-N0?w?56OC5$ejlasr==mX^!K^*bEN>ZsQjOwRmvZYS5uKSB34E(#J=^3Qq~peUj& z5ZxY=9@xaC=&q1#mExx$U*fUGp{n$RX`{)D37?rVFDr_(UaDw0QOQ!o+L)p+f#b;X zV8$Qw?j!^@a(PZa!G0j%QGCP46|>Z@YcEL@(N?~l7}@>(>DPJY*V!T#|6y!YVVID{ zq_C7jg~eeOX9EwTKr-V5qfh-aSQw0a{!L6fZJ$&(vHpqfPxnqc7p+)Vi#HJOoi||1_lPm4F(Pc z4GPf*ZvNk3@L`s~j5%in7#Ns#L(*T8#GM3@o~A$rjg*|6H5xA%GS16wdBV}G!EoI| z^2j;Ero}h5<<4d=-1P0;9mky8+j4L73$NZ@y=t{}{harVul^K&&)a%JuY5k|k2MJ& z6E+=;|I1?1cU5WiHxGXCd)ErxOg0`s&O!5Ia+>}M}5n(NxXb3 zJjArF{dExyU*C42OKXMBA^sB=#P;R3E}1-W`o?LS78$q~s%(rt#CS09j&_5MxB20X zLT&3^A6<)MdTM8|L-+Z6D=VjTvD(v{n4oTdeywFFgU|rbJZxnPiaM6*EDlYxXMFc=+-)jZH?nyyCpH@@U`sw zEr!eVZ;EI|F2DHW<755ndY<+->+>1Qm+nu)JR2!~Yuz zYR*lOvl$o|Z$LAU1M^}?4qDQ}Ji~%ZAe(K0?e1q;3LK9Z_7!FpyexQqY3Y%zht?i^ zYqjaP?}CF{4_ax>>F>O~;QOgi?}-7 zW14=Hb-Hh3`1!3-Nyz1DL5gP!PjO0QOUuvmYg{|D9#x06?dWvf#=$8ZujmvqWv#|k z#qyk^J9r+(pX%b_+$h>@bmaK?jXV#n*o7~dCa=IKH4Yt$#o8|D2Kva{WO6S zfs3}-@vsz4(db>7%aBycET9}HHN$O@Nh!b3(u;Q|D4eYqHWaWd?>n+-YO)J+n@jY$ z`Z1S6P_14>j@Nhck1-a#}><-x_4IyvrnQHH>dXm@h-&^>- zM}Nl=n+5yWE$=bys+v&9QM8Vek&%(HGhXg}aq{c6{G3u{w>daCI8MaI$0-XIZ(=c8 z%Lh_0kyY$fWa(^iu-w!1yy!=Q&u$(%EW*LT;qg=7=HplC?{(KBzOe83_aXfBr3lbw zQS@0YhD*fwo*#?vyN|NlF)%Q&Le>a2{6DzH=oRQ*wOpvLubVO+W)N{WcqvXOKR471{mGciASU+eBD&{AruW!PMyRtxv@@`hBKH!3;T;OJXcS zwXbWJDeK<7=5SAdgJqNDlWk0sZZ^O!SmQ{En*OU;dFryT^Rbg-_3vScSmtJ8yhceK zEZ|_E&@k)3|JNJRE(FAK7_4PrVEP5|ev-r)a0zl?#gY_;jN@_@Z@HQ*8qRN?EPQ2~ z;FY|9+kv^iZ@#~~b5-tb$K2b$OtzkTR`##>+dY$4`gJqj%$$2v$93`h8&m(BefCtj zdh%2?%RlV@5B_>`bAfWs2l;ZFv`1X-0v6tKDrcT`{JHF*Yd8CU+Wc6a!$v`#Hissi zTw>Vh`p>wfH2pyPYrW=$b6JkaCguqJlQ{GIMCi6w({~e|Fs=Sk5N0SZ#}TG@)!MnD zYS#uok5v|6Tlaoq*6O}PIiI(u-BT87o^p#dakj$02$qkXj$U6Jlk6txnmICUoH3UxM*Sk& z$}6m#-QP{;>v?F#9kuY_yyssq!Squ+Z#ZkDOWxI+PusLksQe5HSjJVvHs9L9qxNUt z<8l+n3z0T9pEk0TC6z@>7cS1@+I2F=So6mX{=>6tt7|rDyR{qMKOp|hHsw^x(eEkE zdV0BO+FMznC5sedcuMF8#VU7s_R~cSx@Z)MUHAJ^g9k=9@|J@Ye zXSI`-s#e%GZ$jj(9)-wgi3pzv)0mH3@{y0$`%4u*j@&T4M5y)2I%OW$n|@V=!i%~R z?W%YADE4nk+njhi@>AXgo9ibHC%sYGGk50awHLzsGJXF4EuPPK)>h5atw1TSX5$h_D6*vz9R* zyEA7Nx54v8d{_2g`kQoY=8w6vIk&sJOsRi7_ts5oiOz#(#3O63+TCl^WYdp-qW!Cy zeOpWe421OV(eYn>#G^z31g0uYEU%VZ3}S-uPi2Mn6_>ZSOYEr?jLk8-chH5WZ|^%7 zzBm5MuH5N=q=}_0V%STJ|M3*FED&!`IN&;=*MWh7Arex|yuInp*kZuIa8QJ~u)z1g zMVW?r-L5wCMPt{^AGxSHZ<6>b;;V7wOl84jZiPFENOuA`R{JuaphQ))Ba3$ zNtT&^kAFMgjKvpBIIjXg9#tZvAtq3FXqnZ2g*Ou-=S`cxlYxP;1?s&^Tla}L3bcOQ ztjD?TPDJD7X3P>MAZII?{L*g66}sRq9nEv!VIZ*Tk>JM+qXZyg56W<9a%iZIwzh~6zu%B z*5hU37J))wRKl6%NK^_8)?=xY|+|0rLB5` zW9GKw`c~^FT;2Hct@OQ}w&ilq`YX6qp2XZa#-?MAEhXUG_JW)e$R1x5n0_GV|BVI% zg%55UR$a^GWME)?4oMMjZm4dPbrf-X$YuOu#s4(qP6GWWb|9b1|oJnP@I zkh$4G&!>gnd>eA&tk8*lGLjN0g?T-b9p^neQQf-1O~J9(A!4z>H3=5eQX!7)sOAmN z);K;3cXqid5NPTW!YdexUxFy%Vocjf2z^$37c#j`|9jAP=kFz`zsRWh~cCXq6Cc z)v1`P9nN!T-dwK8mcYOhUDqWidS1M%I@ zxgM_IP>~UB1S=5qFwkP^baPdZ5p85ytTZ75q#8-Eb%VRY!xbDY_IE`O1qymtXfZup zp~14)DCh*!ml#8i>N<^-uQAgzGq>1&T=7RbZ+gL!M=$UDI2A5qIDCR}F$2TrTOV5& ztJyVSNpuV+C@e%FZB>T@{~Hf_w{b8qFeF10)fq=d7X}7~4c1HzY+MY2U(P?_WcZWA z_>DQ@^Lh72vpsM0OfjFFGbco-(?w~bhYAw)GvZR&YdzKIQ|6PrlqP!o;#GB?u`OJj9|vjE5*`p%xqnNcg{8;Dy5kwT25n&)9k}FfdPt zcsgl;odheWo6F>;%AlHd_JNy#^TY1K^X>=jBG_ZwUn?88#J0bFaP6Vh3#&Ww-`fAH zuPytMxn>3Di=Ugz-TY@o3NH5uoY1wGV`r53MvtylAy)*9CQNE`b}U?^_jsPz6yqjV zb`~+!_YGH!3!S;WB3qe1g>X;$-?nAzgTomoD#9*Z>`Dy#SY@(gsi>wy!rRn89IV2P z4P8}67v6+!<6!aTJK?4=qsT$4ahW97Kei@+hLfzbq$ER*C9*F$_$`^k#z;JP#(f5l zjdJ%7)y$aR?R=q0mH$bhMitk$=C{n%oi9G|O?H)J5|c4%*=-Oh@aFj5n%E}?n}oIQ z7CV01^fzfjV^D5_?x9(Qo7-(`)?DJ&^XPpm-n_)?YKMI;_w2n~;jbUS z8}z*eHatj{S5b`YeZ!v0BFwB~vEa=dUdP4D%v#i$A`JRZ>iP0ii+j(=xh)X2`v|Ay zk^L6m)_neUM1h;n@aAU4l!LL-hmzTKEDr8$vo$=>RBf^SL8}Z~{LKkdT756qnN+-z zF-^1=jq_+0pQ|X`woX-U>h?Z0wg`j#r*X3dYMa*I5ZKo~fmK+0`*d}-s1NI>Mt^du z%F%9lVzkYBDeKa|QM>QFW8Abs?|b08y7w*8mnN*<5WcRmoIxP(n{DTwz)AAa&&&KL zG;LY1?sg*&Yx zPxD5DL`rhbp)7??>7pAmOt?2`FbYjE-hMSIqhBKBWX1>Imu2irjXOv|5>z3a#1|UCF7oCWKE}vlkyqB%S z_G-|tEAF`-!unpOJDNQ?mdmY9I~0HX>_5$W{&@#l7w0YHn-e&_=>S!3z4&Go*&xUcLJb8|j*#ZP&H$nE@RDNawO z*&1d%7Ux~bb4>k9k>Xax9}7fZC93YCXu*~fKn{72$OtBOcOs>Qf6l65KG!Fc~oh`7&{X_d( zMp1DF2F4SR!r|>rQ=!`l0!KfJW`{_w3VFDtaq31+iCY&K4~4YyCG2w8!5eEbH8H)% z`oCV))WpBD1^1rcw!~|yR;W)?_b#u>{M$#gW1qX_Y74z~v%0Njm*;oqR+r1JnJ=ex zcF$(M-sey!;4$B!#7kj2#}a>qDCG&oESHof#PK?Ok!>vDT=HE4%BbN{_|@&OPT0d! zp{n1(PWS{b(?!k3KME808edFtIL2~GU0|)?30UNM%`NRqU4R5RTIzT_49k~zjdix@zVvHVx@(#M`}Da?6kF?({XcNpLl2P z%ij|YOxwplasM`z+7rdQZS7RHFMaQPhX43J@ycXzL;0j_&*umm&d;ixXuR!9tw)mg z{q_?FrtA~Wob|R)sa4ZcJ!$*#?irW9E2ULm>0A=e=px24NzmhisKXP*#ugSKfsQ|_ z6J|IRF>Sp4*!7-(ho8cyi4OM!Je(AYCOXVw2@>ew;Ye{*U~OE&%rKF)F@nIzm%qcXvqWs*#z%)Zw0j~{gRBrJFxGf`J_-z%+D z-+%K%ezI##e_d~KRD>T(YGPhWOlqQ}+EH+*JN{oF;Df<~WeF3MHH7UL7?@=sDeKLR z=FKvW0&E}bo;(Z?z3r#DEjQm@d0T8x?sAFS+j5`Z@4UL(`u>@ip7@`M>)h{u)%&~r zYb|?33QlGH# zhF{o;T}k$Cj~2678$Ae7VfIv)JSFE)WgL;LnAw}UHhhWTixW|Pj)$@~HCnP9y}@zs z`Rp8(~Z`3-nZ_3vkoyj6hpKnIAy;{?9(@FZ%_er`>w3Hgw{%}8}v27Fg zIkv-}JyX3``+QHUe;nnKtv28I?)$1Uqh%MDyb*&CmG+ ze%?KjF!`{;RnhxQxm%{|Co}C-Ie$Iw&}5yhs{M=JMV-vG<37jm$>Y@vt+46tb59%> z@HKKxRO|}sn_x1f_2`pqVeU*7-&DtoXH+&%;4@dBE%IUh$$e>Nnp398@^gCXTv2Ql z;ATFMV$3$d=~B&x5=DdXhbk*9c=TE~$i*Dw_#yjai|&`LObfgW-rFtkx{%6ta8K$1 zA%>(fEe`*ci+|lQXR+q_wqt+Qgnuk1e`Yp+QC@IM-rU2AG5G(EyPjV*gnGZZ@ts+` zfI(BWkvoFNMV;gEK7}dsCIrc}2zl8)mg#L;@4lhJec%6Zw+XFHO9UF$%4gU(NEpp2*t;ky`*(YD);08*|upDJC{u7dBUfl+&DQQkXwk!jWLPgVCAvNZPlU0bFNC9VDUN@9n)~&c0^|)!vPHj1`EZ@ z$@R68*vfv!tHk71GRl6th7AXz|6iFc{9*It75^9*7$YD#^zDu2yu3gG)(5rucNc_( zD6bK{+LhIIH7r2eroUj3)|%VP*O->7ub%gn;r@B!AfZl|PZlRDD=S0S_Fs;f@gwc= z{5reUi}PLny`CP_>+mJ-gzE|>hc9|e7h^e&d}k2I73^5&uAs)EP{rHmqa+}!Fd>uW zku$?0X~7dLOdk~)E?ROtdGgldp0C$5)3ZlrPt+`(y(6)!f^X3kiO{MDj~HvmQxP3q zsvVCNyY@`YRNLg+t-{}_^t8A0!ui9lZD01P7)`8T5ptAsRQn{~_(z!K|ItHrk1C?3 z?)#A6U%~KS(d!`FB8{sIr<4~39KXsC<;J$4k~iRRdr#ZFb(uOzTM9T-e&{_GOZhOH zRl)A#?w+TN42JhpGn>}rXWvg*+NyKC`2Ldz35?78lMe`{bxP=@G?vfE+UxBdH!VoV z{3z|3pj)|%sBDj{|1Eu zgAWhIZ+~Q9V2+2x^qZN@#c{C$$IQQ-`9AgWuG-^U*|z51-sbl4ESu@^t-0HqZ}t6~ zF7^Iy_4(p&em(aMZq0F>=elBE)vJ|fOK)F>n{< z2OB7@+suFZ-(m(AzqI&GvnS75aWv;Z=K5_LXZAkPSgWF+*6=w%^zuoblh<6f%SK0d zhb7%Om9g5m`({^i@e5IH4ONd2MeQ41pYO~KO*z!QVbZtMdX5?|k=2>;+pa_ii3Fa= z+BPdobsDq5>_3uc7*80TkYqm;|72E?!nG-9r62e!u|HX0WoW0hoxe!t45 z+dAs}{i*Cqo{9k_&gwU^E-$ux;w;>4q}s9X@BH--I{fxG-#Oy^(8%L{w9du1p-OW& zCqJIhc+|kQn^#o9qO&fXW%mnTwnaCO)}Off-@)0ST~F!x(8t*PuR(-<7mb~j5gh0aXOi`mIyk&u_r+#5fMXPuAoOcoB! z-jon=#b`>PkcV{ZRfH4Ci`XUyw@{l%wB9}b?bkpxF%cK zsiST0rk+U@>Av?g!@c|9I{(KPm7ds(bv*fgyt%UL<>`~HIZt%$!g6Xo>UVUW6R%*Y zRsS2Pdwe#pKVx@ZUuk7^{{6q3*Kjj^-*&I;)0=dKjWWHvuu)pWIaDjv8w%^MC^-jI= zx0^Suv}c>V{^^1vHpjENJe!=m4|i>s^l)^QH+UJ^usAVt@g&a)k5hNsoLX(0!tOYU z>#8e%#hOpg6%yZRwk~*+c=FQ!Xx0xGvQjtwn#AQHbHr@ZNk8%VKKXMOMn8^q-jLw< zTf;z2(!$8_jcN4r?;@xD7+-c|T&;h2=;*mat$(fmsh_`bgF{KkyK7Q@^YPl{qMcTT z*(bjx1eqq8wWjGS1Y0kfrem70K)~Sa5u=CP3|sf=NbpWwm5rtG#WahU3{T#Qq?r9T z|2JrS5O64%7N~VEl7WFq5|Yv1-ZV{?P84W)$ZMRezV2{Hr`ee^KB*F`3r-n?Cf=U= zk$sopo$~C6^SwWpnb@%Hoy4aSyQ}2onPpEt|7^PT^4BFV^CI8h_wQcyd$O5tiwyHc z-}4+DcBu-xdK)vinODXuDg2ty_#%ldC{D8g!0Luw ziE4OraKg-u#(E5f|6i|_Fj77v=e#5%E}rp8Zo`{n6D*$@F*ckqoXpkW!#m-vgpsw+ zQ`?3aA#%zco~%wjS{zA1jRKRonr4Iu99hDos3yu{xKaTkCGp7rsM5a>n+|)??jOO0 zivL1%9{C?_{t>*f!(Nm$=ows7# znz1T9r}~f~mL$q-K}-@QdvI65x}ahIt^ZL1v)8|Ohzz{Jz`(Q_mQ0%`$@+`1eb{`j z+dgSZ((I=HnG(agI+9rRY#6ZI3p??tmCs)rb1_zNkI^+UF6n&`S6ror=ll{1+Q2s*6bbsGsC@U zMpmJ&_|ffWzBgWb^`$3=@j}aagFAB+)PZ#0AJ&M8PrJ6<^A zHeq8V%gM5Ubz0iVHpIO|lm2+m=F^+AkI(s!#om>@XIk{JA#Z2L1IbpyVR9xbx;}WU2B$;!S zeb*xv)9<1?gCB&dZn@JQ;=1a@$8D<0hqTu!0#I`FZc?Rn4zG zx3rOY{ei{Y7p1TM_sJJ|8j>$^I`>PO&c{y+vyv1$ocC-sUca)Y?3Yn`^Pz?J-iT_h z`f%#ew;PNP=XExo5Lu^KRp?;i63DN$=+uovX9bUXXdJt|e{~1b?2btyeoMq_!`m9$4hbJo^;?hwIV~GM58phkm_?B?B?sB_;zAzog{Z z|AeiJ45lzJFcd&D%9*Wd1*q7byd#$*;%|H7Y?;2u4OYwF z4|RKUT9UB%l1ZN!Uy{)=5zTFI{qTR9!Sy}Y7uPIfU|`$?@%5WarrWOsh#dV`EB;ti zPjnrx-`_t|D;79!PFLfdC${|PW{r5$c;V?WXAi#pbLvEWtYv`xyr5G#wh@~-=UqEE zi}|$RrnXY&3a@Lj?kD)JJ^hffW_QN~~J$#BnV-ixGx>~W7mnN z{|z?D@F{oNEK23-6Vp|0DcPr2^pC&)OXf}X<3>^Q6jB^cPkK@t{6s?LZH3CNJAsEe z-b{9BE0{9LqkCG7rHDZ#Z(pg_#d{ zb3`v#8zC3Z;m(nLxsYjo?()YHhjx|NM)!R`lecS~(i+$EKYraQGTy#n}$XDinc-GCQHkJvsbcfJmM!6)SPbIOt21t)@+Y|$`k zT@ti!_6|GNc?xG!a;E6JH@D}Mi1}7YNw&PZDK4s`Pga23#pevJI)wC6iM+p zx#D3F$5yo-jb#egR!Nv_llrvv$Lk5N?=E_NMz&_{(Vl64)b=^%`yV}jEPvaI#ygf? z>Z_+J2&d_W2_`JCmtbXh!>`SqWB#ubOS)k;CnnvHU%f2&|H0c}!mR{>Ev4U%?2TYx zV1lNfx7Uu=M#l=YeH47m?#acmg5hwBWY|Zw1x!w?EnFNc8Xnx+!M~y*Ao=Fc@-@$I z`Dcj#Em!kQKUe*{^vv0_Xa8ny4a~EyvMsx~Ytrp$|Bv@eM@IC;_H5d)<9qj$w=1rk z+Z+GHVVa!FQom`_K77ubrsuXaZQ8s?&-d!g?efas^hL=2efmqEkXdP&zHIaVhaXdT z%XK{RmyF|K9a-*27ixZ7IC%R&MDm4Wjfqbh=iGSlJJL!rbl=$)heai3t7JBuER(E~ zNO@UtV6Vjeei&TenU8W#gPsFt-e(l zO}TT#_gG|ef2!@b3(7w@u7o)EhxVMj7IbaLp7}Ly4^GxbT{-gp(bd9yp+Bi>{CI75 ze|d51+mZDf994g;X`RQAQ7P*GL*aTpTw2!e!}e55&CA=6uq> z_u!b%-0p%d;aOtKBD|MG#Gbs=d^6f!%B4Sj^3|(sORG0a%0IsEc75*LH&>kXV`pXm z-EyJ&gFXMn1$^@I$C>&6eXN$NdVA^VM6(s_|6ho<%v&+Hfvt2hORUwqNcoy|>`r(rXKnv=dcZN>-YzV7c$4ueQ(U zj(NP=y9VfVBN&rY{I$Q4_6EI#L*b$+UU zjzfYtw&od2GBNpwk|6_yhJ^nDA2!@5I55M*Kz;hW=?o0aw;*M35<_#K0hilBjf4;< zHntn7EE8I0HrA9#3X7*aXjx*#qd13a!R~ce@4jec;E`uL{J;Hng8Uo)$G=*BPxw9I zcY^$zW^sW6`6Br}^BX)@zn|$pb^gY%)f4Z{y*lks`zG#byEcZ2MeBd9n{`Nf>4(2> znzrV>`C4?%ue|wBy0NQzu*u)c=bGhj&Q8Am>7VNcwbQ?E%ueptWzXKE%^xTIZQZoP z`E3th?)mRzZZVlXzr6WRbK<|iv(29m-`ibqxNf$`L6f5&ZEi?>vunKad+p@!_Lquh zGVSaTvvBa=pWFRGU+ zCsViQatp7!rWW_CqnLlm9456#I(vd{>|e^UI)CoOAZCs?1-FtvY4RTQxxYl|#G%Ni zS}zUXR94OWEE0H;S#JLCpGO)S)FNa>PB~QxbkvByUlt(sa^jQ6*8(cJH$(>G-Px+SH=1uB!zFB4`my&9dkQ887_Q+9cYeT2w&Fg*an#Y*b*q;9U zTQT9Q*MTDoVzlBTal1#ouKuQ+yV>bI2Z|oD@@vepn09)m z#S~GSaEmV*B6jkk>5l?_)bv;iw;wu^eeTG@6P^cVT8LOqwh(ULbb{%PkBnFI>8Cz2 zr)>NuojbBH=JCz@GcBgHAG~>g=81_GV$tlvfcysSl9~rLm@BF87 z-mbV%+?`%u7qzih?{vE>PpY(DxyJPwD~$^^+`;5+lgp|xZvw8_1{)P>w5EHh@ui+L zRuyjF^kC+sPUoF(L1g7&pShjRmWRM(@2!_UGN*QdR4$$1GnJFeNISuO=7x<5>wkEE zTgVsm-SRvOYfMz|^O#h|@7FGgr}nbmxgA^^=(nk%`uEfL^!1Skw)+0Oep6AbpxsHW zp@~T^;Lq!vCLfuu`njQVI-MV0zd6G|P$Pj!c+@${n}q|#TY$DEOj;0D`LtTvg>Mx>;I<+1b^63pkUCj zJIlhp2`ap&&PVsQs=FXI4pNT^Ezj%5j^%N$kDBEcIbSo9&uJ{_GovrM^L#J1(!xHFvqG@^Y@| zQMqdy+D+diLd`>Eu3VRReoL42gW%lC^B)u+y8T#otk&ZiU!{f7$A%+^`?g=$*=F;H z?bLmZ!oQk1>%C@qCvH7w`sCwXr|0vyHT81Ep3fG#vueY!YMpcC+*fTkXntJF^<3)P zf@9mY?nG=pW}AQX=dvT)wdUk|)vP`=i)G>Qa_)O27B>Fv11 z?dLxpKYX;`zB;WC$$vw6I+dq$FIg4A*lYHN-6wSVIcox(7)`(=e z|K<;GKk$z@ys&NmnORQfSJVsto#?joHQNsE58gh)m0~~YLJo_6;f@U7Wc^@^?1r0r zKQ9aOxx0@sVB!Hei^E;7u_bvSVv;-=-I~Ay>+Sx3P-wp`ko?>13j+h=R9I5q8n@a} z#Py@_^k-GId-pM2sp$2qTX%w~7KRc6`$qE@}? zshKRJB=w=^<8)KoF8wLC_n*W&^dGXEOS zYQOmXMQ5cxG_cvc|9Vc;^ikxN<$3|iaf;M%cV^Q^7u);puW{th zKC-xc>){oG{dca0@p~vwJ-T>);(5o_=@ILCFU`Lg>SbGByvFhT4e@IWmYadH!Lb{M zr9OD9apccH$`$yT5BZ`@+BSmnNAEKK*xxlr+)>byX7^Rbf6^4qe<-iIZDsLZY_s@p z-h0`XGqEKNYhscHd1JR~O$P*C|98x|uwg;jnMz9r2F6{G5l4<3aLWWi*5@u%4&T_+<(k18gQa~z%=9>178cD1B1PT*PH@WhGXq?qDN1{GUImGqV; zf)iAZT>WMv=dILwmt~H8xUr`Gx}@b#j$b|Jp}ePK=9KP#rou_f-W2!e z{AM?FtY-F`y@hG{SsB6W%n!C`3Kf1mRo*+LzrxGuLB~F&f3vugjvqe|Y_x{y>28&I zlhhZ~{OXv(f8(R^q8i13eRdlk$1bYjJ`isVmM^Q})|l_dV0};d)b;4D)WuqzAts#8 zo0)%y=i2d2SRy*%jL;-zhoAt5OG+x)4NDd@EOGI0YfyR0;2Fv2$>6aGtmaAmswL9$ zzrIft*|3t=Vw0aGmq3C9UxEk&gX!E|E84D>s9{M%jM2oTAy|$2=a4iqnp&Zn6s&b> zo9FaW3U>m~+T!rXrug{eXA!p{IB_nWU4vW-1xW<6R`v9EUG!q=abe&la6inl6rboj^5$jG?ziqoaQQ*C?mTa?Shr!5Xr z`{F!-G15&@RX{*sf`-dkWr1q%{ylE{mDWo(!B*HmafvHmyf*wu-+cL5mErw;qNPeq zOiW7kyOyRY?tjO;lxzD0{@e0))hvvRjDkD=iS6tVU&+!jMOY`P1Fr->;)&+hvF|NobH<^R5Y{(bw*-+7axyeZ%FzaZ!Ax@k)f>Fz)CPg#g_!lsZ4A(3UKiv)XnOeR@>cYZs! zSWr&H?gy)OywdAu`-6T9S^kuN)T06#=1O^9f8t@l{T2DvjWZn8tQ!qv46PbltQuX8 zTDB>l^iwGO_~7tFmw;yvJ2Wx~*{^5jlSlJ^<~qHyIK(-#Wuk$kUh_m7 zMY+B^LP3oaH+V+2P2A>iNkhnV>EAA;&rBNwjyz!6=`wMV<|MX>D^e_YT&}4uVN&W| zHpQx~CG~Ksz@#TeK?f&n(_DU!amg_Q6@BID3QF(8tA$)7#81dMPh7h`jK$vnn?#R+ zpLUb-7Ta(i#?H%Mxs^-2S3TyKyX88MTSm1FoAMUht)3zab0%GUpUBahu_XBL{a4H% z=gt;dU}x!AJIh5~Jx9Y|wvtIwwZl{PRpfRoX^hztS3c%Ix;V-hOB(yo>`ui_eFfcF(mIV0)GZ>T}fSr#GqCc$Q zjCsw#z_bLCzu(Sb-}G96$5r?^hu(<^fAhb6O%nObc1GN|-}vg(<|lbKr|Yk~{dWK6 zSp7+_bIl*Bg>1Xqv$pGa-U&-JbMJ|>OC6?6$l0beJ2H)ByXq#FX(xmtmCTg-YGybd zVeUA2v)kaF#h#5G$JBie2B|!B;Yw5D6FutF5>Pm!(?IKl*OA3)5uGwCJa$j)aOQog z7qi*pP(;vTj}8f+#Tg+hIqLe8#Q9xbr;|!M;!+AFpCe?4=^_X=| zg5{%%#-l>|BKH+0xjg>#ibH*qjAC_B$(-82$!dZRb5xaroXeDUdke-}7*7mudcK}p zig{vJ%m*(sfr%Df9=oS@q*zTpsEo%4}I75Cj7i5lK1ojMa$lhhv>3gwA&mh>!s5?X2+ zqY`lMzf@|Ndu0a)V}iU~c)Sv;C09axzcLw@Yd1X z?seYa?0)8bG)C@`SAO<)Kf68l9$O?LBEH1h?0&OkPWh>v;`pQb6JcrP+x(>S-wJ=3 z%zqufuH3r+_t&B%W8N(EjT;=%TgvpD&)fUHs(Dme(JSeg1Y=%W$O(yrA}-aNvRMH}2_(LuyE< z5*>Dzt(7$wX({}(@{>YizNFUXyR9p^oW)H_*?L!U>XoLgI26Hl+CY8rV&%JAh1RC! zMf^Xu!~Wq_LC33VZe|WwpVbR_PGIqzaE0&P1g?`p<_n#Qp0KSuuz72Edx^05YNu%( zx7qejX20rjJa|@s(#+d?3ZzuF-d9mQak8$cTGP#H{-oLg*yzZa zjg1%9upY_W+|c9LYteuE%8BEV58OT8pSr%MzxHogo~==h#-o4A_Q>xU%GiFa+HrH5f2=rpH&;hn{%*dVBZ>+msl~uAP_7Cgh3Qu>71#hH_CvOH2; zYVah~XNf?P#b#aQ*7QI7k6%-se!=L|xx2c?e^Z{>xNCPRJbR~_B8r1s@!_ZU4CM{Z(EAi5;v>gXB*WVt$3QVgqHO8-&WgUO#2|n=N!L?nc0Vt52*elGoche^^z9 ztt!EJ5<0ewfYw}jU*Y(D`>fBCQvd(||8;2tsIBt+-p^B8|9$)Xp(FgYywDzaMnJR; znH3>*2MHMg(Kci#I}>F&NrL0B|H`|%$ti7THt;93o%o{fme$c{Xu0o8#wX?Ck~6{e zp5d3Lh22V?p?}e@|CMlwe`JxCr|QZl?Os-G`wSMb?6k0w&^oD*=E-?Y@Uoc3Nu{(v z&U4CXDpUW+d45yc*)l^&UQXlc@%Y^xJF6$^SgYhKJZw>lh$!$-OIWz#x?;pH)=43s z76;EUZB0wqsJd8Z2jl9NFG>e%%dhC3yyMnnba-?aeID<{4f=MREJD z2yH#LE@!I?f7lw;$bVXy50>1N@^seqj61*Spig;i|N63TXMT&vY|pkl^I_Av>Fgif z&tB%ZEqCOlxunDdA)$-!)z2R)7rVVF{$SttyQ%wEG<5`&)i->pPH7x`RW}N9)CsgXGG*S&tDsFi0NeBIJ(hS zh;e(9YUP4UWkHi3R~qg~Gf~w_&qS^6D zdJI9AMC$IGa#2v#jBJ0l%Ks9#^3MaC*j2wwY`it;T5N+&xQK-3{vC|FRF|bcZN25| zW%M(E(_d`OB)CmyNaJtN=Q zz3}JfjuS^EzrIjbyd12Vkr&#m-M%+;<(ACNy;4S5Csrs<@vjfgR+{%ol`$l0j>AtQ zPA$C~3u<0+FoZtw{#$B$9BcQYkC=)J*1dplV1_U*efahN|NkSee{|pcSa|W>!iQgW zy!e)I`pt)5|2X8LKut$haH9{AS(&)8WmcwJTfH^R7isi7R(<~}bnmM5;Y+3cu58NR zw?S*N)?_Wcm7DZd>@wPEdpb@`t@!+%Ig_{ZcmMu(dP2NW&yzcjVP%ute_s-Jiu)RW zitkfa|NjdgKD<#{|1JOL&Ad;q99;fMsVG@4k^ShPXLRY4gWTVI4;Qb?&3jXpSlZs0 z%{!q`A}m}vRARZC*KF}l4;QP;r{biPbI(d0*(ru|E%2^X;+_{o#GTj8oJ!&#n{yA|R;ZvK4p-6ZCq*eChi4At9Cgny|%5X`(t9! zW`}uH3f{32-0OVHllw_<+Jk9#)*ric`K5WN@)MyQB^+H68IJum7HoVrdg6-NSrZR! z_`jbcGP?VT;;XsKm&{QOYR;JZ{i)d736Czs9_cRYxWiqmkYW8qc8BPxU5V{eCT{au z^lFEtQd-x!*$=l#7O~rB?+Mi7R`c-N#~1i<%|n^f#z$3nUmt#K80Y&+U{~z^f7fLe z*0*jdO@1OV#k6N)p~h-H+gkU)?EGThj-8MpKpEt(4@Ti z8qYVZF@9j-SH#V|yOeoTorhjx=5)55ZA)Wi9|^Qu98uKgR_uEzsxWb;s&4y|GxvpK zc{C5%8^>}5J`RiJSovq)4j!SO$&;ozO#1NLN8I7c55L`oy+ z3b)C!Dc;jx=B%LldA^V>Lr^dKB2JEdULPF~D*h-a5#(cRWA+qjWjNgE8qcUX@uSOp zzMDPrsi9?Ts*DqME)F^M?$JgrhcvOwKYv_ao$7M>5Sh4I`8vNUPg8usqU6JAw{={M z`Rgy8{dPjMp&|O3mQh9S$_Eo%_JsSrU{)08xFm6mc{3j`*Ks2TM+qI)d#`$#9JnMa zIvK))t|)qZU-&^-OYp<*>Iu&p!q_(i-8iPuvd+9BAcbcVi}mymlLL+`EPOPbZA(UG z#r2d24u_r}zhtmP!a)1OpO6O*%KzpBavX|Sw(#5j$qOfkzSH4LHQ80JF3z#&?zF$w z9`(@z6)%t0^*$1K6~2~5VA2}v{z8tg{L-$93%5yUFP+(6Ppx{Y*cwEhxKc6^4WbXNL7yk3{yeke|NsBrx6k_f;@-Pb z+kf9ae_ht}`}UcXkGsxdOU8#G$(XDLQA63=S$lIexE}vlZewJ3PUIIuS9i3g0o$Kj z{cn~&IkWUb$g-6J5~pKNFNwS9o_P1(3tjjBs(-4_c_!_XoTMoE$z1vG)vQtvll57j zzV|#4ERC_xI(%ivuJ9!dD?I;ZNCwtfrFhvlDF@Awd^~Y_#+OYU+j&ePpP2c?d!$G# zJ0Kn`I4w%drGCRY=ZH^}CpN$M*6O$@w?t9SajwHV<##?+F1IeIaj0zX$;;7>Kx{_u4u)4w#xIr%?)>Vb z;qrU+gd~Ztf`Ppoq^)#Ym-&asPH5gxevCEq@V(pdy;G_yk3_GFT{=;ypwq3b@quP% zNW!YvrxP4qVi!&L#AD^kz1QdW`D@IR^`^9M4a*k_YAEyEa<=O9+k45Jh5nb7@9}I& zt8(eOkQKyf{#A6DLd^NP&;pZrEjzV3#I4T#x&7LycQwx)tF?(Ic)fDay*3}sCXM^Nn)Np4 zl(z>ipZJOA!R8aW44-)xH7{^eQg!($W7M;vefC6)bd`R;QZC776DtHvBwg4K7BY3R zujFjp^4O7M$tF9F#yvgkiURqy6H1q`-{xBPkKyFP+ke=UuI9=LZugW5H&>ihroeMJ z)mrJWm4}j1^Nz=zCvs&~1S89K=$?D2(0Rgr`tAj}vMQXJyA@Oue05HEANhH*qkX~k zHXbK#70HQ*)sM7^EV!E6F|B3Fg0s67cKvm|xMh*l+SPs@a?9HEZ%esd5w)+@ZFVLffnDO7CxU_LY3m4SirJv=)pP7W|?+^obb zV$d4IAhMusMo^N6!5zgZ)~-{GoS6=`tq4l<5YX|^;1>yZ*j?89%uJxI@XsX4lQFFe zxz*VXrY^gFq3ts3?}8_JC$H$f6yg5#{f%olLRA<*c7ox)n2oi|6@X2)k%}{Ip;ij_zJ@( zG+t2`kiYc&iwEDO2X0j<94prbDWBsAT0ZB+M71L6_A6Iiv@DivlM8BMJYwE3<$&_J za^@4cA3PQ&F-SJK$9(7rHf*SI*-^A)qFNFE#JW`l=f4P)A5m@Xo4DC{XHxNm z6}~Zsjdu(icd$&dIDKBiW$)3vxwm04a;`#Rkk-@+RS!qqtIOp7I9~05pSz||ap3p=1%fUaXBik67vM~M zOM;R-B+wJz4S`@#$`f@IXkq+OWT6=RdiV4Ls)w&B$0*H_*v%;Qs6bq%Yx`M$^SiC# zNB{2IIBBE7lDCX2`JETBw=g*ix{6G6uKM&%V!Oh}JkI5r)5u{X4*VD=$nx)ZC9xD#jBUiE7TEOI z_sN-ro=ZW#9rYq67*Ke2P0&%fP_E z$cacL$(tHM1=LQ^+Rca_spbJ_o1bx^((q~$LpHL*=di20FG z(ox-Yy&`hkH18$dWMKSsXTqJVl38EEy|uYssd#Ox4+z+9&6WF`>t2$A!yCs>RuksQ z2uWX@n45P|GUMJPc{|i>@X|7#qM#)t?V_E2S@Z2afd@|C&ZjrVl(u(_nWEb ztF4ggk~W)3fte}dbAvW@X!I!{wcmBxLSggj34i?j$Hi%z+xu(#Rek4G5O%G%^@6SsM#d)NN96`QpC z#H$dFPUX!r8y$HjB`803;;^~DsY={A>I&hMyL%}HBR z(eJJsPton1aH*4)+B*C}iY*ab9h*Z1JHPS>y|-v$KbvDNB;sI`>CQ0sU8#asX$;RyKcI#!lQYSalBys%9GUzv-~Q*i_}?d|{MuCtni2c{?$71r z|DK+H%XtEHBqbYo07al+^??t^gqO!KFfh)Brz%BZaaeO?=|tWj(FJWYmIg9RTFB?Q zn8RU?lGjYd#sudp8pbM|Vk%SEyQCXzcVAm2!NFwkXVaXMU-{aF))#7glan_3 z;G#;0LaWk^y~hfwI61#XL`x9Ir)mRJ~4Cc(t~_Z;Sm>TZN(@ zU$#jL7bQMlakSyibH^%H!6g&O1!y7t7 zgk1FCVgER~?)U98?@DdIu4wttYIQq!I*M-y2cd6+LSMjrk}ZL#}t=!LG$QImZ~(-NlL>6PCgXS|rHj>px0vg7oHa|0wx zq<5{;`5>g@*>krt^8Ux*i|5_%^CbpfTX-h&pUhc}ly~0qL}u^%%J6i9tR)}woc_sc z4hkgK&NwV_WSX6O%_Liij5j}QMe}tecs|zq{JbfZf8hxG=djn@E+}w@76Cy#LV-214zyYz`^(Vk;3J4G&Eba^m2Tv)_)*>@#HH-oLOy3h2ATKZlP znc3LUZ*$XnQNKvxi&L)gDT-pkmXl8P2A*vCq@yVKseS50*}aUN0c=WM34-^1Tk^xR ztGg%soF!SUJLxg+xsvdfASER?m7~!S3Y#vN?oxX2LYa^HK#_m8*NS#IjQcK?>rk42>~RX2I))qHjR(E9$CV@rIJZmo;h$yqM{7pJpi zPg>~Na_QeR8SiiT6~~uE9=)UdXs7I#8_p?5UWYC0@Mc{Y`lM0(LPSfn!z{OnqU)cu zDy_7d=fEPuQqsAPqawsOyF*1fKC@2z`xODhK&?+Xb;VaziacDmeLL>wtF+sP#paQW zXqAhG(Kh>zY+=r+?#JwT{uMTOBY9KZKjwIrz`tl+*BM}dd> zvv2KN55`@exjz1&v$Phm?Rj=cAWmVI_ROvkJRSrM$=EHJV?8`Bl^C3@y@K8 z-8FZo1pj*WVX;H+ zE%P6nZ`(Vut2QlH`}ADTlqUrJ;%WPpXHp+=>{)w8^1BQZd!N(NQ$7DGmUvy9aa7(d zEiZI~-Ia$YB&MvalzQ8^q~}@ZjfeI-tBk%z*j%}M@n?hkXTB{ng)X<8@Ow6QL+ATO zwU0Fg#Z7W5!e7s6tn8P4le2if!-CuXb!=uwo4xqf{O~*>{o2sJS1~}MuJDMzOGG`7 z!Ne%71&vFJKHvJ2618KyezshZW((}ma+p||?w|nwSDk^cFX82>J z!_4q|9`#e-T4=hoS5&Zer zg>4dtjwrV$%l4`m!8-|sE+X6K$OsBk)sagz&NREi3}%>6xE>9ym;O`pG67PMA+xLjU8|FDuk z=#shmmp;jh>)w8=Z0&mNkM>V(4HlQEc6YAm7#5+X7dw>~*~)EN!|t+7&cAxvU!_aW zH(use`gq(gvU0EO>%x9D(Fu3%r*(^~t+u#c;gXaerSAPFH?Mz>x!mVVRq>DZ+P+VG zTifnl%e7EbacBO=X|tqnynbtayR`QHnOb26h86~%nEgM#pKf73_4CBh^9SCCGu6(} zVd!8^&}I0-_+oO?K@qv-4UX*rzgApH-^O6WreW4_nQ`5Fex5%|o%_sMPP$(Hrp(~M zaQaRB-{Zd6vR4tV?1en^3)|epkh6#w^gyKS1H48za0qBfpL5{#e}xSf1P;{B%4J|+ zdI`xd*T^wL;?TT&5^@*(E!i9iCel-Fdj+qF`k8=BvpDv%X{}#;_a|o^s;0(DMaO+yzE9 zAvYO%{5)=N{Znhb{+G$+z5ESRI+j>o{or}erslog-Wjt!EZOfLIrn^7P>;$7&5{!< zRSeWG%hn|A-Frkqc!x8ukA3OEFE2VJLNi~aIOfk&A20jHXBPPtN%Db&k{0ss(Eu zmxd`ET@FMW%1>qsC_q9yI zwmxfl-C8BLj&t(MPybK9o$lLWalc9P-?~PDdiJZDY?*1VIwY5D7HLrJGI*i$ccI8v zg){q9|E_UVo56c2r+&iyeE&D{8~5FKGktF%b5t+W?}aH+{b9|w{;4uwn-R0;Tg1Me zTl*Kxz8`gC|H+LNyHlSY#%_9qE73j0N-sT+M$ z_%U_1KZ{T_)8Z7JjN^TG?gT5pU;Cx$5AQDH1MMpX*S#*Qlb@A7;gXm5Yw4Q&rycr* zwql-_k1`a5e|>j%_x-FTxva;ELvDU{$dZ^D&AWz$J=NJEpl?yDf>cA3szSG*(l4D1 z6^l<%DgG}4?=&v>Iz=k=e8Gk8&ju$hO}}9K_J^9a{e^9|3vK(p{{Gfj`P74Z{;vN_ z|MxQQRXx6SnS{&=ELo4;9aq*vYHc&BL0jAB-hMss`s>aYUv|Fua{Ar(YoC5T`1|IP&J(=ih&S{r&gh=ifhn|6ly@ zdH(CqUVQrM;K75%7v4lI*|m4?-W?~; z&c6S7((O-CCtvT}xpTqgN4={yuUWHZ@#4ivvsTZUGiUbf*)wL$NSn6w>eZ{aZ{NOu z|Ni$MKTe!D@#X8+qeqXvdiCnb_didbJUM;(^x3m#&%XaYb>2d+*ur2228JYXHSRF~ zKB%h-TJSl4|NsB{8z8*>5DJ+Dg>!u|`PaFP4x@AtO*%fP^z2Pw+VTzWo9Nm1ZH zp|gL?c?0Hirfi2^{kDJfbaC0rR>y;Sb+I-7nfLxk*co*=J@oFD*#AoTv!6cFKArD( zwCwu+TmQPJG*33{v2AU>y|KtT!arHKg8#PTe>Lxd56W}V(S=z$0-Q=cILbMmhy;m(KC72?XZ&1`?Q0%*r#$nl3SQ%`<-~P(#DSx3SIIq+VnN5ubiXEDZ3)=#sssbJ!(3ydVUB5|Ic}@ zw?#Vi5JTVk-C_P&6LXahCtN%h`#Nv+`~O1bA13moNE`~-v3mb4nJ@Rv^mJ?ioEH62l+1At(BRZkd6v*<&0@?cC8Si; zYV%yT^YKrX4@VwIIJtyx7Za=DQGB#n@qBEj-Q~AAGj(UQu2Hn~m7D$aYvvmPd(pD) zqe&~*Jn#w)UOn47>(>^yd4fV;gEzBIdaE@hVNo#a)c>kWxU2pi+_37POS0dIZT&uq zf9rlfZ)teOvE*0s;dteg1=9;!Y(58X<_Kc;{r$XMg?(4nTlKaETicX~gD&SR+@DJ* zzOUJGOUHM~qvYQ=biyw_DcqpQARFOfbKP{cT~+%gu~YsWjNdtLeiZhKPM9}ASNlqF z)3!MaosCZxpNP_mEh~yRr}TWnrkM@8R=;*`Kg3n(wZOS@-;-OxW-7BgZY&C7b?=#Q zLPSe`_rzXW-6^bag2uoRQzeaP845?nUoP5|vC`@6Ua}TbbmM@O|EeIzNv)-X{V@=lp#m5OeXL zTCee+V&@J8=YOp#k9aucovlKB+51CJd|0!L|MLv-IpI>4?wB!+ocg z_2Tnd{_-7kx*qKDQ22v7%Zjzdb*2G<2bum{|f;}J}D{tfWIA9 zOPEEQ{Qa5QlqU9XW8XQ0Q_zpOZJ%-9_K(W_x+0-m=T?3?Jm;f)b5mdXJ^^)Xmk+bz zye$E#K4qwe)~CVSuT(5vTd{a;*`l@OU$JxP0xq{D%q}+=R{ZDI%XfV}G5uHS)rj}1pu2vPNzrK0u(OWa)8tp(4>4fc@9waY5%K!4@8?&lw{(hV8GpzO$aB)ts z=J=5FUa&x6u}k5kBZBo=OT^UAPLfaY_H_Ev(Pk^D;$J7IFZL&2eV?~Wb^SH9ls=`O zzHZ$uzyJPwzsBl6myyMxr$GYOf_5HjRZ%tMELRea+0@)H^~fCuk08P60k&;tIT`!^ z8W^avTsfj@Aj#t7kf+Yk(y*rT$qz&Qmh~z564(s#Pk^n$On$^Zn1c2Tm9??KtsKJUoV@BJ_Be3VSGLd-dfiC(BnYtwHikzngVg z91l5YxzGLJP`ly22M34agu`XV$_{*qiVBymvez}A;AUJe5$(2~n}bpR&#wuBOm=;1 zz0Zp<-TRTOt<19Lzx6iuP0B2u0rE{wKUP0(PjTg#v}dv18cxS4@{wV_7q?B^AYiv~ zgMi)IRK*3GbXjf)D$G1I3ab~ z$ss$E<3!MDrvu)}ksK#1J$Kbf$Z9GUeERx|=dyp_+#Z1mTX~g_^ZU)6A|S9|EO3j+ z@tOaMghUnvxpF%lP*838n)=kD(b%~o=4t#g>+nd$1u+p)1;Oi6ZLCj}Udo+hGx5pP z5*bs+OHV4D9Lj^5PjFYR}zoYscC)dhb zZ5Dr`<^=k9#9U6dsI3p3GRIm{F>-dD+~e?_^WEP}a&+>Y@6G{!YY4_cATChvP;(6uPX+~F%#?LWs z@dy)FJ}Ky=vbwwQL63k^L~IXl^*aTZgs4i3?^89Gtm@ux!PgQokx`YorC_ypOQWUH z3cW{QNnx z*m@Q$c0}|n7&4(HA!OPgnf!V{9+`{G##J6NScMxhvOOIYkBr21#(aXOJ-Az=i)mY7_)E1UM{sV4KmXAaM2nffctd328Gh zFlR%`xi{CZF1n{6!1CZAo2Qu8`~Pc7-#?r3>rhK1m_Dk?i z=hb35=kcqWO?HxW!AftI>A4|aR-Zoic$Hi4VaOZ8%>sFRkCiAKD{>Kf9>G~gLPrAus%G@3mZgs?Ik(=7;jk0M>rnP#%*{u6k zWfeG^O3vmz{>0GHCe-M%vg|Y=|1h(;Pr{f^vUod%9+`MTks&L+ZRMe2?c<^~A+kBH ztG2ZrjarnoW4B7;`f|@h`^qzZSnZ-@r}pBj?Vfxsxi-Brm*Hxx(rDqo=Er z_2V8d3S%>^Y=4$p{jBkc8ISYDkgCg?N1M(rEBo)uDgNwtv2(czE4-yHhkIk z_Jvt&alQTDk7u4QcHW!e*6V z(z<1lhtdB9%xt28f|V1e|GJW}{H0T$Pob}%mtFC!HMRfr6e8oJ)&>fSKJ35n&3CEC zDT|JfFMH>%73iG&^EA)IS&W@eyEjbQx^!v8K90rLBBFfMRSxaHE$t}i&12;_vCV>` zYs-;?r)*8F4F%oomGqeAoc}U$UKmS9=L(PH^_Og?dD!zDj=2?W{_Oi=?Wfh};=fOP zcaVRkp^?jnCDlq@(mpyZpT3q%Z`ZutsUsMCBjNe6`EE*+IbVNr<>^}zb)=(XMMsy< z3?GkW7v!(xyVsMi+VG53c4)s4mp^?T&1FI5!2#ddxTl%(-tMIMM{%@#uv@iWMOLW zKGC&Xz2q*R|M$Z~xxK zz`!62E;k$u{vS|SSkNGN;lqQ32>~0xy>rJ6&;K_ZN!T!ZcQXS6b0W0txYjB*$3TGf z!puFM9SQ&cZ#KV>uUn zi1Ed(iJQ)FPMlL4Udr1vv+k3}4vEukzt}p}`IVJ_Mwl%uo>1|Lqp0SO+>&a63Q_&E ziAOfp7;rQx8EL$%)tUHKQe~D2pUe4JZ$%hAE9ThqcXGRO3K zMfa1Bi%y1IE4{nyQI12a&+l~-Q`oWsBd;qST_OE8&e_2)So_&QDNc`VNz)tDkEKR$ zXgFdncmMjj3wcMmkH}7z@O@t(XBurk<+wM~ah3Ml2ea17&iLs$A>EQGPH_ME6`y*| zV}y(MOg*xVP4V;A*xeU$RXY|M$fQZ#+id>%Uw`FJKAn?+y4-)dyW`KB$ULv*IQV-; z+`ioN#S>Cq9DBY)BKXNAhL8gO(@mA`opslL-PnJ;Dq>^4r(^4nFB5W)243jd{qOt+ z2^Y(EFC(?WcAx8el3>s=X`1z|88>%Xdv<+vuRg!?`o+@=R^6_zVlVq_9hQop9J_l~+9oXt{;CaBYSA`efrJQ;5=qqTP^ULpl z`(Axt^zcj1t&bPp|8zL;+~L4;CckZRWmTKKv$=|IoJsDR>Ok7E5%nbF)$>gopFgw6lh!Iypwkd!~g%=^Xnz|1|Lm$ zU6EF5|14?JFS8caeeEZh*5n5YFkZ6mNO@rEwTW@Pp6A5W=Y9{Kss=h7&U5_cE#zhC z%QAIe6?5LyCE*L^t1-Q-x!*fUjEwW6jyRgQlMC$ec9`3pcLGDNKlS(f=I2>na^U^l+UEPr976DNW0y(^M~t--Zidk)vG%V zR7|IHY~3+Wo0t9nyVM--^3Dk9&dlm>AJS|*IbB;9%}P8vIV48-`SLpp&*-xXD!Z6I zoilmW<2QaA?v`r2)jBba-R$FnmrnZ^{*}_ZU1Rj`@v4t;^D^xu?-yP@?Gn{(`TWMO zrTfnAd+b)ove~uxM7ZywWl3g=ylm$`A1~#s7xVnq*VlU@&QZr*&-v4L%hbcV+ho4+ zSJl@^8oYWx+x42lrS)D@lqYeneY$4X!3|eq4V^ya+kA2{nrlDbcF_aISEtlg))smM zuRmx!QFT&hU})*d$_;Bx?>I5V-{RHyQ`cfwW$Iosy?y4B-~7LQa&AT)=xL9UHLvOS z+`9jC+lAE3<9glo`)urGIA>^#_BHZs)Td3z>J;?3%YjEXl%WnUwl7=l)|s zMvt#Oo$ZxnwoHw;_DR_GALnLwU0myQA}n@C&aC1vU2Lf=zMO}`P`!OrA_-whxXSl?XTTh$Evj^#_2d( z>FVq2FRxX7*`*onuJf%=DD*`Y~Vi=Mt5lE0lh%Q~bR}{?BgNKYL~V?3eztU*^v~ znLh_)mbEBfTqJKeI~X*1YX>en9Tr^p{~tPa0xdEzsNWbO3mgtKH0<-a%sTTg0|T=q zv_*E|s3^0c$k7Xiw-ev(zmg)HCiVAdFzfdf)+c`oRO?h+zk90nMt)}cPREm+n(*L&u=j&=B^hi2lq~Y^6z?=&Aj#-N0XMCc5JaveO<9{`SWv4^JbWP z99U>BSJmjkWas1JuMpqHD=RiBEkUP)VfB+60&LSZPE-`q>2_~x$lb&2+1AroD%k78 zmpD(sX_dv6$DihaCs5kYx?B&1jD^kr@d0S$>Nx?q_IYR6B|?MDy;=`ecl%;aP;=DZhTSR zeg>>#zio?d71#863ae*0*Vo*Ae&dUi*i>oybU@WM!phlcuaUwDDTS-kpNG9=y1Ck(cgY*48{8AF$ZcA_$2lXP zyUE>%k>&ck`uV~e+gt9wo>Tg9xgx8tSMBGizic;3$vm!XYdt5h;&e6Z3YFdB50?M9 zD>6seBBI&)h&$T}#{WOsA4Kt52HaEJvYpj&W<7^qp7RPOIo3DxjznL$tUW8j_$pJJ z&YL+Ls*IDbDlfb*rJ{6nF;{dC4=1P4jCZ20Upsnv5-&UUv41U>I`NUWMdhF3jtJ+z zDdik*a~=79v@2xS3&d2L%=Ngi_vf_>ec=&8e6>oy&7Qo??l7tU#v$ikp->~yQMbl2 zv*S8PQI^8AN>Ew#bD8qb z#VX$?Ykup~`dF>|xmoAWewiP$)IZkf{+O-)dz;+XZcu^rW3Jlg7M+vx6sDA`PR#(7 zUdO7nAO+acDzz{VomUeye(#Y@4$v-+()zVV@$MSA9TOE#G;92rp}w71e1s}mWP&9OGzTP#t-NyyN}|NN=S+gZWB0HrEX`XM&52vG{DzY4)AJ{ECk5wBoKw^`QIltxbq|XKOPxv( zmxRc~L;WriM`GQwR$OiJaGvFudu;;CM6s;322KS5MQ8Jr8J!M0TYukrPlKl=(c-Jd z-tY4in%O#@#J&5!OKfJnt{nFsq0-yOJ#S^)`;s^9+UH`fIf}c~)!80zF_fFuCbM&o zmC~=&z&Xr2x4+zN$F8z^@m+=a*908HIMX?*HkVYSLurOIppnU_3{f8Qy-__;{&#KPkFty8)uGP5k7+PvUn z;Jy4q{m0rJy9K_~6n|VMm@jUA{v>nwgcs`Te(XKg(6hRvY<9`A_xv1{GnaZC5Myi- zjP9syP*^r;im!p_@-l^Mk`ta=6*nfNuvV_!EEs8i=)`;WpDr0!ZUri#@b@WeN4itfGKH+QZC?Uk3%uFd`lp@8*CT?_Xlr|n zf`f`$Yu$HImzd9Y9vy#~km0n!ocX1`zC%Z)mZzsuz|ScvHloVU7bPBipc7jY_(3RB z|Fde-jrUwX`6o_!#;)b)Y4ly!WEP93?W%|!e3i~kAveEAPW*jZLGHfpYAw!<+c|_@ zo&U=-LGk4llMD%=83OO^mq?#5%#v-|>pG#6Q?iWdB<3KJo3^s!DT#_tB>JFXh_n&fdmb8I+r! z8fCLGLVN-%N5(}_7wZd)ggeS!Yo&v^QCNE$A(@0=@y z{Tn8D{%)7!{$~yco;&Y-0_kO=ksiAqKt#mbwl9mFP?9t)sHlY@XAxJy(&agUkck7| z;u`tVNqsqS5H54>!aLh_nij`1<}5O5=}eeW#E`QnV*X+Fyah(y}(zx;{CUu`D;#XJn1uck>C6icNlUO?OkKrzwes= zto{3My*U5)EyNbA)x@L&*Ofo?|6*WZXav_V0uBue4j2^tpYT9oL(~O_ga(BP2R{D) zAh6)^27?O)0iack0tX)azo0O?z`!A(USY$A%l{J=eE4`^f`Gh3!h#F`3mQHgnEb#% z;QyCn4TWDm{QviVfy06a|NkHU`Cehi#{d8Q|Nlc?X_NqVmBEAq8yb==pDl=UvS_-> zz`$wd>Eakt!FXp1tJq@;0hj26v^1XQ|Jd(H#HqAaraxMn^7eg&@;wG-#9T_VG2tt4CQcUPx>{iO6fE_Q>|*FvxVTKM=KmeB3` zp?CB}Qi0a9*$YqXS`nBQ_(vcxtV`=xv~S>zJ~m$Up7{zTY@*XvFs*OWuy1}Y75eb% zITM}s>9@336^qt=(yY38_*wM(ZmEUO53tI-f0A!!U;52kZPVGK6WI>^%uiVM_SaF5 z`&$hzbJ%hP>4`+w9aMh!>s`TPsa*ye-iWXM>XxuK>WjBT!OobX_St(~>TWi76sG)> zIFht`=bEfd2RZ4xpq<5uh}zScc=MbK1+uuol`XVzvZ?W?@-)|`LC z`-b=BS2~W@)WqGG^{ZmtY{%rSl@qQmxFoYX)L2;B_T9lSna^i~8t%SYGq*c0t?=62 zt9%NnuNnU>-lDZdguN+Y?e5*mmNqIL7g#vw?Ed$E{+tOb=bedu^XlijCGozV{MGIM zPo~7a6ny;AKUzC?g2sxrBMD2n*k*27I!9G_>B(Q0s^{*TaQv|5gfmAXL_T)}Y|i-$fo@404XvWGLIck0Dpu!OO18uyWFDIUR#%U8nBG zbMQ+>Ze-XV70(nZzCp_=en!ll%fDCue6~WoTJ$>qq<#@sJ*EO5>07ePbN;*De7VJU zw+w@8-ONdIY+{l_|89#|WN7{AZto{o&6uw1OJ40Xcu-ZiHB0sLZRwpi&pmpUb76+^ z!}F1r+#hCHvBilC|2W8Er}m;MS9d!5lj1`yQt}t)@SZucN}^cWvWiQ4aiz&Cm&5Z4 zUVLSDKDgli><)#l}e8pNe#}w0) zWF~j2T$`9^G*A5goR4>MAO1QdqQV&dNWLI{??IV850`N>Tul<^44%}To#R{k%cFq* zxXDI=zjDdNv-SRL-1JoU*`u|a(%&5Jy%ajNu;+o{w`J9vPx2NoKlfC!B>G9H`P*d0 zUtJrI9GO=6YFYV#havgfUid7L2}mhjZIY&PS=>3(Xpv=Z*bWYtdzWYH&bYC__)L&n zojg>p0${zH1wHK&+CmwiOgze&e^OiNZk=EJ*D~&oA<-BGt5pk^l<&3 zd{bKDM$Pwke}8|Mx2yYQV|n!LJhoXPDniyrCUGqOJY|Wbw509IJDF}Cc6C3seti2G zpI)RDl^S&?-b%sE=a-LXc>CkX)k-+9hr2v_2zE>;FGU2M?x{O z{g{7{LS5ymucv0}9r`cYGO6XorP)nYMtwh=-$q8+Pi%PLZ(X+V&K|)dj5YF$m{arE zPn~(|ptzvt+v^j4=N#v!%w4fHJ6__~i(aGc6Zf2Ty=nB~JHyQXI&&XA{Hncm=h8f@ zZ+|nYS@%s6Yw`LdD%)`VVe3-GN}jT7Ve7XpFBPv(-LkW{w;=!jv%BmQ^Y8B1_g?Rj z_m_J%wY4kxR>qmq%IV3QTQa(>)hXTFX|GxtePGH2;W2tAzehX3Z&L+=!h@UA@ z#q9SBV?$k?6Muj7-fYNoPh8Cur9Mw)lY*rFr;Q5j%d}m+6IdK~e0g|!kCAnl7jH&v z*Odu}C9=arS{_f=yYul#0=xD}pT#~E$xj@8;ufsS34XwMN0lqGZ_?T&wkA9igq59R zcdb@2PT}*NE?g-vsoGrKDJ_r1(XTh;V4U_Qp)R(AQ$yCeD5^~|WF_himU zPAFD(d9Sp8y|wq>6F(xV<}mLx2>SL;f$`poo)fHheyw$6ideQGY>FF;)bvl+K5Sih z?gV!cC-28wA$v^U-u3N0p(*fl%d~f_Hjk7K#S7hBb7@N#e-y_eg}a-zWG7kH=R9%z z(b3U%}!4DDj=Ucrqk zqQ0ILyJ2)^b|6n4^UOPU-gE7kAN*^-wxjyWONV#a6yHsGz`29bDDt`K zJdH{xC#}BGI(z!r>ssFUFeOz(d%EBct zv>&ZEvkS|65xSvx^WAF2yaV@Dy80G8<*3>lxBmL;uVCu8_a7#Gfn!_dbnL6d(k5qF zL(E7?GPF$&X)!`bfx=l$Gh^QF10n*Ii8a zmoqRhuz=f~4wEm)Z+j5Vz`*mhub`^mmioA{&;3%=PFR!q3PS@Fn1jrgsq(s>=z*K^!HdQZJ2 zufL7%92w{s)Oi8{XU~F`3x0#KNKdxP$A&#B7c( zmFn%q@=>ooIfxwC-m~LqtjU21ElThIPm13dV=BPYruu(U^{T(+KC_QJI_Mx@*v-i~ zfuj?I>=`E2)xB|Ydhny3vqeSW3AgD%TaQ^hde!$mt+-PjbNxIZTmAIlvC9pM>gM)2 z2Pl7!H{Kdjt#tZrt&!xkn*6X5`Av3Cc6St5ji-NO()=i~Z`-VD>o0pI{r7itQ;7fV zye%c=>(%>d8fV)%q*Goq{&YE8Yrg7H@)ntU6V~pxRam|DbJ*@D#aga^m+Zch-*sQ* ziCtNse5XB2-x@~7Nvw(mS6Db4 zH>t4nX?JW+`8supvEzdsjXS&odMccY+8(nx&1`025Beuy;lr`)RuyN*$D{@ckLs{& z8IN8^v-$I-rAtSpVB+8ly3*FT*7$f0}>->H*qjV|8u z9!DOn2O|<03P)Rjf~Do655+4&yFrbnx@rPBq64t}izw6n1g3s8+@(;( z;dCYI*oR7yOJzNAR2mnxh(Cc5o#J}^U)sf+ta z%8N9+j(q`l6c)AY3%gk}q3ryEC*_J-@Ab;3yBIqiDQzyFDb;);N;=n4{m6^z)a=F+ zwa3|#^EwnQt64R@?zB{Xd9L8HYDcZDLzQ}>J=ej-6YQ3} zp4L(#=COVH6&=o#A%R~NQWth)B%VmTx9ThFq=$Cg&V3Ub1Xx=GT3kHfsQHES*&8uM zE406!5S=coTeKzgoA#OOj4jO1&$mOBbx3gDcjLYuQZsw+1~vhyPEN(^CN;C0*8Kdd zASk4`K2dRf!=4?^Qt2MYwhQvvAFJczuB>y4JM3`5=tQvs$31~3sxn9ZJZ=aOuu$M+ zuH5+NBidv zbsLkH9<$l~SZ>N;{Z&^T4m=m@+@&)6YwAcHz%|c{?p< z=jb0tBu$>{DQ+!Xbv^Ol4F2@v-`2f8)L{N6<;>3?$*lJi+4 zDnbjxPW({snG+{1dc1YwdLP?XpJO{%cAICg#7GwO9ha-RSmJ4@d4Fd}8pm3pmh~@0 z+N4}(Y9_b%U8t)L+vB-dXDaKY!wftAZ7Z0Q*4wC`%E$I}$I&Ow=Rd8|bAR=0^~uj} z5^PV4lgkb9ZG%5|WZ|4G zXZL?OBy)d5;mdi^mu#$U7$#XNg>iq6+ULPyA+|dGMPcMTd!6$xG8bHqMJ#D!y)=DR z_SLxm<=f1%Yn2^7uiW1hY%DlkUU*rxKI3!yVdn>qmK*p^nD49BoA&J- zm(G*J4+T?yyiAatz{JfW>^zV2=PeQMbDTG(ok%>z=Ii4>ulxPJ9ik^K`jhABy1ZG& zo;kDbRg8w3y3U+Mv$B^?Y<3lDR1+(AWxD^%c)Qg7_M<_E|HOPVaWB2c{Lsf`&*{3u ze<$$o|8hN>bxDNB)v_p&%`DqHc4n73SCsce-m^Dw@DTWNyUxI(*dZ&I`}l>zGPyIs zI-B+}I@;`bXr5l5n;vzAY^NPd4}a`>`NGib2(!N5R!<$4?fd5} zI^1*VS_E6v66L$ia@Dtf3D4VqRJoPi$4|6uquO5E!tAD8(L)aef1S0s{=xkFz1TJG zwr{*kTkGB}N!49qU6wGt{&v9w%UAdJ$tM2a8ZFP6)NCN)us`*Ia!%%H&YJ(q%f9=3 zO=M~ABkrgk$K{W#KR@vOd&s=xJ#)!zG` zHwK7ZWzUytdj2BRT0Y^h==mUdF)3lWWkGI_(`!Wz<_1a0r++=6Yixt!`(UZb))@l4X1<-Fjz=V_&R)YfR9bc(2x&pw&sPtuaAp z=*)?^uJDptVZn$00tp8uI2b%AxUeCx!J=T+&ntiA{_g`7)6xGwT$?Shw=S{%?n(v* zHt62QJu_a;TcW^ogqd?Y$NT@Asw+!8@5I0Ex%^+h`pgPf4JXFfV-aE-`_6qZJK{25 zar2+0J3^<;=UKZ$tN!B`!L-N~U#1^Z66&{4a-Z)YcCAtW=|*qI2kP@hf;u!#I;sC? zFS)d2ijl3?)Lx$ZW*RArl+Wo;J~mfw$w{~N{Aiu9ORIBKFEv+0&MfcmFc9hH^w_NM zMTOHYV;UnSh%6ESs}3FZn0y zutdFL4m%s__U!6j!8N6<)d!Oj#>2`qz8f254r|+rZ~nJk z)b;EKmWpS(fo97RKTccnM9L{I1X9!we>nbfQ&mpX@i&P&){T0CSB2$X zy~#NGA+Y08V6yewjzd4ExhEWmJ$FyY@x+S7N6e<(KmU;5@XN`&S&LqT>!*A1a9O_K z=$)rH_3<4G%TS|cffw7BUMyY`aX}?kJCgfp=>H9U^N#uyZ>W^f+g8kO?ej0hrmN{n zZQieo3UgjenKSA8&&c}@_MW@lt$b$Pn}2HYyTZVRr&9}a3)udP8}5B!^C7p$_67^b z^M4+j@3qS_Zr`#ZdVy>TOJIw2y!XEE?z3{c?S3hk@yE|87o+>Sm*ySP4TfTUzj8~A`_cF_+Rl838XG@wQq|qta^)5|P zv&`$|yMv$hPB~+>R%9!;vy#DmiwLbXm$Q%W`L>Wvi*ege>+K553(6m#OD_NV^$TzD z;`K>6qP_RDw6=toaJ+bsac=wmdY`>ZYgVrQyYOq^wKo}x&e06*JBrrGPpFyC%vV6kFNiD9QpT6C}dXs~% zk6n0Ta^`Vi=k_Oh`5q^fVGA;?TeIHNUEa!YnVR4K2 znlts2!#1dWtth*+duk!@ap^f-y$Y-+I6hHEgR6Z=JCV#_AQ>Z2bYJQymEH+%8%N&ZcbJ|?DWQb zbHl6mjuWJe89%0S9}}p)7buzZT=q_7w9W*X&#U{{H2vHQj@Ig~+pKY=FD&k?pw|6W zf8@8dHp*IZK@HE6tJfHG8$+ zy^5!Czl8IjA0ppg+Jx?DKC5$;cV#$x`Shw#(Y>n|Ys{DCUg(^->t0-mhQ^m^W+yCa zGX=~_W^*pNU@a5>sr+A5_N?{ni#X3ttjqfRtme7WKC3FZ>!-Iqj=ym1pG}41q5a)k zCqF&mD8X~UZbepK?2#L5k1^%{_$zO?`}6d6$;%55)J%VKQr>gL$tKO-0R8QMcW&GJ z^q+i#{YK}DS$9`Hi*LF_F~Da!kaAuA-bOK0h?927G!x^byZ!NE07TS{e(k!W&44( zns3g15s9q~dbm{cRqMQ?Q>B^vcl9#vyPnJQ;#RMw{rXu8(u(E2Y`IskvvTjn&uklQ zzh%#4Gz<%#A}aaIDZJ|MXVn(XV;v_JbldzW{lS%_(e|`C@m1{1<1xDOCa%4oa(7La z2$4J2v?0+(f45~e-?8tVl8v@c7aX2+V$#P0U)ufi{@X8Dba+yS_7vwco)a1mPx8@v z-FPuf56{=db%E)%q(?`q>|UXIrjMGhT{queFyfWo!rRHwdms~e*u%@TtC)W zHZ?skP@dM|C=gNfoP(=L|ITUiUWE-$&IyXJte=?g+;84|dUi4gmy(%rvk+{6b1Yz+HB;qbU4%=t})rgSLi@Yl32ZJ z;&H3S4aPfWPVrl`EJDD?^^hy`n7rM zWSFlgMfz~h3RQ~lN#MG}g(E1fJd;=ln$|my{&ep5$ znK&or^B&#kuCk+RowNG$eOhauY&WrOXsw!(adnf;^2I^hR(NHw%wS z{{Pk=Gg1_<>G4h#zsu{bl*AhKdDeSJsbf~m7mlTDW8Zi@ens*pN8^AW+?T_z6@K!Z zF4*`|L9pJlsJN<4$Ae|T`CQ%vb8jOBCl-bZtCmQcOKwk06VeZ<{n0YZt3M#E+VSn% zGkJffMWRv0f`x9G^Ac2konsIzsuQl^inE-4K}3<&Rdo5CuoM}-{98(Im_r#lZo8cL z?&5L5M6lI-!WZFn7PAx{>B=U|=;)qw&7+?+WuCf{+0P!{up5<1MU&4PiPdZ?dUox| zB6H3Ed(Asn`uo`RiDVx5d0=V)bHhI0C2Dn!wMGn2X1jVE4iH|uZ%$F^c8*kU=`|ah zLeFkL#2lC7s`g-8=lre7RSqpe30=)t~@kHJbyGJONjcjRy~oEH@Q`|K`**ExYejxF3`pK6s3YI~~i zR4Ga2@7d$;!r*a~S-|%0D?%M5{dzO6PoL5?>vDqTe3QS&*8i4h_UbZr(PEuo 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

p!aG=A9TF?A*r&$bOlekd9l`6%|FaX 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®|9r`8lxX6oye$$dY zMfNcC1PHzZK zpFER&i~5XW$pe!c6gNtIP}o zUbwaGmbZ72-SKoGPv`Q}a|N9mV{>M!GWN8(sC@8_b^M&cB^y!b^2X^xZ-YRw6N53| z+DL0v~@R>*j7#mooqEDQc58DQFd2xXT&k_!qY5$N49>Ac@TY3US?+4zMTtxh^Rna$|W9>-yt!{Fblhckqt*qI#)xs$ug8fye;*4QpZsKWZDr4mGU@j-lpc0(be$g{+PL5H zaGQyD%*s^PdbNXRzMaYwt+)D^^Hk)L(1rLThql{a$q6(3dsJte&&t4m&+Gp^FXy+} zxpmE6T~{o%K8pk~wSF43)`#>m@srVsmVQBI4o=1y1)xo*)92^awtJmEzw`h9|99?R z=$ah;`pu(h)20;{7bhntFIZl+=fL8P+b4hf{&~gv_A_VBM5;U~WME+6h1AUf4YMx% z*ZQzqAnAeobct0A49p?WiuOV%;{gK!<_m{D{`_vux%ip>d544x;Vv#NE+*Ii<(}QI z>he}#s;ONOr?u9R{Z~AgPgvg5G!$6*(W(8QOY(b$IYC(ozgBd%A8c)|VwiQswI@=; znwvSXWW(A=E?OS<|0~uv&c4+adns*4`j*AZwdFngHgLJGv*ujm;#7TPgOuS@!G>0o z)Bh(fW&NRAAT>crUp{62j*zXtXShr`=E0VCrB}d7YlF~Pu_v{~n}sG@Rc06l-7K%z zzd>P{%<_q!+0}YyT&VHvXp-pfp7CRW+M$9{&6A8@SvxIeg&exjG_^T2<@>HJs$zyZ zvGbxNtTt@gT=uLq-pfg)z12f`(Sg3T=89Q7LWOyKi>#RiieAP|Y3XqGTxa`|(a>B; zQ}vO7Y5;$3`)?;c&Zt-~73N8fr}s;`no5-TF(@{@Z+{?)_qfCA=#_yB zR=T}*W7PgsrFE*t)h6Wa)@AEzN;d4O`|?8XtLz!)`EE6`%x5};)T*^2_R9DC`uUEf zha)Afzw2<)MCLt{f7{#Kwg@=r6|Zg-ai*!uWlx9U$+Lz>ZZb>NxhWZ)-xF(D{i@D% zld?;PcST%-uostN3F|qfjxV>TA7QRf;DYyPO|KMBH!lP*2A!MX-Na0tz&kUdU6F3*Yl%AA0ZRP~O zaseazkA1Q(p5goVH7R%g`r7+vgK=9%dE$<80aa%ClIMJjmONhk;Ev-ImaCzLhkdWb zimra8b0%nx-KwOn=!Vr7Li~?!pJewSr{t=z7~j)o=LX|P^1-LNyNmT~g+j4J%kndx;zeXaTtkU}=u@n#-Yl$f!zCjBJ_AJ3Zrr%BX3d)a|Nn=EhVI+9udAyI(wv8rXU?2~vmuO6pFT0yMi@ZGsF`<>lqo)PN38Rj6C%FmY$W+S3i&E(XlnZ_u$tpmasT;-eGx zUq5jB#f2yD7M!>P(emN@ufK1f{k*vU`?eXMXBB>$nDU_`{B4fG`#P^5CpP_gdh5&L zx_70v|G$6zef!LYi;uqVUz)h&=*dI_7c>2b83uXI`pZJ~zpm{T@s$BxC*}h#u%eFt zuNPRSVD|ql#1aFCf`)+q2?s!(i4XrTO!yDF8f=a6RLFf{5HTew{*`VOB5qM*r`c326&lYaG`t;r+f#!t5Ht%Vxqs{Kd zCaz$8=p{AM|Nr=& zB&BO}kYnbNzSAy35V~*UtLb!lU=0;k=*cwcdmOGL>zwY73vBlKhzV_FY zOGo;VL1oh&#kTR zZ(38aWS8VWSGkgP{O{u?bau4=>+d_krZ(Sqd+GBgo_7Zim&?32R&zf8`d*H+dO6Q& z+x=UD?h5?RR}&Byx5;)|a+G^X+;WAGNiBc)*6q0eU`6l!qSHHjRh^bv@0WTwNqoC- zW!vOvvouYij;9kvUkUFz@ua#li8buRPKsqG9thoz{PZo#zs20RCuOG7pI^p?6FM?F-=E!g#`RPMM^LZmqfeZYFPUm}|5{GuWPAj^D+FZOi@a7-J{Za)s+v z+-p3}xi~*A6za5GIBBl^6Dv!x-m{v^uR7%`t`W&P$*etTQPffww>e?FTvOEqbP`Vp z-4wpT;ol;vQ{Xm#|n1Wfol7&oaaH)xmnk;MF%C zDXOfBday^@%)a~FUcKEfMOTR#*3Gkgx7B6$dS+*a*}M!UQ%@ux5WLdAm+eHhx6sCq zOSP^3z1yg`?}E@&hFsg!_GbYC^VUYCOPQC+y?N_;@YuxKo0mQKk1x39-8IAikF&z3 z#UFOPP_2J-##ffVN8eUW^VF4B2k$hjb&M}aJ9cUHtoJ{oI~|NWn%)+*%yK++-+NBS z{qxTxN_C7@O;OnL^gz>(+9@4Br0xZ-m}ELBHH&L$4`-lEN||lM*H?V{;mRDUOfC@u zHU*mwh)aF;Rf%{N7TR}kKZ1E>iEQ_v8kC<@T`fkH_SMl=|9%U`lyRPOl#Y%Ou zc8D5=c1?R>%P*&Hq}jjdi&2ix;qpnBPo*z@!)H@tP(EeV0+rhN27(_L{8_8Tr?l*u z!to}B&1Qo_(Vn9@CtNJvJAC3+`Ti&tkKkz0+EAtNn8zmni=^=R zQY-n}+q1Ph8YMUuOn!6w3eTjS|K<2MKc1ZOE#F}VU+uvOr%nnv>&;)le{_C_$^j*- zlMA0lU0SUyk#H%?)@O<7%90I_xF=~VOPtCUdL`qtvrnZ<;F*noz3A+)E}6w2V}0!( zaXdc7{%c*YtjU+kgR7Ok&G3;Z_C9|~vD09$f!CyUJ054R6Zvc@!`E(HzT*F$Wha<& zu(VoO9~0ARserax^sxaO8=K_hWKU1eu&}Vxr$N(xTQ+UHdGlshSJ$&=&pvC?oNw>btM+QZ)0 zdA=*P*&Azcur_w1ii0Bq1A|lvXb>`O->v^P;*h<>uvP$Qrf!<7T5hbbOQKEcg5T z>$uY#|LU9Cd2#vokK#_chq`{B|C_iM@m2^B64 z7h|T$F1(_SRnk6|FZy#`E;CO(!uvGV!q_pl;} zb+^iVTa<*%c895yHD0#8YTMy)C#S47=<34$#H~HC+(lH_a;l+qPBklknev|6Mr1_xpTW-N&C!kN1E3e(dW?!?ORT8vkkvWZrW=k-t^X*`yP+%~vW= zYSZ$YpI0rswC1?Yl(;)<419RrL|^hq^1r<1nAI-k533qE-fOU{Oj2(YDExj`L9t%A z#day5(2olOC(1a5rXI3Za8f_{yX)%foNoR8=w16Z_p&7A^QyK8<>m7pKccl{@o@#~ zQir}B&Mz!q{t7y?MIcD-CvWfPwYj1xKk_DcD4bjUNbu`-qle}?;;fG?CS%PECtbFZ%SiJI89I@dk_(%RKMj?WLMm5wC_FDa zA=&bE+p+g*Vp(Up4`_M3Kee}Xg7@P$WtWXT!}H&I33r`OKCCda?b)N~+}h(xKRVa? zzUX<|BjuSad^95Tj5P0wh>&M3toNVWYvh+*%SpA{mMzXHbl5vXOcD(Ein4^dh&+uRfnyO+b46{ zoZ7m8{|@)=6V^SCxR-_OmiN4(dZp54&Gn^Da_ooXJbmw<4Vf8tR_;XlnaI-a6C82N z52revWB1-4=jUVRc5!9MUB3U$+f}T&{8Xx^EDBb6A8>ZI=qKIQYdb!!e9IKBbn>NY z>v8KSR}XWsCE7{T(sbN5i%4#cP1=6^T9j~h2&iOdU??d1z<4J2*PJxVk1MCl?kL&X_TyrKM&2_U+G}J%j9u`Sj`2 z(xpq?-QCZeITIQhdNkyQHvVB8>y_zn1&Fa1L`ReyMQ)GJ|s;Wpvc3=Cs;gGeqbemv>+@sv1RW97 zd`qnFf#s5u8|>yhczbyD3Kea=IoFmLu<|c>R^xX55n$09QN?*D%IG@$Fy6xbiYd;r8be^&g^qcwZ&3l_A%f9Dd+^)H3&i9*_gY0uJ zE?_&pq-Dt;?Y}%~?0Md=RlgK>*|r@xguF5aGg)Vm_CrR1wytR+1e?mWBiMgC%w@*S@%RdgK=w-iF%)h_X zHffQH+VvxLsixmfCC_t8cIo_K_)@@Txq#)ye-gh9W_C-mbtHJPsNFZ}e|+CgHSNr& zt7nTgT@cu8H~-nDc051u(a^BQ{H0lybEwS*i3wS{9^U^qY++q{V3)7@ zx?J@{#)sYyPqbZ1%vPLiRyy6*i#I4av?Z;3{`Xb)JzBC3&Y5a>#ZbwmYMI8FFr};M z#e8=pg8tc0$*AHIG)Vt$wz52rCsSfF>#c8fSuZ*>wFQ5LWFMbuc*Uvkv+My8fxrMY zp9$=K&Ob_GCcCK!oj6%(+ud~Fc(mx;u;%)en$bc6Do#hfU(*pb{_Vh0F1)D5(?LMt zP~Qx(-!(^U72+oui?ei^IHVkqGYru>smRgf5-~d?CQvqGiWcX!*SS{}Jz83)vffx? z$=so<_WOqL2?2GdwV&_3x)Hc|`@Y9_lFuFK7pRn5=Hs}cX@^tD;RUB=x3${e6uLh9 z2~S)s+r;A&J|9!FYz}`P$7wTXQSXWeJo_4r*Q~fVFFi|0@8Kr%n!I-}c-Aex5$4Ok z|L&W!m9i7Nlq7!h`+Q;9fBNGyEq50E9hYUU%xFkvbMjD7O5k%hmssn2I^saEqgB?v zbMp2)hWz!6vuA+qzr|T145}a%MJ%tsF*Y38MxI{cGeFeuG)|V&3 z8IJt$o5GnP(tFmNk2mOLAWub$zU*vafzE}JyTpYOXX+hJc2zO_zWE=&(-UFN*$3X2 zonzYGB+;=j>Y2yR|EbXzwS5%#U%S%!UvI;;HsdmZqz6@Y6W7>#obdg6diR9g6MnCl z`QGW#nJTGPpTw`F2VR}7JHql?uq=b^5Z~I*oQdaO&AIqUZ(eb4>V-2OmpqpdVgU@=$11|*@tbj?e1)zb-QhLdi?DpyDMh!Ml-Gw z-WWI8f5mkcjhCG#Ty3+e&aLyBdf9TX^V8`+>Nu2t{JAFA^!wCJ@1(2dyHrbDwzK>b zls#+TwAjtPlgJs2tBfQrSeYmkDH&p zir6+=cAr(#^&Q7Q=Ui>%w(({UuHGkfSDar|)lAmVdZDl|H=C-{EEd%#*&!ZDvU4X{ z2nh?=E&Kf9iOtFj!A?aN=RUQmO5Y_anJrq+UJ`V# zT&}K;De6?q{EW;KE$?H?y#6r@rhMzSTC!Jq!;y041vXh0;Wv&yF;`8qYgO9EKT}`x zz_sf~|7~L_NuJw0Cw1Pj^<5PV)qyM#E(OPDfr@=kS3j3^P6Sj-x^?~9wFfY8>((t8^TE|CS1w<=^x(mRqeqXPIemK1o;@c|oLIYd?c)=B zo-ONmF**BHN7S1fgSBAry4>;6^^0rQu6?>=(f)n=)~;QwcECC z-L`e>jT<-4oIZW})Tz01=T4e5$C&Z#4$SYT_CbAfCuq8M>XwTUFf793P zw~qSlV=Z`bk+n~$OJ7N7v1IJb;!{5Yr=1A*J}&fc;mR97(^6vGwAza^kF*I|ZoJHR z$H32P!CoIj&+=!FIJKwLz7G*w;&(b`L$kr!jcvY0mzz3zk7P{J{ez_oZL9 z+I;bjUyE+uMZLqTMA$YjZS6RIntk5qquNT@1 zT)E5{adbg*@x?RGo-~En?5f~dp4)SRb7e*8%iD#kPxRa{nsx81+~-Vd=Uwi_j{}~) zJmGreOTy~c*B5MD?Q!DOo`nm9OdQ@z#bnI(y~{lR?D_j4g6$jfYRb-am3(}>xG*C= zuVTTzpN^joB&zb6obx##>k}LB{JQ(qZDZ?S(vsk2>}2V1+exfq+Qk{OwH~W3%r(^S>u-OW@k!HocF(jGnU1%adfvWx z|6T8+MCg;V?=LAQNL(=EK4yLS!doZd%G7_$gt;&1MJwL0-1_`%LunGzEmxPIQywO~ zLSYx*A6R_;T;Rqv9+%7n#XhaO?ds8cNU7iFar$h%@nT~o3 zPk67bHs#Zsk~u3zs4`LQonFGMyr&bJR2Ic<>dm%s2r*sdd4zwj0?*9G_l4h+9hC}i zDLne<|7)iBFSo>BucKp&G<7^;Q;xs>vRA=`d-KNkVh#&!y-NOO2~IwR+%7PeUyEG}&g-6xcfKR8jMap^I`FU_6ZG7o3y`Ez#L6bdh#;#DdA%V@{i z6SDTl{Zm{QdDQma)KXpJTKAz?Xk}+j-CS=e$?06aPiD^lsMmj_jZ-0KUucS-xT9j= zCzm7oi`cbpO-hcQXsxhFFnq?8<@a+nKOK9$WRu%Lec^_uSHfIAi?@UxX54r2uHEX% z)*W{qZb_QBW`gL(Q#;g>OO+~BQUw$nI4q?1O?MYs$N1m;<4(0BN`lTZLYm2pE?;gY z2p{!jx^P!cERbix7qx!Ze;qxo}|oc$Ug;;Lzs5OiSXwI(AjCOg@` zxty(*UYA{}=RA>MyMN~6!5=f&j@i5l-=Og`D_-h5FK^(9C3ha_yH`wEuvLN2gIh>; zZs;wIz$I%BBwuUjcwyLIsjllKxtZOCWzD(@d(BE=KL3Kr{7#-p-zO}Xtl0N+uT5dJ z;2;0>^L|hFJvDoYXiw;)8TI~pb|pr~n;LorS3hwLe8Ji}CoE9S)6b7X?(?@FyyD)O zhG#x#eDu~_y!U)(%UW@n1O`5~qo&=ZcE)~(vVU<+Fh23>t+(;_jJF+4t6ffUD;;3I zU(@wZq&-)8A_t$=13A8sgPJC_y%ra23p|BNUT%AkJkerlm4MeFUzgNKuEn_vPTV`j zJl(}4u5{(b%?r02`!TomH|vJgvtQWzn8w*{%n&*GQf|WYUlnKhT!q9JJ)J1}yEk{S zkfdhX`$l=O88UhOJPz}gH_W}8t$#o%Pp%@AdCIfZo0UpFG1%CD^iB~J+xWe}O!LfQ zMV-v`Hx3)BE3GnlRNm+M;a{Tv`+4yy-j_wvz73iTYKZT4Ax{i>%9mua6G&?>>F=>x<+wo%iPRR}0Dnm&=v=m;K#c_2!84 z=>;beCQg5@fA`YwjlU~)X&7C2`eM#;`|th{Eath_&C31%cddyFG~KoQ`;YYRUp8J+ zH>%jEeeA!I;L7(g-%jdbt6CF?sajz(e2@crDi*H|OG&F-47&FbE&^xNE?n8LXz8-P z+JzGu&r}Cbnm+Mqf#usAgV&o4>lZEE-j>xqXYS-h6Am`S-zalGTOG8vt7J=iE@b)N z&Xx=aN1PkR+^?{Yl4HKJqr?2~g9_DoTnRHm8~ zthK&dxjIcF$U|FSU;oZ(xkZgC`LUWthI-Z(df0~j(8XrgsHBQ0=Q1!b1c9sQgaZWv z7yo}Sc+eiOQo%9h|D*r^{~P`P|9|oS|Nnk8GzhE>`0sF6;X}cN1ql-#Y&h^6TuGx4 zjsG_oJV^L(U|xYkfWn0pFaG9&I)=v~9m6x%*^6Eo2sAw0nmp}Z&d!U6FI7MPXI?FK zbd&JJ1w9h?%;)~FL}nYpNR)|M@l}~wDbSs$A4AjE2eLMFxRI?^ugRs5~mMY zCprn<)982NoFbumS!aslWTAhBxmuM^HnF`3Jkp|NquXAd`Zqgx_2JE@ZXRiRHL=_N zQrQe{f31WwEWTZfny+3h-@8x1z~Ir(z;@vlu8&EXB`a@jZ9A-FnzL=ys_L^0wXb@L zvu-5xrH4H*&uiFdlkvppSd^*$tAyNruXf%)6s>R3cXa7GQ^{W!;{A_Gg_f_F5P#%{tT?>ToW5)3RR2-MNi* ztThFm&yFyLpHsN!9kDvC{lh1Ljm38i3-hw97F|!6$d_UALs5nK!t6^&WA2p4u;%U$ zW$hI^eeke=&f%VQVw>UvSxuw_*19FlSthDpvRO>OB9Nn}bH(juBd->b<}<6E!$c&{ zr^dHPcZGhqs`&Z#R{oE>b&opz{B~`Hd${$K1vdotpKOW?-gWE0MAN3p;p_EcWo;@? z9Dbe3aDDcAwFRx-=I)gz7C+x4#_%OQd6C?UjZ0=Rww@6n)vfG-~50}@BS^F9c$%(qswWQQ`GWa&JV`rwa!8A^NQ}tPb$@@ zQ1_bQ;I#E}+P+f{cPoV^-OeeWQu32O(7;$?`bdCimnsmi^B?%Vk5gmLoa_Zo3%`9%iXUBn08LPmiqVoW4G>`HT$0*cKmDL!`-&g zB-ACWA(wsS(Q~KVPN!5k%CIY|ZA)fsdsmaf?tbAHyN~ZR|A_?xhJi6Bj=6NH%!>L` zDVwu)uAY~!QX8wuFN>-D?^hbC{ho7Kz%a0d&6#y(%Ubh;!JVaFZ(UQgUw49Qo6bqQ zm6dh{AFeV^e0a#iKGl~+;eq_A+xx917%%UJ~ ze}4Pt=d*qP{dN4F`zO9z>(F1Vz53jU&#rb4GpzmT4hQ9e*ciQF|aXC*EIHb0&&_DXY&&P`uG&3_VxHJT5sUC2U zU;eS?|8kJ&Jwj zFxNv;;>VBG6aQSv^-1Y*{#CX2c_&MQ@X@aqm>D;l?YYU#Q?b>uK7}Xl-`ZJ6gp*FI z{dzW2@lm0zQ;s2}6m(Rf_^9M@0&OaqN8s|{A{w_I|#smh=;WcNXp zK;6Sfg4Z5c5}4b_dsL|>?XT!Y&MR34MdFr{UvH+&2-VWv5WRA;fx-#(_dla287!H* zNAcIm>4q!ZwOrZ*U4N{cS8rj=67yumRma4K3wAgtA*QDwApys%Kv@2$X;BWzn$ zi*}bb&hx&LRd%EGx!T4A{o2#Zmh{QCPQAZ5jAz2qHH_>Wo%3f)^IiJeE5CDUpYm6u z^)F+C@zb?}{-v z(o_=tI|`=d=sVi`h(`lyCO$6W^zvJzbtspPP}E~+J8w|k*xfF@2qPB z&2!a7Yqy{7k#Oz5V0f)r^JVj@sdMIK9}E}wd^gX;S6{cJ{m;hLyL&2&R{QZ?kl!Q| zD_-L$6!hka=&h>yJ2n}yOw;b{njHReyUXv>5=S3@xOdXD^v0Bc%o?UJ^Zk0lb7S0P zqdI?D9&%6d&09C=wio-ZSt3WDzB-njAFVX)j+a&8B7eQ`@@+eGccz=ph}#u7`Pe4C z&(7(o9iFJska?GLFsrwzg!MVzbfT4XJNu-%)0q99WW) zyncyKpltB8nB#AuY>ZP_#{SKfVV#GI8@_qR!tbq?9(*UbQ`Si3gRfqCyMLRs(C_P-e$S=v+2);? zWB+!}+V_GJX0$!9ce+sfHv5Wz!p@FKStlmkytLWxr)Flxi3uC?=WYs)b#xL+}C z?yn^ZlXsP7R8DKo;8FiR{fFPAIhXg&p0Z9!+WpFesS;`@zp4IjPFrDdHD##-|00J! z4wE){hVI_>TjXMa=rTnmm)BSLqr4tnnd;k=c|yi(9rNsDM}{4W!4G{lsh4|QnBbwH z(zot``sX4wgH4lU4){Nt>TvRVhoWHE@`7L)-bh7vNxvY5HilBJ^v(Z+dm>ZZd7K?T z+-@?AT z&i#sJ4F_7}LuGGOmU3)Lv)GW$Z*;gdIC}ysU(M#@GXh1`EjH#x&t%Pe6YUnt?=JV+ zJ+w)^y*PJ*>EWrhxf7Vu;a| z+YlhgdU171cG}#njvSBH@EltGqWMMWCd)}(Ivnd4@h%GIeCB^@k%EmPchifIFOC&c z6TE(T3b_0>g&EfjEK-M>kq@q=(kkHgAIJq{~^-o$shinOSUCJL}m&0ukw+AGLm z@3>jeBjk%*i&xy6drSVgtvx24z37{_shK+~mZFfk8COxr!py+Hpmf{@G$^JO-~&E* z2eS5$Ao)O~>;nS>10T4Zu29h6I^qAa1c4979~k_wGm2(lVEP3qx{lstzAPOp!}{TW z^1Cy?uYuM;-c>tqzs7cz=^E1&xzdYEVm_a~a`xHH$+J)H)U1<#;8*tjPO;$6)mkMI zDl<<7Up>Hg@{Gt|tvw+|6PMbrnZT3s+TZ+WT;sn@A#0{)-6`3)HU9CTzeg?!l)C;C zwvIJ9Sh#Vsm+)FqZ9`v?+Qj*$;Q=~NRvj05_;iJP!tx7VS6#wFkjzY9LfVATdl_|`BvhWwRXLYgH9=|4y7@00iwftSN@XiNZI~6&QR8!ssqN4g z!>2EdzwGbVbl;ySEUw7J&3z{EZ>D-+pTFKo`2{L0;~_b>19L|@G_%SBz+=&RmvZdlx5x9DkRmZII~ z7n+3|^S88|*Isq}zWRc?Kdcf$bpiqj&kQbR|4~rkr7CA}EN%uG8T(zz_ zIH^|XuIHVbLjH&AAAkMQYc;WQLg_4jsaJ>o3xqiR5%^VE^XGn`!k##Z)>&tiANB-< zYzwyFbF=^C6v3WwX^r?jj@^bIro86*BCPGY*5uu<`lQ!ibN{}(R&df~X`8Hd-ar3; zo%(%~4A1O!I*2td;@tR$oEO!hdGR{N?mkSB;MV7j@HPAbvkq)%aQgpJ;etWh-wmY- z3=GT}kbL;&=GJ;ubAbbeZ;gv*%nWY*JV`I}5YO?1w7L(`>-%R)M(wt0d$z&y+3)#% zDciy(g=^V0zBXKV&-}1j z-s8&@_7?wI1xtC3<+Td)e>r@zo3MtzWqFOl^jd{{Rkx!5`(InxZ1C#n+AZ|bH;v`Q zZF2^L2|Su^N{d7jW-1HGFgdxq>|y$_R#{2@=_Y9<`K9LtIqO)$ER_~n_*UE!6-+(5 zyG8nuz~&P=NgbR2|G)pNW6w9?1GAX*PJEVTRCwGVl3QYbtl8w2a0se6q3)%wT(9cH_ejw;Yi7@zPYo$8>?t#~9~oTt`Z(dj@_^}LN6()9=HYrK z#F}Mh>$Owur;1ifG?;Ev{x@mUhshi>qpX)CEq>J9qm-g!|J60cWh+<9zvXKtB*>kJ z32faEdPB23b+c2e#I=;8EzfHf?)2jjO^V=3Z9j4EqTFe*{z*(f&Nj^OI>p3r%|5lU z#s8(?woHM~^CFvilEqGB2_K42Q%QH(2usNIkRhxbBcdMjnR^%FU}&2I-A|EOwQC3*r}x1u>Fp}%`GQwrm|=@ z?N>9)wJUW=xqM7eaH=$?zq(_PaCq#|zflueG#hTsD0%owJieyxIPcBF*{ioq58u0F5^6mC?JSwVm~9_~A0GbsKzg--d#9t(L7prhpU(l0 z1kOn4EKP~oCu_IKNzEZ-t1G9-IYA9+>Gp}zD;OeTidweq`@0%T4a^pSs|Mx()xgiq zFY+=lFwBSM`ak&P{IgHy&T6^ulQj(tKpKC{Rr|di#Qk$Z_urcx zpbpFPC4bMl{r`67|L;%#9`^pd81nZ<_P-Cu|K6>CEa|?Pfq_92TQ4j&XO+y8Hx@cRFtFQ`{$&rgRv$jbCTM#uZS!)@MJzw!ZmpWhzgb))b(gD~!K^Ti zlPZBVHT{RVxo6v*%j!3n_T=*O%54Xhb-Z%pGy45W)a|2gy|Mm;ijadv0$z*k-F2NO zotS+3yQJju@*Dksda91I3hg+{rl=gUX8vTKohMq~WmgCEU7Yn~wv3BG#q)>HeLiJ( zDadVUI&-4KlgZM9LHCN%;%O)Ixq?b^Psr^%bD|>k(H8bz)=BI8Y)^eQj~>u0}(F&>6*h|6H-zz3j#_=l$*R{`!Bve7RuFB-CAezD~GUPK~F^ z@PF~NsXzJ}Zo4dezR2fD*oC>j@4uNRdSk-9DNVa?oP8*`;*aHeqheq6yGM?B+k{T> z@4ec$<3qixSzL3oiu%kp=ee!nD+Dg4zHJL(74*5R=&&?u-8Iog!e4cbO#Q?85|^(( zZ1%)vt8C5Yo9n_>-*wBIEZ?Qj*cZI$!=DwlOIVY(#$WZkwC?J%HwYeaCMdWxuOd zXq*=McrA!`{oef_K5VcFTPsxXCARrP_VU9n8yB>?E_}PLC%(G>k@x@m^Fhv!FlTox zyX$#BTW_~X9_Q}bvh6oRH^*tnzU#W}HPwx`Q2E7yB$bJ;G@ONWr)xK9FLsGh=xkgT z(sblv*^z{{Bsri&+Su~cx<-*%%YNW#YXvGZtKoy z4qtpRQ@7}-+Qs(SEKKX4UYyu9?e4MCsm9lQ_nldO=uq*b%FgtfHOJ*7v(MRe>zv>0 z+NdJ+k}vkzw|7O!zRRya-gSuk(!Fr4`0L#diniXBU#BU!TgSUrn&Btwny9_E=3V>E zs}&$vGkf*5`X|5QYW!B;lAAi``|>kEQ-e-({Hs>zeRiqW*YX_#EtlYHp>vaO$13qDrCF~1e}u{R z&$9(TZ$~Q0#83Uay-qXgvFHB2ZaUA}t-D^nm$W~q$Ft?ytHQ5oy;*0D^38kZzwO)J%d2GlKA!En zEn%|a*jz#HsS1}CST3B^{&>2UK~(0h?W>c%1T8J*dfVCd(IHzP>QliAhK_Tp?^~F6 zE)aC*+H|b((8MO0LW!!imuxr6otdJ=y0G)A&&pGdWfncWQIR4~QZ|LW++%6e(Xg>; zP2mKQFI^fZtn)%77qgX#^VHdYc2fUXUR9Cfnd;mcgPBgK{_h_Z5y`*LHv3 zG3(2M%3Em$kWnx%cefiiZdhAe|9$)H)2C0LCZ?=gx6a!_-@yblYWDBj=jqd@*Hl*@ zi8tu!>_|yT*%@sR78>&O>C>O5ww^qBa&n-t&k7OHxvYkex+i75!H5422NdQvKe!O! z&@kaZfxv=~{}ucnY)H6hI1ObI=>Pxgf30dG{23TnjUaWi==$W8ee54<)K~7GB$D-Y z!`xY~ca@&s<*ul=|JCLX%vQoC?~Xh*XWqUst$W>%Pro1D|79zsCt9feXwt{_b+Mc; z+P3NFvDsL$l&Hv69Gm%pL$%QG!A0H+hqaGBRTp00CSdbt)A9RiddvB)wd?4yZZW-b zO}Rh5nE!0=o4|s4lP`PLUgYg%pY9YZ6|t)BWl+Yc!;7VNNr(scvuR8eJMvUNxu1<= zeg8(?Pt*PQPcK#CJ96}n_U*;HmFj1GIq-R1?{XOvf#8Qr4;R%G?9adLJeYQoN#Z2I`9H;Sj z_GPv<^Cu{N=CCobDQwL1I5FdYa+1XkzNwy(NuO4JZ^#UsIb&yz(bbHL1rCch7-krK zEeXxoEH-J%%{lrydUCP6%Wr3ji3l*rS$Y>fn|-UM76j+h)Y+Oaz#*c zrLKyaVXKwi^Poi)C)B?&cY6BhI?G*5jLTV?Arw5}{YLp6u~X$1C}t;k?<-JP6<@FY zAucBF>wE3I#bmMZPA{&=lNOtr!UD_M} z>^c7~srinIeuUvpos&QIl&Qb`=&fWHTKu4Av4HF3KkKY^h~-Ef*GxZiBJ4v2^Q0Qy zmOCkjRG+!b`^4J$OhD8mvY?Z>^_BJ$soNL%%ofiN=QXN(dLuJHRWSZ#visZbNAk|A zUYdT(CK|HS#?ZO!}=x3%HFvK&Hd-n6_BU6r7FZp}}*_6~#H zTwW>GXN#MbpP9InM_A&+O3wFTDJOiU74gdK)mn8`zwmlWvA^;P?dr>mI82J-nj!<6 z|FkXjW7*Coy!%Fu*Uw(%3jyj(hd1(uPi$z*n%J*ndbRWHd!@wir+1hmQ`KffsI=T72=j8xBw9I%0U|FL{!4|DN3^%S9H!G9Fh# zI;C-&7B!PNu~Z#?7Q=vQ##fyYfJgOCvM?ow=37aN3Ll4ez{3x9jj)b z``nJ}N(+j73UxY;7;qbgumAY8`;k!Du`kb-oSA$&TKy>FqJvM)_|4vYXU*n$W``R$ zzcX^2oGo0q<-h9YLn>!&3y$UNIjGid$CH?>Z|Mcn8H8nK`Mn==8Pv5w4 zqlbqFSn~hVr%%1Ty+3{W)Ya9sZ{NNpOP1v4=ij(-BQ!MBFEYk0D8$&*bn)WF|Ns9# za^y&8QksRWees-S{)uT7i`QoLPId71i!HCSb#V*M%=3zhOKaX-|K$Jw z?f?J(?{EO(y8r+Gmu~-mi2wWl|Gyym|M7YM-%t79b$t7T3DOJ<9IGL9(vfMe zixyjmv?Md%+d5UUlCPU5MIuq4`u_L&y}ZsMH+^rP*!gY!lsQ`aUR}gqF$=@w`##<_uMA0KQ2DxF zp6}-I#EvPmnsbgPz74y{o*1$z?xLVDb|!r}t?mr@t3= zOBT7tC3F#fK zjwg3-u;KU{rLMGg*NT^kUrt>zIUC0tv~nj~d1k`i?fLQ%oBoy*RLF7|9=YNDbFE7s zTZGy7f7kD3=lq72tp#!dqAGi!@>Xs(&dm9^Gmsj_92;Ksu|Dxr?;(GG{Ezdls| z#OnB!hGtR0oO`jmj+Sf6x#axJX^*JoW?$|$LC5pjOT||gvwd=!P z*Odt;?=4?x6=>p7H`m$6qOeQKsnnX|W0KYr1|+9I)NX-2zv z(~da>2^%jr2slSoUXeUG|D;wovtYD)p@l0?=7STQ^LlTsWo&B_kuqa?a^mk(#Wsig z*N<58H=k4Rcs@5^-_gj8-7_SdZ&gk?(|P~*hGu4uh|^jtiXRg>*{Rs}C%aU3N#e%`N6$HKQ9YgQxJ|lT zcFFU%2Q4K$JmcQZ+WWLgp?-d&#){%Y6CY2U9=}+&`S9gGk|`6^=QjN@jx~GIkko#< zXL5dK=Yh=MJd=zk)L*PRRp@r<>WwGN+JY+^e^{Nc_m-J8BlJ(@G_Rb{eOJt`JIb*Y z#V)wO+B`K?Q%2Gj|zq|b}hRsUyJe1SBdU+Y5u^@_9XrO!7ZnxqCy*#_e-{jTeBny zgv>ZHaUV;rjR#MAe8k)ZZtnk#n}bC8KN!lj*c+^vbN)@oaW;n>8xH+4w#d^ywJ-d3 zCG!6lPnX-3D;q2D?7un-N6%#Lh=mbMO`(^T-MQz{ezfj?yVt|1?5Dde4a^i~@SnXa zf9~8lIj=v>+dMjs8(n(3>A_ahU8!D<(MKv0RHBn7&%V^(Ghg|?7kk%>B=v0XqIG;Z zZ}hzsl@2+V@AfZS)*U!cLU8VV{Haw2|_Te{Wn;D^O*LOwd31`yMA$B=H5HSX!rB~$@BY8+@E52Z{@UU z$J<T~@s$i)bVEOwysKYe zv^eYPzhCj4Zy04Zoe7UD{mod2D;cjumMu1#|1wWqTH8ijRyO*Huq)qO z4}aBJUGCxeE>^1_D(N;f*=v3|w{m)U<5%frC*&m;o|w9)G3x7=PwT4dWtBeN`n11~ zaeAeU^z+u#pBL|Ruo#~%xF@ctclMqp!-b}Nfy0}kZk*mdF_h6~qVTF|*V!uFesrhY zo?m(-cyc7KuqCs{G`_EM^po6#P|ZUV8Qy*PS3fQ2$oaRQ{dC?Nt$yq< z(UFzGwQjH3R*{pFym>wuMN0*$O0Ui6m~hc_lCKc+N}%v@E}XW$ej~So!!mqFQfG-uD(j;if~+Z5#T4^nxxBnvT3Yv<+^Vzx*#iuSZbv+WXVeZYy&^tXJk2j`C91LH0!cN)8+kU6j>Zp{Qt_j!6 zr#7oAy)&`r-uPVX@0v%J9xf|Niu=8tTSRs|JXtSV`uLX8tn>T2bRRKXSsCm<@m$sh zj?kF7H7TysQ^Z1*?X`Q!Sp zij{v}xLK`Us1#zk(79{LgTpE@@6->eui!o%7&mLvb-mI%=e;*{tbJ6lH1p`vlbh`- zWAEyPvM$}o9F5>x#rj%+41Po;-4&)CNDl3-EHm8ILB($b!oTB z$}b)=4X5AEJvOIZL}$_ALmQX;T{B6jVfVa83kyF~+iny9 z?((ZLgUb$rXMeWvO}Elst;>F>>E>be7#Ds2HC)Q8tG}AbUXqZzShjhyYt!*Z<=mD< z3N6irwUW^)B|3#wB4_WXu;spb@L5P{(N7u2uQA~}YAtssxiwpVXw<&7Z_m!%XU%P9 zC7-Oe-NC*8b4N_^iFF}W3SSna-*ZhX(2w&s*IO&W;c45y-l*C7Q&~}oW&;0`FE%Ik zs=QzdVy(Cn-10Y`!DjK1Pb)V6?#>Xuw>Wuy)Y0czU3cc6oPOeC$E!QtOBWwkcB#7Q zdPip8!-@Rw`u1Hu@ULjeac9>XrJ}J~7amVkN;%>D>d|cOiT=&(A7AmZXXo_2Ck6fXl6yHDLbI&in2r2Dx%TNDzEdJuY+kZ7LpOM4T z7-Y*JrZET~gLKc1_lOGa4XNiK_Ownf&ULS6kHH!_^==VWHSsq8oc?x;6%s&|Nlcad^ywf|G&ZN zWmxTHlk(3-p^|Bt z{F-_Hju(pj%}a_+d@6qWG(+FF2@W3R$*GfezhBS8JITdn$^Ez^EL<(~&4hJID?H9R zCHySEuT{3CyP$$2uf@gi-OSAGRqgE(VxMkIHS?_aG5PAJFb{uaeXFv*4WG+ns%#A3 zWedyOJu(bDcICm&X=%O%DV$+ncfEW3wY6Q_N~M@rq4e($-}20vyTwi3O!(1m@4IK^ z&E?sZKR#cz&iG`)o`2opaqZtdx_*yprf>QE=*Kzn^jq)5AKfYS+&jxq@CpfNk323o;*9{=(L*K>gmgCZf{)Ick;Xcx4S$1gkQY+w0Q1kp8{!?MFv`G zS_&l$;&*Z_-|hQ9*7#p24^O;S<tfEH-Bk>} zV$7#Luq|q5QP@`T;?1m6fxjOvG5pOP-e~`tgXI&qikpI@D@)wt04*8O(=qGUx!DNB zzD-jy?j+{FB`SG`fmlysO{pE7%$d8M+Lq(>&U9;Vdy(v%7rs(T~tcE{(YOk-q z<#lGR%%VIYnSI}DSSG}Omk&H;VZgupKw~+(MD~*#VQX|b`}Sq6G2>jkr7ouV@-((1 ztNfb9-Sc)=ow~8kX@YHN`udK?k965x%k(8Y`AT#vSMXPfvEODq(OMI2$=w{JCcpHh zuodsui93E@l$HuU>UOcbV1xJ9M>{U;*(bL#PPkq1=HtBq9(D1*%gb-%@QJ&v)cI(k zvcW!4Awj3+oz0Vt3Hwy@JnA?6d(G`V zbo&x#@k>cv*3XVf*&Dw&9!U7{{-dsy@c)yp4<;@ZH-0$b%Iw4)UjNlog{w9ln!Mif z%NoJd8{M<24!WH?dSKb2FM4})w>D+JT(KrJx|jLYir&P;$16%V^wiGn+`Qn%zO++E z?6<$aXH&3bd!oTB6ZV3iPn5pjEBY_J?C0?!rP;xn`V-0-?E^$SGfn0_FMdAbw9Ouc zBl}lqeE5;N(MI)n=OJCK4;hhqUle$id{!Qhee$r~LiN*%fo^5MIH$n9=2O^esud2M4;S|6$RX@&HLEv<$^QJ+`r=CIl89ij8OPMl}Q;Te%% z6+}4dB0J8M?{iKm;?**_ew}a1=ZnlAbX2t>rad~teDP{(ZIQ1U!#5`(9bgzc1XwKFR;GBV)s-pA}n<8p~y*@cAX4^>yA`y+o@};nxe1 zl^U;^?-%~r(s;1y8RLo0BbkdousIH@_-XOlR_2(DMRNL5fkK}7 z)d{!l9UtEKB;@T_*=eNAKU1WWUFN3!rSG@v58Xdk%r}9v(qoMei(5;C_p&)D%4IBO z`R&GL$uF#2&#P8k$!1(BdM;yT!5#RNzPQx@Lp$!^+&l&nn7tkN*Q4; zKNp4Hyz*L7xGd9Z=WmTg>Ce|+{41?%(EP@Q|ND!JEyorysjGZaD#^NFka<(tMOQya z%*0^6R*-eiB$Xv$>bjF87w=xVqi(I64|9cykcX^6#t7y=GH8eb3ai zS1*!(uCn(3@@`6&MPQBUksZ}fO!&Dj*jAsJ=e=s{lY>uNJUW-J7d)C0=lLXLUrK`Z zZ{5!s*LKAGQ8P`^wlj4{oNWc91Hmd8ohfHDJ-TPTfr?a-0|Lm1(kCPCPi{}&z{n@_z z%-w~tkDev*&vQ9*_}{0NCyCSjIM1Xs<-fnl{ybc0x#IFd%YP4T^ChmFGk;j>xaG2n zT;w19pWFtg9i;YLIKB!?3C;e8m=d}OT0%4AEDD*hk|AdibM7LB91voHF&J_dvE?m> z2(siZs#v_X9LIJzxVZm>RYE08^5(Bmsa*=$EEhgyRmI}9R_)7OdqB2`*#>knFfgcr zi)ROcgp2&1cictgbn`<92zc6IMDO||Gx(x{xA4{%OFGW*)#?Qc40{A z{C3vQd5d-lyPwVw5J~0ce6q?V=l*}e^h~=;t)d(}Up_>?`mz5J z)t6Xvw(Pk5$8E30lFvum)E_M>@F|EeWlvlB)Ux16muJKQ&Vy3tPfm>f5T?PgU1;6U zB}q(d^)rRH7q{&{Gw=I@!xf7x8h3uM+jCL#k`Kqk!!~Anrt|hVta7SZB*rK7YqoH{ z#X*D0sH}@YI?_*OXe}+<^H5&YTT^n+;gnUIoc0LnN8?KD!kijxa)}GGG*hBM|oK*ITqIk@2h*b_*Hj+w&X#ZC1Nw$*FG)UGSxtH zsguW)1h$D{v36}u1wYhg2+dgKb3mSFQ)9m4BUSU%zT5h|pK|Mtc!@YK7YkkDXcIAS zkAtB~sENpvlkqGYEIJhpJGNA9Vf-2VO-;B_ST!z$v*hMSaqFr}H+^ocNG=HM7FTUH zce>|Pui7H`WPPud^xVah96p?UZg1H%;o8kZZqH8K*l?oVWreMT!?IFEs}qHmN!K5K zXPMwF`C0#)m#UceWX`fJ)3RdvuGB7ZIJ^B}lkVCanY99CtEN~MS-d*d7wcMG&?3>f zQk7>?*R)%8W?Dx?I~k0Qayo9Ba?qgD!62x6$BSJDSa*KDq2M~RVRn>4(2EJ%_g5ax z{wyI6T7)Fg`YPqU=o0o#N4bw@tQ9ZZvf{bGlAF1FkE`DS0KtJFPUAq zv*?AQxP;hZ2_b>H4F@U=SIu4(y^`h8Yjw4yaYn`-A(we&1i5)cRaRwn6lC!z_Ec+c zT+8*yQr%R7{jmu2!zRzFM{kUIxbAlFItwf{Y%a(9XDUr0Tg6(m(wYw*@BJ?kJCpt0_Na8Pm22J}Z&6}pZ*|c4 z{bR?vcXJBF7aNw^ZTuWMjXCJ6oy{z(@H0UY%+eM$E~%|^Th7JK4JkdOR%WMlu~ThY zTLp)B@bk*f4PGT(!7d{U;6r=tomQ3PtI_DmYII;9C0Vm{k4XT!J_ka`s65uRU4x{Ic05j8I{d-W3k)U zVs>r%0o{vRPls(UOJBUcuP1xctD>6c#_MMPT(rSl!9_s3*LVVVd!W!T?~e?i-dOz-~C}Ae!Qi4k&F8&j_RvBxox7){NM69^u?PT z{-Wio8;+Kq7mF3@U6%PrcB)rpU4NnIqpIVHb|E@9-+T=0{c>Vg{rr>bp9Ohson7Tt zo~OF=o$2!rxx0Bktb2EspK0obVrjljcaw_0h;uAz;a%*vZD&XOw@=3J^xuX|dwWV9z1Lh118x1>byR))yaOPlFdG)bDch**=Gc^s?q;GqfI5{;x)%wltO&6;zeNMXNs}|l@=wF!sKQA}AC`jO^ z-Hp>q4i+lAUVQ#B!Sm-UvqrBc`uF13G4JZs+xqmyGlfm(B_b1od!yYOdj1_arnR&u zbnV#?|6-4ljJaaA_vUP5fa)&kEL3h(P4|M?`K|IUN+O-2p7P3$7&(7Tp$oiA8MWbaKa0Z+w60u^WVL+M)29L1KU}- z8#P}4Yn)f!&~~;m|8vda(v?D-^8l_)M$<@uG=!t?c2>a}GuyZ$G+ z=Ox}h;^0&eQzf+aq}YK&f1?fi*sBzGMOO%|J_5&JE3{`{250vH zk>-mD_0~VntGP31Z`kVhI9#EG=W#giqxIq`f2VGY4arFmwW+$^9=TqnnoWD-+h-Mr zvU0v<#7eATy|(l++qGl&|1kYam9u9w{*$)qDwlZ@mPP<;5;2W{E@&g*HMZqOFS8Bb z<`}F?a&3(X+M4WiC)2Dq)_-Y&$ASdUw>bvK(rn-67+lS;c$aJVB-?mqy!X>=qwhQC z{(f`~bf)zG|KATR|2!@G+vdqXPi*}2^wz)cU*6YwecL|s$MKCnFYf>Q?)k54M}MB( z@nvz{hmP>yx6gdvHBa!969)qWgC3-D&~RX8z=r=n66XE?Z~Xu4e}VrO{y&s|Ul9HN z|Nnyje;57x|6lI^|Nl1+{{R2q<~mba69WTFB&3mWbY^GNW*dQ4;RAjKx_24GlO~3} z`E~#Q+rRHl&8Rz2c;P$Oz4W4U6WTQtx9~N6n5wbk!mIoX%1JXK{xVL#*2io3FF`~2 zx62`4r?0Pl-WnSxo%!!^M6bE zG|B&Mq~Jtd`HB8V;(TWutF~iX?d!q&hCO`x`|el2KAkdqpmdW#$@urwC$G9J4FnHP zV7Zczvpa!}!_$vfY#aAW0Y%A=TbPu*RS&S5Hn^nZF|{oh71%k!X11JSdpvGEOgf@Dcei+)%G*NU7uHjYUrQHG zbbY@j?~d@*<}Dm&f2D0L6H-(B>gD-Jp2J*FaAD#8$(1GV)yxkmJ^S-e<=ExB{MWv3 zQktT6ce=;M()b%EI}0X%TVl3DSRm6}^7pi?$$On5CyD#}37xkw%Qh6Waz7Q4c5Hv} zQCAzS$4`=_9#65k;^*UX+1~Kwk4{&wI6gl=6}352g+)3!p6&S7@#e#&1tL>FH{6@> zjHS59ZdH80$J;*|J%Wu>-tqA7uQXb-gGqk2!-5?>)fozI3w8)~KZ&|`cq*5IGRwE4 zsVNQadK*tjn10&qa=Lm4Z)T<7fyHWEM_d{DOB?ro@~qw=RP*$7i>=m|LYqln3*5gH z{)xJ_xTXHBuZykLq59okRcp*!{+IDSwYk%HPm*`Wwa3@C2K;|9{fFtly-woiiJJ^tSH^0q);fE~KklBKy>!`o zmk+@^=KDU4s#KA;ycfS@n|}za;R62xzU$NU1=?QTPS~^U9&1y6IP;a(*w#NOPTfmh zJSkl8`G}H|Yis2L<<1AUs>CJjCNZqkjZdlDB;PGlz+a=X@xOL^)q~wG$)ykF>X>3$ z`a~Zn8Va3#%vklK^T6q(k1rDV?Jd7-j9k0aR)fjKOufDOf#yS{FU%?Yj(1}c<5gG^xD^iy^HqwFbKY}yVk_!vZ4CZ`|c|p>`xylsVb&qM0}j_ zi?hXbm9pcEooh}cJ4!@#c1>Xs()OJAHt-&^;7aa0%wmkUm?{{QD!fi+uy&m2KkOr- zpk&7vbuKjiTl(=rg&7&^j=1!xXBWIDoyAQI@(oMnz{-0cSB}QY)+T=Cf zjZ>K3JPF!$g{yt;*|OGllQ4@MmD|k?Y-gOmrUgE}98tu3CZ&GW>8ouCN^4tAEba+7 zRIyIwq<+(e{bxHOJq)iOT(Q|#BEwY2ito^e`MjLX6^rV4*RF3?;M#A*)fDmHt2clD`u_j_|MT}Atvqsi z;+8#sFGV4?J{*zXeEQ=1FJGY|M-=~__x<;J)8jYq{v4A2_u&|be9-y#R?)v_3;&!n z`g=X=&mrmmKOX)$Bt3K2!9OR>|Gij#a!WNo0|SE}xF}a}Xqa@MK)_(bhyM>3BwX_U z|L^Pn|NlQ22rT#)kg$H@g+~Pn2OJtQzuvUn^&bM{93tBU{{O%Izv$nd{|5g){0ALK zx#ItU|I6oWPLsA{VBiRb6!k}DJx_XMCD8gbZlzh_!pD=o{X4&Xcc9nZ}V z`S4sbT}3j{zwh4>?@bwFWXbamg})>*}1k= zpLbMd$oyWt_3gop?f-9R+;|~1A%??NaCuwt1is!In@xU7KH(H@y{vNBzKZGQ$qzAF zH*J+|`k1`DWD^(6VP)~t3w`_Hu_wo>6x;0e+19pi?y)UV=G&G3DC0zwhGUb-o&x(q z-6^lSa(pZ;V?S?E=G*n|_FD-ZMxlrkXToktsCm`8C1{0i^IaNrS)n4ETd~u4Y0x*d z*&0vY&f2)x>)dt2im0d+LSK09E-%sBwc*pZxyL?!)2p}E%D89we|urmYUzs;=34E% z(yHsfYL}(ov4os=sxQCtUYPwLV`uM5`SM-A`AY1U+}YwXEn?BWS2COYS2=F!+4S<` z`CXUwdBc_X#M;zXP3YdUq393u;~hVrU)d02Xq&GteT{K(-ii&iSNxNvN$;s+jmpQn>Eoi&po7oK0Jj9n7*%b5rI3D=eBCtAq_vP+~Oq|?%9j`I!GI=b|WO%Ue z(l_f>k?+>clk70Nx$N~sw!HIqwhOPR+vfI}ZSnR8;>*75smJIrEQa{ax0nUD2(%Cj$bH9Wu>|@6nq6u1<=fN4PFPd2Wlz1sQY0 zEer}7w=~(iHoG(EUAA*8s5KTaIkNkm`trD??W#=EE^%wh)U_Q`_$n=*V-WIc-sXG9 zBDM3=C&zWlcm^2w;W#brDA69 z5eAl9L5?4GxvuXE(LeS1Q;)XDGldIP%zZD}(*0#hc7?55W9xrd)^WA}+{bH!4%a>S z8nl0MuVjhd7k~a+g(b_UWr#lR*kiK!M+krI@}p{VH}{H7W#i-ckaJPWy~nCM_-}1& z=!_B@20oX=_nIrG_i`vPo@(>o#wRT!zI=C^8(Za{JKE=#{|z=$UR-xq=R>^BvUrl2>JmD0RJb&;o#(cCU6j}%Ly-_Asf`u0He74s%DRy5#_Z0wzuR;* z>rO`luIGZQuEegB=uj6vcH>RO?|$Udat?Ac&AI#49T{)o}2b)bnmGW;9ouen!wCUi4$%w z$`Q#(yUJWyFk?X}i>#By3a?bdc$*G)o#ij<ih%PT{)?ZjZa*I5eK^WAbVs{wgixA5ZEH<=`Q^{ORvWKwT5MWh z&i|+}Q2O!n-rcEUL9a@)BMv*gd%jA!-|2^wT!W;VcOUP*Zl4q09bt{mA_vs9{T**r z7M7Ls&s@9oXr1@lEnJ@%+!d?)uFbVpXWx2r-PUPNuS?S%rzFZLh^jpLq;O@e43n)x zQYX*JO+I%|MP6t*ebgvX*1MyiD&(0;_;%qZ8*N&TPZZ*P{_COALOBVooUWAPqN|q+ zDe}*HsJ24D%82*v8s7=*4{C2O`KHWn-n;A2p3@O`x81g%$8Geyw*C z(|xmMz5L_zEcX4J>S~6vP7%vTuNk>&PcDvhbyQL~_QJHHvLVOu?qbJMmhL6XxqgbU z22No=ye`Id-=CD}6FDnwH1FR`72?{oaofKH9{vxr1w~SlKa|$+-zwj2d(86WAEDk8 z%k$Sfzr8*q#;)#X<`1K$WA^iUf~Kvi*yDz!k;ip}i2gLA7qpRwIopX%7pTXOLZ@{yoa4uvskok@~4hNpU$~AtQV_>x9I+(onHpf6?)k&kx zSKsCsyva3GTXD>4_d|yR&tK;nsjWDsz3!~Tf#+%~j+^bc?Qr1vtU!Z4KLfQD$3ST1 z@wYh!`Wr94%`vds{}d#$;@JL%xVJe5YAcUJxZb<(WUt=&xX>DG$gzfni#1mqoi(*< zeOD30ZDHFk_#Azyx8g|Igs%L{Zz`_6&Aj-=_0Wrp^&zEK--euc+1FJYb^2ApnODi@ zUiaR6U%q7Br2R*>&h4DjQQ19X+QBL1$gS0i#cQ`m7+y*;SRZPrvN~)p0|P@Iq!HPW z@PCPmL4m;j{`WVJ|NsBrz+nCV`wb5B72Y4XFEGC#vElvu|NZ|36b|11e|}@t|M~C# z2mE*VKmUBe|MUOX_x}$_aM=I<|Nn%5{|0~lJM{nmuP`6f*8Kbb|1S_-{Qv*<|Ns9B zJl_@2`oG}1>>X!DpG@nb!Jkv5mk{b`HLH`)z0M-@SYH?$f{b)1EJJ7WOm$ zy5W;`oWkCjJIjTBh;Pif-DuCyuBi8?%tr0Q!}7;Qjtr`TRolc5>32wIZ#Fk{7IKdl z6q~l3dE)}k*>aXkzqAT&i}Q$za@y*|vA(5ArKjMF)2R)s&lWlDjXdd~_A%0rPJH9!5+>rQS`h*7!ij{#5$|~!l5^k*M zTYcY<%QNMs&SJM-#Y^qSgs*WfnSD0l`u}}bPYC5#oXN>|(bN5~^|z|A`;}QLCNDz7 z4_sU(zESAf1N+GrOK(M9JU=z$-}$-&2UcABalt?!a4%1%+TNC@T<-lTk!D=YNjYNmD}La*Tm;^y5V`wN;^MfhS~mIx6FqYw5dazW%^xwsk`4WCH~; z&l44)wjVe$4hv075o0@Sq<$W=FhKE-Bi*tA`Ls?3wg|270!+BALpGUtKRdgC=yo>VlO zuUH%KUQnS&rDCFXrmEjGQPs!BAs_vUJ2~TCxSwG0@bl!fm1MSfZNpo zA2AMP&V7p~dF&VZUY%9FDX*-uQGdPD^cBI$n}0lcSTRw!U(!j`cr z{C9jY?yX7Ytc#eot)`J_ef5%0ysdX8^!BJ$r2gG=Q|-v_mm6Q)VPE%0bJ5pSgM;s@ zyZ2Ol5ihFgWBq+(s{M`!)kh^Z9a9c>93w)@Yn;H}i_%O9mPvlf16j~t*8Hm zHGPNaZrjV36}pn54`#f)d}`0%ui?^*?)k4f@O`I7SbD+gZ4a_sdH%$A>}XQpSuFAH zz_zBwy>4@7e3&RN@|B}lB{xFtHW%A6t;a`N=Izq*c^q)Sb>q^61mRebim$IH72KF` zIlI|&(jtv-qCT~~Q8|fBT(Z0C7KuIW{Jea}?ay*=OkY*0864^7l6~&Ov{fU-Dk*kSn;^yVA8?b-fh~OKD;(H z%zLZC!Xyu}SgQVv%hnI~B9``bGc7TgX|+e==l46;XPgvZSs=CDg8S;C14cIk4K@^| zF0KsN8?&Z8L+)`!z?6t+5sivVF9m(Sn40%qIvx0Dn$Dkji;}gvcv+c4d+c8>h&mb}SJiQ~@GR?4$}{_*)^=r8M-xVQsT9w*9s za+$ds{=0Pk=wers_!rkbkJl~I^pfXFi;lnYXSKk?wKJsc@}|7vD_g4}QOn!^pNpG6 zHjCjg+hnI{EB{x>ZIe^|-=@N_I3hpU<@k)Il$pN*433KC3j7o^7QXb6N!CAeX3mk% z8@|r{;LzdnZmZ9=g^zVY8Wv4x`n}=nM1h}DX>%es^l6vM@QXj4xB1%bq=SX7HSQf6 z%N+V&6>V(z$tdc2$FZMl*}iX{9SI`B!gKoyZJzM$d+tA@oaf*+IZL@?e8v}F?~rBc zvc3`b*88ADz5SBjmISAXwu@W4AF;=XEId@WapPM1Go62U8qHK$XLTFBO5!RCypz8B zuVG~5RGIZ6&F6h2f-eOgIkSS}Qq!r+{qi!-8-(pYIV-$8#XVm5!O6_nbaWRb8^~z=KO3^>J%Y6i;5~lksIoX41qH6L!RZ%-&I-u&ACT z`o!z5Nk`IL9;me)xu$(C#J;OkY*M!qYh~7odzCk;EZiNB`FuGZTweK2gI{2ei9(YM z|28{5pBWXtBCH`LHf^ijUbU{yjJvt?#=IAXp{skuLN2Yoyqs5#yPD1B9hcyZD%JOI z?YbJT6)}gz*!MPVTHko=(wAM2XKbD5s=DsQ48uY*GwG?U6O9rxw>*=)&`@=MRc39< zi6bAMNmWK3>vT(9_ew(e=X{~?6=8SVZC`f1sxp3VWE&-~9}vI7%(P}b)5D#w7afiS3BUwcm5^ooW~D!Q;zwtv3otVT+4q*h*9a9 zBl9a+#pr%VpT!jyD$Z7CuQu!A{{7v^k?VY>t!l-)hM56e{+YFI!Z~FJT<&E(n&<1+ zQ6Un|wsQLAUlxgK%<7+1RQ}lgC|cwH z`fkHa8;Onzzy7|yd)yNjPd1K?ahw@>oK^I7sHOEOMeZNJ|J*kI8|^W_N$cQc$KiGsQP>!i?xS zd&P5@N*ZS#2w(Z&?7d67ROS9?&2yBm>a}+CWbR#?dHqoN(YUvtns06F=TnN1`o@;{ zaQBfA4*8It>w6j_f9O4Qj$OL(!WW%&mCE&hm0#S8(S2^zRa#%N%Ph70VNJ>P2Y1ii zi`mRLWBu=I51;<7JNep)y4#b`P;MW;t1jXv{LKgEnTrOwjq-rS+{x>sznZ zw|>ocxuCUo@ACBDZ1|H4Jyp&OjEaTD-b)@fu{2{YqPP;a3e5%-#9us8y}ur=M-lUm@=%t@?VdbBe%N9vI z30gDp?bV1kJQp;l+R0CwoVcUc);~)o?Ae|5(;GytJ$-Od>~=)nvCj53;b))ZC+`+| zzu`uYa4-|&>WT@IuI_X+xuRJ1B+=_zT|w-t1zUAD2%kDBo@4+U}vM+t-hd1v45@3iweFL zu|KP9?)3N!;|YCVUqzo^&fSI1=O?ZDXsu`v&YjB?^zGugfJXb4jJ3J11+?c*Fq&iD z{!5pcG5Lh3MuwHkw7r27b!wh+&N$$BRmfm#bl=)8=JgpF?Q7O_WqwY#KU3#kApW^q z#4EX9wZ=%Bhe3X(zwy*Vp_*GYP8D@5UbS=G@`o(*GV+e^;&D^e7Zhif>E!U+5gov_ ze+J*r%NkydD;7oky8q%&wV3V7b@8Ukzt0@y-WbPjCH81(!0|;dG8C6>``TPTf1}z2 z5$1Uwiqo}bY*JG>u9nIdzCz%wvoojW*{c#_PT!xm6@Gu)nRDOU@q-g*dO*Mi+qYVe zTML~08a!5SXgF0i)pLn}#l%OV%Il*v40Rnl#W$s=`%UoCb~jt#!h9w~<}6nRU#APZ z`l*nk6HSaBTBsuCu@5w#f-T8CO>)-k1@7 z^;q#~sbwym6Rg8)XKc_vxcg%oLkWAa(ADnxg2h4mwGF=-3Yw{}4AFNGGg@%OQM@=u zUe@V^{Z&`aQj_#`znJ9m?mE1Wc#-616}G@yt!QU!zkXIfYFY8;&r@ouS&y~{ee{}9KY1AHV9F=d1iL)BpZ<-MsSu|B{!k6V>KwRA}&9v#9GL>)yKOJOBUh zZ|&V}V{vr~x3>5z<@;AoTrS)DYtq&z>*O<{M?$^)va6TxyHd_v)H}uhq{97!oSS?- z&(-)z8czy-GTV5u$j{!CMy4#a(`Ia6>le;4h`gqe=vc&>Alv*u+G>+V~7{~Ug3IOX@GKqu|>lh@@l zCi`u%+kEYtQbe^{`O{bXzJEF}RfeTWW4fb<**1n=&hPtgbhREo@XX=-Z$UN3(opH- z5A&vo2&Bwb*|>Lg;CHQU8>gDiZ(qCPn?_U4lp|Y2Q$BgjUO7i+?a!v8bER1wC++4E zntjKY@t-}HT9Cy_xqV(jf+@>Yj+QK6aiipTcWPu*@EOh6<*VjzxyAY}yUCzy#zL?E zCD!5d%)&!$G#}Z?MRU$rFx!b=RmL>qm5uMwQ{Hc%##k-MXExunkhyn{iRg(BOUs;; zcK^@h-^lIUyR3Mk}xA)WJK0o@u*XH$Y zw_6e>htI^CCtp3=;wg0J_lm9ajgA}psWPlGo}=tI#XyML`byr7jq{2Q3v7v9X4L%l zg8EO1w$J-V8 z4HM7WzmniGEbra7YGSsv$;Qcgw=7%k|ag<@)}Np4CTI zoVvXzF2eD%fAHz;_H4%5iWzdZ_|+>GU1Z6ucNRaQp=hyu>i4{lEKLEr_p>#!gnFDd zIyniMrUm6Iyg=>-(UV)G7Sk9ffO}62jLs&1@PDyLJ3iu8Snv}n5d~)|!)M{773cfheB>}S=-IOobxQZBOZI*NH`>J{7 z#J6kNYki+g*|fxM(|VyvJ2=kIWO$*h<7;4+W?Pf0)YL8IH6vlI<+NKYPR4rfPbcy6 zUMrDdULN$r@@)U_GfwAB?r##gb^UkIn&uBv+hp78E-n{&7^`)+-ApS{NWHO0{ZMs) zR&DZC@6O3xvN7jE3w<`2S(M*w6zA2ybMN1z2bpP)mZ)3rX412Nb@;_^gPVI#KHIVN zm;FA5!k;p6rE#Iy&QoADBc?SJ0&NXp9mqoyOioTNC@2UE106tc649(&C{n(YinyKUd=fJKT1+HB|yO8{{Qvw8xGG(Z3@1?z`)W1 zX@Ms|qQxG&;%|ucHfL@Yskl-2YC;MBMrRX-6E3U|7M9K2v3O=)zv-7t?|w`;{^{4h z)-~TI9e+FP<)Xz3Jgv*GOp9VM?oR%j)-qZIj*(;V< z|KLrz+oyddCl_sLxcGji!j8kz>wmCY=Ct38{A<6+UBzkYJ7Gt$|8sd53|j zjQyIPgKVau)}|)O4yX5!w?2GFr-s5#n z{wH~7T2pjD>W?(GKc|ko%K2n@Hu>~}w^e^iC&*h|3!S@C)zfsAWUX-HRzANg9B*!& zIrIOh;#te42TK)9cdrx@L`FYi`(9$h>DhzjKWgmO3kRCg`qItT!F?05B z$(2u2CLH(qeb039-$rgmg~#`fhHZYmcXfoo^S^AGEeZRZ?a`mu~T;Px1EU}X06g!{lyh(w@T#SgS}Vt{~!9qy*hKsjWY|1oOLGd z=CoQlGxCnnR_RA3XPtFCR#luhasKWOBPV0#doG%@mgN_H=lDP8KpV$|%#+uB&Qw*d z+x6acMo@vi^YvQ-FM1ia_t<<~wfN|&d3%b3Pv5CbYdgZ0lPmp4q3!0siKnB)m3(v@ z*&^S4Tly)i^5)6j@}}xQYU16I+FciGHZCJW~=b-pPkd^ z@78q}cy7qsS$=^h=7(>K{F$B`XU~Ot2z7^+4SJNj19?m3BiyIO-=4RBZ!ycnVnch@mpd-rHn0miadpPR z$F&dc+U%~cx3`3WpKNQUN;niM9RV%rU_iUKj)$Fy;*;qqwD>HAf%5Wl2y;`sRcUGI z0W+TcU{qRK3Sr!E7QNvtdcvB2zZuUFE1olU!Vr=DW;~Z&B_HRC-F^SPw6yesozM+u z(Y-LRdClsXGiP>mbW~MUov{(P@#1}LLCy_l(T89E^-Y^@y>^%K(d$a{*UPTl%({}&7_scZG#yFizzd@p0d>`9F_U-rqp{rOKj zJp0w7wZcKgp_zH?nM)Xb>%N_Kd;H=3?}O4z<$G65G5Bz!K7UdkQ~6$qEs6~*nR3@L zmG6a!#7}PceNbAi{pj|)pMD>d7N|dX@a12t>1XTrJz^@~>oM=*-7o*HfBLuU#h+7e z|89QzhpBw8*MdvE$DUn&|EFNeAEe+fSX}@%+)bPkZuz&Q|!}&+vDuz{9Wq-khKRW3ln-gQq_n zs&AY;=j-OECo>(7r+YlkU_DV7kr`=yuu}460ZUVo;qOkyo005Cqb$EQG2KsQyM6KE znfouILL4vpah!1Gx-hNv{>%4IU)e8oWYHlc&KU*vExtsOf ziT-n4Wq0pBczI|4`%30(J2zcgIOXQiLyf!)g$xV~r@@m}4hB;M0M799h+XAwLL2GaHa|NrI3|Ns9FvJgotgxT;W@AX3l1`al8YvgM4wq!$* zhKI3B%4Xl%mV5jCe}lHL1DAIEEdDhYKS`LMfFHR#9*m;I$WOI|dG z@a^wrnH$hiUw{0u;Y97wSMyC$q)Hsw%rmB1P4!xOMY`w1;gg~-CUN+k^v&{eovAC4 z{QA7qgx}6dTlR_sl%277z+UWi(Nyopk+q8@f3&dIX{$G`!g_@BLr_HjIy<=OxI(h0Bc_a*0yssZ?GImSzDk72YsWG%C9%7=?#j3;E;}2~ziC;hVhXq5?$?pJnV;?(AMm*K zvdY6<^ZF~hOTq7TLtfd=RAS%_d8w`NcTMo+B<52QEI(gl{?V@ZBYlR8MPcEk*&>z8 zv-uZJQT`k+%C6ly!E0NG`&)KF$wyW#MXCQzfBvxF=}bpliip#(pv98Uqg1k<2)xu+ zC|!G8;z&=K`t;J8rrAjfMxL%23Ma0#^IvXlkj!hCdm=~oH1o{g$NrtEmbzJZV$~Lb zNDYPV4I$FrXH!Ljbk-YOyXR=N=9F?wRfdmC*u`YtnrTwK9_ecsrIx)|D0)LC^y?`G zLBsiHf4wqN@Lq4#t9oJc#*-6Y9G2xd;`iii*n)#ML}qN-J6TsL#6-%{AVH~V%i3?h zr+2SQHApqrZBn%G;*|XROsZ2L?7)mG1yh78+dnX-?meNLX^WGmiJ#r~?)~|f(~r!Ud^xx+g8zBX#{B2E zCp>GCE-I<-7c;oWof%nsW5j`{ZV~P4sT;JN*-#DFl@%HYC+OpP4nR#=R&h%;SJrTOX;Kzp- zAD65&csj{K$7O=?+7p|XH|$YW>YETKW9`XXJ+XG}i4)1f`fsnQR>(Sv94)jr(_6)} z&2m#ra9(rV^k{MYQ(yMz8Yf#+CZ?sOU74$Lxps4UdD-r>=6dzvXWs8F|DLC3aqHAE zMNRn{#mfD64qj0A-5_{kWA=|X+&A4P)YKo7=6`&4`Tyht44MiaiZ(~Py1H%qwyzfm zoj6BT(#<20V~I*!l$v&V@VtFY0uuuZ1vnc1aI}PkOZj;#l<@^gyegAy) ziQk>8+Q+gj{ytt@$jj06gmG2OuUu1}RRu>9eV4tAqgJkBM3hKG4PZ+36^v3L^m+oE2fC-=8)dYdQE&=IdOU zsv5*HQ|4I11k;{IW9JIhiSw@QducRZ?0VZoufrV83CsdFMYL~8UvIm(h2?@pK+3kt)m)=-CRw}LJ*uXEjZs*h1jKeb`7!xEHy?Y)~TrBT6 z$Jp=i24=}=?cVt%QD&O67a8Y?ZW1ULk(pcAJz-MhSIvi8jMud#@^4CT`XITTJyK(p z;kxGinPQ3`jf!iIt##^QvU|KuaVn$s!o(Y`35gRK-+>Hdcg(8SmgGslW41&+SfzB! zw$BDXW~a$F{ZvzYogZ`mqSD;L-2z#uPHWV~ozm}Ewakit7a}ItR?A^-Vs_(#f#D9O zb9O3K-xOz0@I4{FyGT%C{ok|Ou}m(pXcEyMU}%K)2N=Lxj`5KC`uaj4rJ80o`uh5; zDO2U0g1KYcz8{biEuKDcZs?yw(s1wPy^=ohkqZA{XOpu65l8D zYn9UX$(lbGs6LsHW&uAe;{N}-g!cmH=Q=3uPxud79sge()RvlW{J&s-zq_eZgT}+fY?#b9V zJBAjxaV}dNgfGxWj@iGmaI?FdR|MoRsevqW+PB#5}r0sW6+choe6Qe@OJxRgC?1Ddy4mJw(e&S&0f8w#>3EM)qgUtIEA(8-jVq>-)^4` zkb4x{885{D`q(n-ep$B(F02O|Pu@(nJ}6;g8u{QrUU5>t^v)?gbz+<3H{aSLw&Y3_ zPkkT%ljBdS6h2Q}%#+e;9c6nVLuFQ54Aa461@|*iM#md%IiJL;6dzp4B`n3!za)6h zstsw4A3T~8jF{C{-(7dSc_xS2R?S~0*512l^lQeyFI_ehiZ$2TUGzE`89nJ{vcTGX z3vJzuFTcIh$+o)NZ^;$Lu8AIb%#A4vISdu$oCK4cY?dh9X{mnU+Hj1$XRXJ&y(t?{ z@aRuzY+OC_!mf!EQ@+|IbOq{Wesa~X+wT#Q(<8US_Jq0HI_dj@Z^H`z?Nus1S(sGu z;}!qh&aN#%Qlg$s%IW_XXiBmdy_7dQXkDrDc3EL?<|c;N>-E`na@(+|74hGTxEE|`mpI|cT-L(I?K+D#E3pPR z6}A0v35ryCpOeUcVSmeY^`HO$xE~MyeKWfGh3vLpSV|054`NCT*pV`zER2-vk-5LI ziND^gw6n`>VTtR+G@skcG+SeW&dxGK8?d#v(rwEH9Z?n+s5Pxp_2fJSWChYkW>&#V z2?2+K2?rkh54gDSV}pT0!Uj<30$PmdAU5;=|Nm+K|Np?c%WMIot*)0__aL;iM&(Rm;d-S2x_v^f)uAA6ZKOUO-_;e?IvYC!Lw?HETZnW^cW@ zGiA<)3o1U-qLw5ua2lUncvHvFn8D{l&Gz61-}QHsxMpy^P)R5yl-v@~n!IP?)X9t4{C)5FUP>|!TAS%ZC@X+b5y+h4$q?Q<`uMZS6v;Ct%{qzmUtf=&z#@5h#>}?u+df?l zPdxfmJNiERk=4_-t~tuS#rv?HHfv>e%$dZc^99528DzaFJa3t2^1XX@82fyK)}U;jdUZ z@6UMlS2Zv*d_wiU<%i7q%+89%-;DKt->P@N+(|&F?(kf#&w*SQ+SKplE<9B;!D7O- zw+{QYLzlU@vCTcSPc?h3kr&Gi*M#j`gCrSucis(tQucv!+MC*zm$sj)X4<^?q4O=I zjV&cFFR@oPzWL?KGn3x0n_XQswd#k&<+z#A54BkD3&^EQT|S#zx-`>Km3M=Deaux; zm7TU<1@;6HPqgV-EhT7VS4*X&zHJ2?G<;UXS`+Hx!*?R z-n;j!T~d* z?ZJ1!(|&@Anrh(?6$e-pBUiWZqe4y@JJ&{9o_5pI*zbv9J2C!MeL~lL~V)s^u&) zSnpk1|6wA-+7nKKL8jf68l^hd95pvaGzgt`<*<~xa^a-Oiv`BZ9h-Wd&s-)emsR=h za-WB3bYL84>7U%%h3r1{Et8U$lDa3j_sMJV7b@}l5Byo*;-eURLd2+* z<>>qM4+0bd^cMFBf1dHj$-8y^x=^Pdm;PcYP`O%&C{US{piQv0xRBnwWMtHzpVXHY z2oY~jk0}Z9td9)H^>J*9@hlE<%k^<=i4JUy2?8T1qb$^WT1ni_ezmtd{G zn4kwMwSOO!{<=qQahc133Dyq#n;_zb2G9e{A*C|&+R48*D!l2_P4aSqi0nOJ%d}%2 z^Tuf`D|#W;eV?qkzrxPJ!W5$5_d)5l1JSID+P_cM+)(JOudffOH&|Bo9j&%lnC%hn z>W~`j3lVIM2|80}@nM3_tTZouef@2{9ywd$FE^R>B={Ev8$RkZoSf`?r`7mXkFK7f z!Jk8*5!XM5q<7!G{s0VGV}kVc^;wp5_FO&%761_|b6r6V*hTI92UaY+e*Vsb`wt#G zU|rPy;K2ib2OFbf8y`G)U}6NSmqJhPX4*Qt@cf|%4<3Ahj>hgMB;AAi6F#nzJry-(2MMZIb4h zdD50m&K<-3b@udhy9v0{aSgct(@gPj5U&VG@*t0cq( z*z!Vo`f~a8RajjOw06WwF)=VOtOSo|8aOD-fBC;lAmQ}?^Pp|`?;8UCzXvU*|Nnpe z{6p(o!wkT~iI7TB0Ybe$f1n}2LBJt(*8l(OK|=RI68BZk|Nrms|GmO{(DJPN24Jaz z|KR0Wpq;4>`y2lE3+zvL`v3nKga7?&{{R0{&@%u3e}(_^{}=qf-|+v~`UKEuX#;2s z^MBZXhx_{j<{$e1fBp0C4g1gEK2R0Sz`zc>hVKgVJRL`#hL2k=*>20dHhWF(@0;K4 zkB9aCJe+mqzi>?}i;vpmlPN~M>L)j?Ij}`@Ra?_CX#>}`zSvo*U9w?smizBte3t3* z!p8!>O_>1&EuzaDj|xipG`AhjDVxE>*={+=+i%Yj%RFDXXX1*>FZ+%?>Rd9xD}B?4xT3nel&nv!iz-B=r=6Ob zwf5XEmCNsiKA+Tgm@c~0qq!q&(bQ8~>jW=aNpG5XVo&AqW%G-3a^Jss_pbDx#}cnx z!!yEHZ*W}P#Gn8C!G-%JB|39T#IieAJ!La}T6sb z)+LS&N2({>mA%$cc*0@zB1zGk5+c$`l1ayA2pzhWEn#H0BK62s3bu6W_)T%@)tqA=DcrD9ADWuzR7&+^>W984Q{$IscQ^`nY?ER*_TJT`^DIt zD~So36tm67u*Tz(YW8!#*Bpu|cV|5=$qAnD=7|nVn8#jEEydiN=S!F^nfrEw*}m7#^V)uV4@kbSc6C#V_lBg%yfbr^ z^p@;(_k5hU&3vZJ5uu$z(oG8$#GA}-pN+Y@S83J!BR&c3H;&z5pW1WZS@6!{)eI%B z5&UwO^nbc{vL0N2sMwk7{inw{^;Z?Qva~wiTFmY#<^AgFsXIH=f33Y$FK9h)+3N%R zLfnc1N1h(wf3Ed?^YfC9RqMjCil+!&GX2z)A*U_F9j|P;V6ya=$esHe1cLr-I`w!Z zf3mFW_Gjm|PApZ)i+IR$SM}y@{#~nXlnU{+$M3vsRc$H~F|T`?YphDJ`+1g)34)&w zNpM_`&pjd-cD(%O>vr>x;tTSc;`@#tnU(p)Vn^f-yL8*|)lLq3EhU~C#Z1`#_QiinONBNbOglT*T0CL9%U=JM1?94`-OqIneJ=Z_p#DmP ziTLGQ`&?-riy&!!(q{n_zBar=%5HQyfFFaCU_#a7K(?vvu3*C|Kz zHyFp9$ktoJAhd@)ciRg`=Gr4IN7I}Fj!j^_C7feD!|jUd4r2xHHS#l^o(cC(_SZDM zYA9-Sa+fe)YBTjD<1-<%zK z-BF@$R?$7pe-}P@Pm|(z zz`s7e{^zHs1r?3zM#Ng;8 z`Eo zj?ZfkJR&C8{IJhWaN4A@T#q!d_LQvJ6aS@s4i_ms`JHCCcxwZDb`7)n1)Y1DLd~35 z8l$XLL^MVj{Gg3daGMg+vcyi#t}5EKc?_aciO1XdmRe>45V)83%33=AyiJzX3_Dj1L6 zc`3JKnGkEik+pXMxMC{)v+p%OnNxN;^P=0c|CTc?_b+k~ta2%tIpwFHVyfn)Q(b#j zom{>0vzhm#g=e#^LZ2Uj;;Nqt%9DW}D*(Y3AQf{Q+Tg6aDe z@74V-UbOvt#=7rb=*G6C;a+Ro42+wm?KLz@b**#zn{&L2oDxiVSf#Z8 z?8WG_@3$RL5i5VaRHiKEMz+G4rm|D{-!tuvjRX_V*_XcBZJCjlvE+h^o{a}*k%ZkP z`(s(}UJ4t3me>AUG;OhB1OFVwS8q35;@q75{wNFEN)E}NvaPRbn~Q&&W;`vQ=EU2+ zv+mOk?T!tfPd4=)|L;A|MS zC~I+kMB1L8xy*8g+^&n#_pHxkYTB^K;tET7m1HZ+!`?+VK2(LZvKERQFZ&_I@O)kA z|Zd2pyK4dxjYg{O1yME-Nu$M{YN69NwmbpH8DS2hW zD%Xayjh}nl!zRvJkSnn~bAh_agSi?zxok2fX*;Z6cCE2|;uEb63qAFi^<7t*K6vd@ zwASL4hGxyI@86@p>a$IJ;GLAU^}~cIaox>J=I_?Cs;lz%mdK?@^XVpp_9R$iw zF6ZGm)HP|sa>pBL@ga@^aW4yF%Y;%`#FLXwpZEJHqV9Q#BS-wnPnDaQ6BuJIR%InT z=)QQ0bJCSZldHs^+`Ra5Q-i{h^Xi&Sd6_ScPkxg4eYIK*zuBuvU7q*1U;W`ZD`<|! z-shoxNu2w$?^g0Ft9|~^axmJ~`0?(AnnfKlbJy`@7IS!NoXiM%CZM`U|MV@p3C!6A zLS=3Ht~AJO@N}4T^jMtzh8~AW^80Rm3R${iL9@N-5677+swLJim8>0zTrFut0d2RT2$S=)K{?l+QD}IXh-k|hHZ9VsLg@5n(y0Yj&|JvrX`L4NvYPt#^ z3(sDBQ}t`fv`71X-Fh4NR_E39Wuo^dJh^J!mX>ZV@pxa?pEDaa+_(6$F?r6N(sy^O z#cWr7-FV-8drRQ^w10_mQ}3QwJV|L%m))&3QrCFPGBg)yO7B{J(pWGwa=Aa_6WQ3H zVkY43y}hq6;%FQx2P_D-6>z0#!4RlI4xQ0p<}E267g zOFbU=K@Rq1{oM(}T!b2%1 zWmjE)7OA^i512K+p3;q9rj zEOU3AM0?$=c-efJd57$bY;L9Y=-ib#zU|=VAHs5`?+kkMr}1&-`ER}SQ0}q+FUj=* z^4~Z*LR^)Y;}-3CXt+MRyW_IazKa{bs=eLF_n1#R&LRGr#O0X0b65B2Jhsz~bBH_h zQlfI5ITyzs=Ox-j_UoQKl6gH}tgxlypvm1I2QU5Cx_o3pShw|;l~!l&7L=Y5R$hC^ ze&(--@j`+#KgfML)0o*_I9=|2;9QPZf8MUqso*bFQn>qr*KA_jj`ZTrjsk}zx8L2H z=k4;CaiUz|tL?oV&Py!Jj$Yd_V~ws-e+U1MlU{d!@+h$hpE)x3yn>RUQ@*qI`i{f= zw^qjga9y$FTmFf$n*`^_o3O6IPtFbn(j4&;H$-StrnbOlDRp zcXb%+zRiy>Zb}cW-TR|`-Rt%r-##QtDXo$f4BXZ+<;S@x5^rTPUd_t1-(DuhRn$>( zMDB=*tJjiazZ+zBIP)8G@9$8Z|L#$aZ%fN|V>$CnTHdpl8v8EFP`p=NX#OVp$$|yp zO3ZPJ)=fPg0t^aSPmUg#za(3Y>C>fv&$4&J)ZJwM8U-I?F%F*adiTwHM~#JS0wP5( z_DQ<#>)ue9d^%phqqgPXA6CK6{t5rx9aA1Do76jM2p%mj>1=BF^@roQy|ad(sJe_X zU(kv_tP_`b%xjWRaNQ)LQW10{ZKk5=1SO^8JQp20kMIk==~Z-1I;-0A|8biADz1H>HXG~J2bjNlduGbdrdbCB z=AL}Ym^C}i^nIh^g!R>K1=Rw3`0|gwbzIQd@#Is(qwj+2ciM6sd2c%De)Bw)rhN0& zn*H1F9a*#KJU>%^-`miZuLVr2cg8VlShQZS$u7=#pmJ92kbJPvSpj}F!GGI6bV%?| z-}pmfVUx7T%}b5}kBqMf~5oZNwDmlZTVWeQB;(|^Rp@Bc_N?x4vB zi$nAD+Zd$sMAN+=92PefO8L#tx#&WR%eDWKi9u6WZe8VdqHjWPRp5p{>izo}pDJGw z-!=D7CYGX&bq6s;+eT>7205?-ncUG?61@FN>Cz2v!AD>|EwDV?5IcGL#EQjhGuP~X zn`7`O%Xm#sDMS_*2^nM5*Vi{RHioc+tspcO60%>>*415KU%z7UT77-}g&_vfrPW^1 zarPcwn>+FYQ!|(J)m1EBTbljn8v_G_HMjt^jBnof;=h2xo&Nu?|Nr~{-{Aj$hw}b{5C~lV|Gz=Q{`Up<&nFnZ|35#jKVbg<`w8b8mR~sd#EXG}r5aM!zPWOh z@u&lb%SF){Id^`o|GM+F{6l)rD)8pYsX$qwwtdN7oXwJ&(2?JbIlQFjcd2a=U;6E^l2d2&dE3vI7qsRV_iwQIAR54TIAGe5yT?QY z#9L#I&p$Hr)XoW)zaQ^)+irBWHu%oVNnWq7=^p)bv#wItV--{4kNvZ39&=7+UQo)i z<*l6`-~0b@(rO2<1?ldJJ6E3lODo{e(`aYSzg-78PIdj8eKO_!R`cxFFPP&^xhy4a z3tjY4v!30M8I`27t0(7AO_ti^dcJ7}*MghM9FB&#m`pzz7r5rsG!`+_lvmR-%qIVR zr2c=hhkA8|(!rDr0OU3%?XUjFdrg_?(=C-3|#V$t&HyX%96KWi3lnx_(*JyF`@Z?duG%I8yG?j$#HUbw{WKgn~)(ym`Kw)=hf z@!)645rM#qzt^!&*1Mt>y3y;y4mm@AzeW8P4n~}sD}`CJRrnv6ZMO=4Q`>aXcadjK z(xW^>eueM*i`m3kPy1{;WZ-#bOP8I&j|Z*Q2hwNBxG6ChS3Xo$7JJCQZ_^{W0+ksj zlyrBT%|{BY&TSpGSYg zB7yaX4kS7!uRVEhePg7`%9ab&T!s=KcTPCDzyHapmbOXVmp6V_^%v%5Z7bYAfA0B9 zTF={U4C1@xY7#f9pWJMBQP-2vL*vn_ONr;Czb#qLA^vnTUtiKPcD}x;PAze3w&vV8 z_^$>%a+dgr+ji*vB={ip6Uwan;O*GUawsn5%FZ|9w*B;J9DH?EnrzT zeNJ(Jn}=F63nHc0rt^jxx5QCa<{rjKK&NY)E*{j6jL1_mQ=DIL(1@csWSh5a^5{{Nr< z|GWTbj%5Gy$p8PJgC;u+>RLeO4*dsDS%79j{@-_;$ZO8Pz|;&aoDVjFf~aA^-<9Gk zL9;F(9s@%|=UQ&n>xmLv3-mMs0%p#PR`>q@zgT}=_omCCoApmh#+;CSdTo}Kb?c*0 z&FhAz3ZCy!(pRl`)H!E|Lx;)FeI3D!Yom4xXs%K=Yl+>=6ScZ_Vw$`}=gTF`QQPMp zRM;!tY_VlR*{Rkq$zjt)ggkdnXx#AWL}2fepbqY3Cft&J#}-(+PJgF2HA!)@k&VX0 zyGt)=r!bxON-5v^a;nEM-Ku+UN)?MM!ty5F4b7^*J!=ws*Y8ym1Or?*?LPH|zgb5s z^@7zICl6IQO_hrZXD2zwPYmw}GAi3{z1K7BSnY(W^Xa0CES|mlw0+r2{pqJ0{ZH@U zGje!S$ldtKE46nrk5R^gYw@p*UMSceG2J}jEX&r18ULOsG~3zTV0zjqtMpE%HRp_B zn@M-QVbtTzofkbbbAPA&S!j9u#ED1oJ+D^0x8w%z51uM(fAyx(`u|GZ+Or;pg=qS(Wy_rf23%3 zoY^$1bkFObO(%@9x4&6mBo6P7}`#6lJlN(`Z*}gq3!Wuiy$JCGKxbp z>HotFC}{IGIp+Es9Bk`biMnmbqu-7la{WJ zSqzeeTLfXacUJyC!0>-H!~dxwultSuZ)NzufcaFH`~R7I{|_^~+|KhqN8^9K4v5Ur zz)n87`Txha|C5rz+4cYbcTfMH-1NW7`F~CD|E9$MrRM*4%>4i3%m2<0kb)a0L53`< z1gT%w{eN{ENU+xV|Ns9Fm@5x3Ffhb|ONoa6?-SMwILtTy|Nj+e!$tLfh5z@D{r_(e z@n2vnWCGRVy1?s%;{oT_DgMr)s`|tlR|NlQ4Wc>gC|Ns7X_<#O? z!~gvX{SAk=H_9?FuuO&)C|6n=4;zRu2be~D&^NA~fB0to{ve_C3l?v0V)*~BHhQrF zhw=y4gVA#ubU2&)4Op*RNGwU1<&*BH&o+7DPo)<+j$0;8Fa2Q1bl%PG*=+@mGR}%` zmn>zPKd{W(Trr))CS3U*uS+jO3-~X}yzRM*j>Gph&uz<0eYft~{>ZTGaKV{43JeN=A{1=n7H~aYZf9{7T>lhxq zpKqBwF-5$_VDF~By(g3GcGmt+wwj>4Z^i8At~IZ9-X+KHc-Gq)=^eZHu=)Exzmrv- zoM8T$uv+|3w_}EtU7J!}npVk`vvZ%fTHQY#|KpLE)S`cS-}1eg760&_ZZ&w6X?VGf zBbedxNzaHRu-CFf4x)IVzvZ}E2zTjkBce?+k;V7kD8uP-ycb~pO>b|`%_+7B2T=W@+8k5-_b*`o_**N3VD`FihRk!f^S@4vE*^91ntJ z-D|B`Vv=G~(wmPSP`8?pt*>Y!z`y81tW$>rqmoAI87>!DW|d9bBF^XrG-S-(?PfGV zvt#Nvp+k|+5+2?$l=zvW61wEQR9|uLmTBFAQ;pP)E8M)bq-DvIUH?;>MK1kM;rtb}?HteC(=vu9 zBK}(+yS6iXNyL;*pE?}*e%&|RYtx(KbwYb>TBEi#&(VN~Z!#+$O*(zY|M&gl=d-!^ zi&?k3hiq)N>Z`hQa&Jt2`RT_$C#j}5$DcYQD}C_l@86^6o2_2o(@?!oS@qLpftW;2Z6;#IcVQSBr_)RS(=|<>+Lx^vr|Dmv+cl8ch77>d~=misYN%Achs}(-&u)e5R?>vuui_j^~|^ zZWy<}{Ul*6RGwSMQs_qMw2_xn5d`-}IM#~i$`Bp$0-8ODBn<&>W+r$u(oY<&Ez z_=oSQE8kx~`NsKKs_)`&gQ5%4-}f(k>Jyjn@MHZ8Gf%Dy$vwA)r}-rukh^U#Pebxq9-*_0z}B9oT*K0vTOAynpYirTf<`zjpc3>4N4IXca{Tb^i{~C(zw-3%trrg;ym|KI zE$X0MRO%P~YwjZG&>g`EecmF;&|NY(SpED(Ko-WX;Mp?W`8(he>eA`h7I5H_3J0jm7kwED{#Ri=0#b%tIXVT zE^YSOb+yr(E%STGlz!W}mp049hE~SUe>#Id`?pDR*zu3kZ%}KjrYA=@<%|!SVM7@R{NiuHgbKA zk+YU9-?uw-BHO8)%t;f{{|5vtx}Ldx#V!ZUpfukig@r#F`L>DQUBqeesw8ZikBjR6 zYxB&LLgQ=ilr?6Y2sJ+O%3%2;hc%Di_dV0y_{z>!o71sP?|SUj>!uSmn-9c9e%r5b zbC1yKoe>Y5C;VBxY_~(NdaT$?p! zJn2>y*SJ{3XBY5y4{Iw+ql$~?&)!F3*Uz!b|EQ~4WK#8YR-PcItj{rxr-hN}-IoeQ zRxe;>V41Lit4yOh-b8`F)c)FA*Uo$4))$^FiCQG^G@0>4pL&1Uv+0Lr!meC!$+>Vo zQ)qUf+M1=TCz%8k^xN(j=GJ>nez9q}KxM%}Rs{v$h`b$#{4+m!-AuK3JD>efrqbWY zv(nCwBjWDIT}Ym=^x268HRoo2-n9QrlB;OUhB}rd>RipA4DFkEcFr!!)-(9%#ycEx-J(~|r*x=K`T*RokdwKJhB^lieOyXjEkS_l2#lO{FjGA%TjV#=9mqpNxA(MsEkT8xc9L^REx{PtU+s8=2*?UK73xxj`*p{ z+?i3$A*zcTC3su@yRUl}zB577X4UMqyIvTbI8?_droYVdjY;*&wVs#VO4%9&m_B}% z4hx={8F5D_U+IuSMg7C4GONG0-dJDvMXgOCW?Aj>6;nJHty=rW+)H9=g3)1x3ceR} z?o>>8m2xR2?e?EG1rGB`Txy-sCc1IcrHsqnvsE3U*5*v&D;3)P;ZN!mn}hBJIu2QH zXXsk{a(;3Pti5aH&;BdSfN_D?dA={+dk=n-@%ol7G{xhk633Fpzl+%KEm(Uf((hLD zHBU1Y2Q5=knQzDR*%ZAt&Gzcs8nd*y?vmIXm0jjXWfj8fH#KbzWmc43a;Uwl^*?t* zLBNl^3#)ac!j{d`)-_{TaK7=vLz7#^DqVa@rNV3S7>u9&ovYnCQ>AN7+_eK-Rh9jh zx9$>dxpQ>h8Nsz80#~9QHlBB1v{$@^Z<=Sx1QwYBOT9kBGpUaIV(a`HR;w2qE3oin zB(iS)w5W-9|03yL744f5kqOr_85E4UB<}0qw(7q9JJV%HPJ~#h(^RdXh$to%ZPu2@ zt?QmoG;HG%-f$phs>;M^$_WAweqL#r_SAXNx5N40R5I3lwg{ie(onE%QOJtWzM4r3 zwrVd=%uMVu;AC1TqQk#+(y_h1qQ`G#9h$U7*@#h+CF$ZPfp5G16&>X2f7hclxAF1k zX$6xW2+y~i#MkSibKN=p$==S0IZOq=HurQ`9*CW@CyPUChw8yo7et=8{@TLK{_6Kz z0Rex@n6(kV6AY5(CYbA68t;tTQQ$19oKo*JN^$^&hOb{CfRMVG)tk z-@NhHH9tDO-p6mnY*A(X)~$D9@T)Vcwlm*b;U0ghKut|{!s81Y17}7kefad7ZO_H^ z0b(9t zCjNfD(;Uf9GSitSB^NNqoLKoXYNPJH!;5BjWj?D<2@;@h#dml4x5FB}apvaSu< zn(1)pFvlmgoxUyCV)!rdb*sDgHphFNvq)|=J~8`rU}?gnZ&D$b&lP@I>NCOYk9lvh z(951zyx|+x{yI3N$#6{pw{Gp$bA=}#y}tGO0Q2mrVw0ZuJn}wvf-|)}Vyo8N#|AO> zifSiiDpr+Wae8#hMxuG4$2^DLOF}vqryh}WF?W9H<U0o=h%$LFMeh=eB13cQUArt8k?$_BFEB_zLeH(pP=j>-LtdO@|VeHp_9vOB2O1i zSpWU%U#C7de)gT-G3qO47dwd5E@?EXd$=+3+{NxU4^Gc3-Q{@u%$^D6p>a}=J3>wE zif3w%}2hQg94+I6Lf7qiHzy0l5wmFtgTFck=Y`y>I$E~YHKR0X4 ze*Qo&tHChf;=Ff(g?m@_JqcPDlfZL{U02-xqs7^R6sZ@BzMF5~64K}XOEP4&8I zzskb9$?^tnN%PKmxkt>A({lgwqkPV(^4QPYG@hT%{?d~_@4g_bUDK1D`}^mAJ^C@7 zNyFj&^vqqgm5-k9`)z$_qSS|j@8cIg5T0o`uX~f7-i*ml{_J`xQ@bhbb|sHw-(z-* zh)q;?0C%3caUMp6^62P44dvT?0U+u|0PJl%u@^# z4ucqzk1@HdbC+?LbzpW`SfVB)>v1z%n1-d2>Jgo!{@aOhZ>cZq#90-Hv4}F zH2Cm;C&QyTY@3R-A!GCWtbjqHYd^c$b^zb>24b;BDOaqo|sy- zJlAJmN7kysK!`@j_yd$Y&+z{W!~dIn|4)JpakLP7!oa`~3~5(376`omzhHmtee3hv zt^WVp2JX_w+5@S=0`WY*7I_+N{8yVdp&&ih-$Z%E&) zuL->yax6VpedT(d^FxmCnFJ9Go_BS~dW}ZcdeT*Jut9ht7dk0Op zP`|r*il-SsP!}KjJ$<=Y@K)qGaX-pH1Q4eci4ueCC*x9_IES#{Zn7_wPDJf7h-rpZsNpXO)BtJO3n>W{>cyd#oNa%a!?r zx~KoW{dTF-rzQK1#3xzvFY5nxCM&v7p<_|9{Gpvr8G8zP&EEa_f83{C#O2zavaFo_ zvG(P`(^@Uhr+m+2&40iD=;OQW4d=hF`f+==A20vCRfqCBH4NNN^JglaY2P8R?9*(H zmEK&LCegVDvL_W{7sb^#%viWWpz1;nqr^$B#HzpBlxHOOgiW5&xnzQ3L)m_J!{CE5 zo5hlDZJf4q$pp)4WI(Es)EN0aury7+U*Xwfyg-+Su+v%VZyGrNCWvfZ`dsZ_n zyw><<)=!2%;qSEq73Y1k{TUSMu)zFN_OX?WaSX?%iX55}yUNd9)7<>-%t`u-{CL}9 zRgLc&Tcq*@RwTaQonK$n&Lh7xOs!_^^?>sUk#~Z$jW4u4_gXnUc-8NlI{#0IadVdD zu-Kg0)T6u9Lgr+_tn-(=S{02P&2pYF_Z)p(Te(R6vu%AI_u;5)`5T)AUN60+U=^>I zUR7`>UF#4>=a2p2-@HpbOLj`>&1q>DXODC&bFAF}ZvdJ9rJ~w~k z-=JI-C!Rl#N{SsD<{oy^nf_{zL`&LFg%!D?&o@-<5x%JV{nCYpp~~5I+}t5KtP4MT zbFe>L#~I&V#F^cel=u8|Z;_*$L517NW4i>}xC#W=&#PSIipbRo&TKmYKv9&<~*n^sc#6)^s(l>1y1&VEVeA<~3c7YrC7)^)zp+FI?N*w4}adZFkeE zj=JM(m!8_Va^J$4Tc`G%+PL!gnk74DOCH%@3jv3~ifjVpK0 zoeB{@wQ=Qd{qLWwcT4o(tAgSn>%Y&F_zYgT?mjr@>+d|Rzx%w^mi!66Yqi!o zyT5hU9{x!SJ3j^2Uby74Tz3W!3US1U{yg6*&s@U^K7sOwk_+L%^86(T2 z&6lNqaa2rtb#Ln$#w&j`5<;yNzRmZ0-JQa4VMVq1$9U$-_iTEDsZ)u?`+~#i<$P7pJD z75eo|n)+9kfaw=@PxqazMj{#U<*|6M8dapk{b_Gzz~JWCb24t>zA%)cW(QQF`9;{(3m@fUcC+zMap z`guy@Y5R%H7LNCGk8b-M)4aF1^5F0PYJ1D=*56?4LmGAC@R zd5Ph>ZIfJD@B1(MoF5-QNz&?c*NgV|o992>w|>zI9dDtJ`vMKP7;bqn&D`(f? z!Ri05i2qxC{~s%Wif_+_w&}pFLS%OG#@BNh7#Q@yrHMmA^Zfk*2LIo$FHpFDUf_4a z|Nrm*&;I{k?0kd4dJj;G?f?D#rA`eQ2Fu?6zjJm%6*~h1b0DP1cyqnAkU^2bC6F)H z=2HFIi5GVWeA_fJ{Ghx{@uK?we6MSEJdg2tHd{sfgNNSMnVU_of1H%~e5J9_hgENu zIUVcN)O`?pQ)=7G4~h#XrZ0WmTx9CPH$OlvH;Tz_sk-w-BRfrZ=Y)+1X1&!?2z<2h zL{|wz*b?RrCD{|6i1X!gihMf zP`Hop&0|jWo0D>;ZS9%M_eu2deRJMw)`^UcVv+(4RtkTvS}6(zg*vr)cr<%>gmP+X zDMqR+X-v>-aS;%RQ}Sl|So7TeBGb3kT8f@3D$)}L)(a(tIxX|?2&`0hdnMohpS}Oa znU#N3XGLD&Y(F8SZ=|3m#FlcFHPK;OOkAut&xzdK-x}{}@VGEmT&g}URi$3?u71ze zs-PD0RuADVZ}&62PoAf?QI{e8@YkSodIwt^O5VN|Xl?J%dAxHMqp_V*p2Q@X=7kKZ zpBK$(UMaBs4tuw+DxcRf*PRT-f^0^IvQ;_B@&JscF)U6ON8uUpyV3SKMWGz9M5Hcm34Xc>+sqd?))l zc?xNrI#s;TcG6!N&PQ&~CT5&nHa&N<(6&rj!4tnj`yNk^VQ|rj0Lw}I|6{H8Fs8-LTw%Fl>yx{S=E%k|SqGk( zw`ca_-r}0tLgq6W2CpV>p1$apsOEE5%U{c~ug7(+N{S9~zf<|@QLp^@{eP8q9hhn3 zz9uQ+zU;XZx273J2v}J+Yqqd2JHy>nDbye;dM=e|+G^>QZ)bFSO?$rMP5VTjv%C^q zUy4l@C#|^2$J3dxvTjaxWbu!AZhW6r6yFut^zPiV!cvTbQ~Y~Lh4P6b(;oZnR#=jH zN-<$$VvTqH1n1Q&0{ZhWN50wrq`-;c@2W|&5+^=X{v+q8wLw_r+C7Ccjt(z)+qOKu zZT0wT+`;K3k7u)85SnJytSEe0PBE^SkDj{-fcj*pB z=6Nf$P9<8+S;%Z1wcAo;?ybrH*mPD^dl`O_y>aboX)R~{_W%EWzh~#p4FBTuek-;M zy;v29DQ4zFi(LNH&Qb`1h%x=O{z&QntQb zHq+OrOkBfIHkYBLfBOaFnFqb{)+ICav?)z$@S0z=`jl*_JaZD>FEA85kJU zzy*(hQ}WLD{}0v(Xx#n(|M|jy^Z)->1{XK~p-23+|Noz$ap%hp1_l-`XnBLS=w!x^ zPfKbvcU%o`n!Ox?ckh`|Q8{;4?+j*40TDN%0_x31arzsPmFYN1G3@65yQ z=`v>NVh1NzO7JmHT9Vmz^5Rb6mcLyqm&u z;AGa--~v^Xdkmk?o=H*+N|svcqWVUl!@0VfdrsKi72B7%$i2T%Hc$SRn(wCft(jM? zk2`kS+^gR0l%X|iSwQ{?FTW4RPQ7a}={h*&#N%4MT&|rOeBnyZ&Q-o~;Rtu?J*nUR zFGlBWs>iY^+a@h2kI=sQgdtr!QGD;W&|pr}XCHd3BLW)3TAp}iYArnWQS*uwD3>s-zfqhQs=5$WYKC$YvX`LA=f^}@R>t%KEP|0OR=S+{++&&g@MS8jQD zuGqcX$8)J&M(>m}rRCE#9iM$jTcC2`UTj(Q(c;`d&m;OuxAq?NT2p9g%DK7T#Qbiy`eY7woWxr%n6IONOo5< zdr~IzYJt}+={kd-YXz!qyz_YIckiZ~$DJScTc&I%QU7$VXl@!qwun~dM|GdN>FK9l+GRZct1Mk7OsENCHws7zv>afh+Jm-|t z9pjJME!q#A{%A`oKMeQmoEK3k?)2s_x1wrHN4=_QRmz)KjzA;DdsBNZ>c_MEyKWb& z%ErO$C}DR#ElKhyn4>QT1KWLn(avoi@tqxJu$Pgl%w+2Tx1XUeg;F^;8ve>9a-Z|8K^UpSqh|_Vhl2gp0`*)d>=j*TizN0=W!B%&#`ld@WWJR1cuBr!pSiI); z<<7ht-gggtG@hn-|H}Jzo)Zl`Cv;6yUYWPww`gEsU_d|LmqU?=f|Ah-T2Pi(JC@el z!%jC=WdBVhotYXlzTCs|Mwy3ea+gRHi~}TD)#4)^yiJDv$LHa&lP+zpa1O&q2K$Z z&h{y6ove6sq3oJ<_NNzX?>TRQj2@iO*mBhJ{2Bc{=PeGMHTil-W=^+i=QP`y%WQU? zHo3JxV9$Arx@@o0`?dC*x0t)ede3=_8(YQaPjb6CRkA19_vK#6&HFVLFXlbEL3rg_ zu`LHRx2+Oby_EONLcaCe74|LSTeC%G`!T&`D+KqPx5ztKDh$8*P{85*|AsV$_v;Pr z_XmJZXN4>g`tNZ5|NZ|5x30_~4D*I7~?Qe0+jRlo_U+;hXq4drp;>Kf*)7*O^S%r?M`mNfP_d(A}OmBH^ z=zjSphm1IP)_8|s@0>hEMft&sm9L*TDn$Cv-g9cxx_1jJ1iEHyS5)NtY~y(|$*n}C zz1K4&EO~~@&W`*=>Vdm?gVrb-ruAF?-g?XM-dY~rlm#OD4@TZDFKttKoyln9r@Z{z zoz2fGdaMG&#B*v7oA}z@eaE-wM(d=-4g$wMPVM8i+8|f{{87=n_x~N(A4Ydi;4{6m ze$J+PUw*Um@2xL~H3yYgD)RUHwm7rrb*U{2 z4()Y`KEd#;C8cG7lERTLI~LIg{cgb`iXAPvx7r?-8n{i~#i9Sa?Mv5t{fp7lZq(^% zNxhx)E%cH+kNY`x^Ch-&{PWq?n|@R=^t1?h?eErioO@JYwn3 zLyb>g)oqpAe}m`4#uT2J^b_2V4}Q`*5dxFH-4GeB^ZBS z=3JAwkJU@~`P!#H7Wnp`TROk|^qCDZ$JLqV&;A!bPwU)`b$?Q4S__y+{%|^UjCtz) zNl&->%#mGO*s%V`>O;!~gQwj+ctdH!zqBT&nvauji`;JB>iS?e=eEqv$AuRimh6{Q zRp{t67q8>+QfdA3n7$0;NyPA=I*zM82 zY*9;(N$onC^|>_{y?Ii8@G0)wm(38_a$TEuV&jGh{ajJAKTX}quj1|aMCP%3P^#jm zo2iQ3Tus_DpD0${=Zl)i)iOWyr z?yoa^wj@*bbj5_33lGVByJ4QaJin(_M?2Z^UR77!_7nBBtxU-q9qd+3xcBr-X?u~3 z&Xca944vf24URGX7wsn}P7qihcl|)bBl+1|16p4`GT`V4v3Y&GC)Jcqsp~KwUvv8p zvl1CIu?C%mOyN$>e?)h0ZKn@xn}D+ zKTtrxGDgz-MRKr}{lvpBGWD30q^-UjQ<8RKt(QPf&Cl<3TQI$S^D*oJIRrKRT6+{q1-kBfxe~Qrm8LIzJ6&+fhJ!5rS z>5=V@hmU@nWe!rX$@~BQg#Yt2|1UBCaZeT9o_1^k0|P@GxHqS@@V|nSKtuoj^Z(zk zPcSIBKmY0e99UHirN4sc{r}guq&ujd{~rLV;Gctpz*wPR|NryEGPsEL#;J()w^R8%JK1aK{10M)8Hu><@BzzgZ`6UUbd3 zTICIAd% zp98#xxuTW-G%Nnz{piP^;G&pUtaN_KJ$L&P$CF+y?r0v>R^e=5qRJ^4wD&uXq~ zFC0!*OZKU*S9xZASytCSQ#O zt?IJX*EjC0TxjmqIb-SNjfZ#e%1^x-d2;o=$KiJZ!z8AE@a$@Q7wWT5`OO1~rU`qj z^%q)uubQ-csX&W{`K%Y`CQVzubwX=FyD{TSgDJlcu85EddN9Y|is?(zKS!>}4lBT1E{&GeBsVo za%4{Ps8&@?}?R#bH#FO<<;Y38}nb|J2?kiK97o>)E&YY|skDU=}>~S{!~HXcTRXw;lno7z1&!qZB$MXOuv!`IjRJ=sST&CZ(qS^4Xy>8(wo?FlpMXI7uT$F(ZxpYGA+JI_qttFB}} z>5l8M`*Jq3UMEYmRIQ)ZJh|7c!?b$BSA!EL(hr0wABoGDP;T|n@xPHN~2Qv z`6StXO8m6nw5mYS^Y+WhqNjN_&HMFmVaNCRB9opv-@EF_mT&*>u8COExxF*LUVC;# z+_SpD_->xbk%&iW-yE;koVGY^%=yrvp9*{JS8wFjy*g2W;c%q1<)%Z)7c88o zEcu|=Z1Qf;|7;zfiN%*EaCu%{Qxkste{d|z$+~3w6#t^1H47s|;zAVUeNVPe>H1l- zE#_b!S9h`2s%cHSb=>hE{#Bjdvu|J8J=OVlM7ZTs+p;7UZT`LK=PU0YuC4oxrcXYc zeCE%@cSccXlbLt%97*7uDc>q&H~GBH7Qt2-;iLR5T`Twf`MLUAgV4D{n{uBo^5a*D zTle9UhsU+D7=9-yiAPP(&19qfuLoUyvgMZSj!Q@T*kUTqR?U(yj-RyR#lf}b6BHEl z<}Up(QE%z}MvZ&=94`ANr|H~0q8Z<;=#rh}{(0L4FVm^hQzVrYe(YDUf8@N<>x@&A zv*I#GewNCK%NLtV6+OTF%AqHI0(+oL*=nO_cNE%!dS%%QwGQQepZr6k@4yBpS>Zm# ziJzo0xh5zq;htzyX7;!yhO_*FqRw}xoJ{_A8Ao_nK4cj^Q#bzW&Yr&IQ+Et|MQ?CB zdtl7$+S#8spNvU2eIv1Xi)ygPf$z%9;#RvasLQbaKNopwlHG|<;yNkkT-my(?zNmD zcp_?(LG4l2H+@ZNSdXZF+)ugkW|K7;9HLTcu;c*y?tb?k|xt6*ILIy9{-Ll^7=jT+~Ay#SWyjDkMDaI2JJE1IPcKr3bT(gb1r1@Kjf@wud8h-k?EO|{$kR4y>;wd z&o8}xE}{LLOV#((###o}w&um(c6@zc5E8HWGTU}WS&9Hck{Buid_r7(G7JAt z6b9A7Q-mO7!qWALOV|IOs1c4fpx)5 z=o1BTCy0Q^DMJ5iqi6a6aL` zL&Adh3Jn71`@`oKG@kxH-{HO2{o3ga3@qu8D*5fL&Z1Rb0&EW$ndWr(G#Tn}ecZMG zzx2JHe<8u!t~eOoDt~A%y?lm6{LRffS7-(=^Ot=l$&0_hdd%j&nPop7B>w;r*;nvCEeyPBYH^B(>!y3sYs# z+yfWhPoFqz|BU_JCjTy+D1No&#DNRfCq}Kh^XGHX%J69qo-w~ZB2gG6dC+U+r9Zpf zx-;a8eWvY7b&+**`Mds%>(*CWc1JHaDLUFw+TPf8<=MGkQOaDeO1ftr{d__(d0Ol< z=VHmlrstGpNtW=#}h5SAk9CS;8RjSMT zTH~G;g-=2bpS-1tZ$435xRd9s=-pLjymAKnIi(&Pk2ISa%f#W!z2%%Ww`N}GyhA&l zo#rfC`YJDdt7BLgr@{-KwfPDK42M(-L{2>xvY54NizkC)I%|}0i%fV&ywf4sF3%GS zr}#2?+?G^fSs2|Au>H(I)h8P~7#5yWU|jN8fy3$!CFf;T9`bdkoRx87;*gPHVkn=`VyQF9 zw0z5?J*5R4au=WTO`336jnPGAsm+r7*&MA34|P*QJ1tg;-k14o&H1w}{!^{p9g)iT zxcK}3PW=vEop_Q_|Hh+7s}nCqrN8>l$RcEML_t+$?cy)33YCnUGG0836dIicn3!am z1Uw!Hv^X%eTd*jH?K7Ehfe0gt)y0Z4 zr8#6&RxVK}nBc;5>B*EJp+m-w0+}8&f)5!A?0G)hs;MMCzv`;Q2_<80Z5cj=2?rF* zD)JOEWqp-dPI`MhSn;$h-s3^QVa32VVntI$3V7Nj+M-Xm3LRiP5zyXu$5Ej%SwqFN z%cA+P=n?J$OP;2yIc%-g9pQ<#l6;+8u6f6#6{`zaXnAlXt>xic-FdB8UEs`Zp-F)P zBAUgFjn0}LZd2L9S2BCtu!=f);^3|y2Z|pjTyAEbG(FB^@7>(I<@q+o|39!jR{S%$ zHSWZ}0*g1hxTQXAd|_hoPlkzIc2VD$3nb@VS*th?f+taW@!*7y`U%u2Fxwo#Ey3atT>>?peYoej0k$?3L%f zX>sFAOB$~|TZiM1gB~1AoHC09tZclUUp#HmVBzy%QT(I2oTp_!$MnVz+f`E({`5*I za@4=};xT%1cF)za?bdQWWqTc)7w^2&(>9@5MW)EA=WL+~3*RK0?+II0GDWZAHN9{5 zCgBPDw;%g0B<7mGQ+$_xmZgyQV~&7{#MDRX_wQPLx@?)hA@uR1r`syJo^JW9)8EC` zXPkO!ie^2tZSn8xy6d!qu@$gHovX0|R=`3Ez&us-VlYqRf1l9*B9;G(K`S5suV?tb zh3S8-%>R81|67FruVnZ?iQ)eohW{0E|CccQ@8bBsm+}A2(*JLd{eRpK>c9MaQ_^7m z|Csi@*$jmZ7QKzeN2iGV-{-oy-1h%vk3$vu|F5+FKbd}~ShuFi=Ksl!|CiLhozHM% zF7uH^B9mhRH|5)1o}l$%HEVO8>+Fe|Tc(v=VqjoU0vE_edm2*ypBJ9{5o8S#h75!@ z{NJz7)UU?Cz%mzF6yIo{_Q*_v^#PBqdJ?`-}u>o&XoD% z6PI#s+4?E}y^QNyKw!(fZolQf#bj(lm)TcH_n9k5YR&%V`kHTcVD}_P_C7P!=6$L? zZ!`PnZax?(6Szh_kl8bT$(0XNz8Y@oTY0T2OEtFaj8${7MHc7Bpxv*we7?82Z%N4; zRZi7|Gv>No3chA|IW#Tol4Jm1-6;uoE_Ri_jOOopTGnjbXm>*AtCzvM%q-Qtm#rok z#;rP^=;LL=AG>_xwLL7!%bqPeGiSntQY}k`mp^4E@We+i7uHpu7N>R0b`zi1q3aTw z2WPm>Tshfw#`k1d?t_e+Ue}&Cw5&I?2uLnkvg`N^-D$_>xLjH&Ga=>#pGureXs-AQ zem^4{iSJ9w6izQzi9Of2OJ4Sxgpx;lT-YsR@yv5lmB+Ss zyLD88%{)_7Z%h*rQYlqeKJ`aP&M3?*b8o`R8|;O$JuNK<8kY*k?$+CUscNhBR)J{w z(=Im?;#IEKPQO2A;k-?)pVl{RO&3U+;j8qe$(H7_S%Q>R(@9s_gZx__0g0yJdMh|b(3?txPo%jo`tXb?#|p& zJjF9`lQgH%dfAWrCU11zrOBX~XK`Zfr1I)Mm09-~H?2}AW^Hdv*{Gs86xf6RmE^@v3&u5aG+2{;I#?SHQE2GmhVVIix2dGdc}+ScNa|xxpU#v%mwc}J+gi**>d=&oU0`B zL)i%n>>@ZBXU=wubeqE*+dS#3Lj?OIjVqnzhYme%bnsFW&gz+@QrA)X$b7b}S z)$n;7vYznci@=o#W6u=D@Z(N$r*5p&^f$f|aoFd${OOuad`yqdy9Dpl-fVyKmDYUS zhxc1<%=dg>rv6%4;p5-wTJf(>oh`34N&EYHO4Ax{_Mkha?KQufYNqaABcfv8ux7UN zzPiFs&lGlYSLO(AI?EV2+e{&e;o)cd=9=}*r|#Zccp)G&z4gqUcAuy}eN)ah-(l-u z5Y(!>E$6b{+%%qfh)CB9+^#zBx5vDZrWD z6EPUa;0i6kkz2fQ_RW`X792mj<HDZ-)zIwohAf^ZKWTKACf;j`UA<`4^dVORga9 zRoZItC+n9vJUOJuWzn+TQ;ccS;f-%}1uD3gaPSCLF4Hn_;b#}*nslJjRfug8L*%CR zDXX{`vc4`TV?EiRbGLp+;8m|Ba#PkRI83)}QPD_j3)#AgwV|x~37-;|gXkd+P3ft> zepmf=E*E&~Fo|6u!DkO^QFix(MXfpY0=6vv*Ve8IiFD9mzjZ4ut%Lo9*^TWTg8q(t z%k8Z_R{mns?Dt7pASf{Lpk7s9Mbnc9@=huDwo6|3SS|mfmBIO)gVoAc|4m;UYgf2j zvxZ$ue?pyGsn~>d|L+^suaxJX5S7~E^Ih?A&BA*o?j9U+-z1zY0v_|8NW3XD;i**0 zN4}Z*-xz0BdF}5}RQS8qwN=qV`@~h(r?N$*ftBrN#H)puTs`<$KNHjlZLw}b_Dy6K1gs$f|k@I}k^k>n?v7CWbExuzrzuUCiU zj^6K3-0r@|w#7lH+mwl;beXtFkzt$7{)op79r2A@Ux^H)P=@0a2b#`j7v2C)m zZ+3K;ml?fdLg~(lWzCKbJ^o%jexB`a&W*Nq(_({H)@JUUSk_=;yRJ2FYftfl@|4-x zv8^#dZ83q9Gow=jyhFX*13cYaTwLn2W6Q(*yxd&75<=qqyb42ovx9v4(;|0HEQ26D zsYUl07#K9cxy60=|NqaI z^{o7_ZsQZo)ye<*_^es)t)50-O51JH;qgh@#iYU2rRwO<@@=N6tA3lhzA5(PI2cuZ zb6<4*F%OAP&)2NrFkV?4(ey~>hp=mus!NWd(J>J{yG8pQS_;gLx+l0!Ja=nCq}avX zvsdlj=egv7abKLH3&Vx3#zP0sc*JQc3bt`92v`5o>f&MY%V)AjT77tm${~?My?-|! zmN{wct2EQ;NMH(M+K#@G1K%ADUa|exVJcf?VY0W(#_XIRlSyaJ70c3Ew(`EP$tN7= z8sELRA)u`^cH-frg{>0|CVln_J?m@UvBLX-Gs8r`#6L_E>o$4JTPemVX>F4FWRvHE zTDghGSSRusIL|D~;Z>S_ThdUmFf`;!ely4BimXFDPwY~aX4ks%lq<{=EM@fh95Vq^}h+_ z72Wo>RqcrLlD&_f3d}g>{6tZyIb(HK#|nGJP4{aici3#*^4r;E(&7p?7N03P{`?a+ zxrPZhzIZRNuvRKm>DE32WoPw2+8->H60&CGsPC0BD82D(;hzG*-#~j?(x^-)oJ?jOMQj8#|flE3wZ$8XbmSKjIQ;NsL( zl4~fPR%!lwtMR1Vd)psv$T0i3ozeO;B2%CHypw;%FN=#>VqDtM-LO;1_0Y~a9lx%0wz$+huDO{RW~VG1z2Nio z9l_fh_jJ_ecRxCG-0bi<30?h5Gc$K=(3tRE@YwIGuK$=zr`}H8{5>TaOG(IdiPrOSIRUEX!^5`+O~uReNw@u8z#8@KN`cVYU@eH%`l>DsuxYvcCSM~*Ms ze<-EBFQvV&YS#Re_Pz;gH|F$CNonu5IuKp3k}0lIhL>qrM1Pq6S~dlExvZ%vj)w@^PVltWfBC1mB8bf zT&wgvC+%ZC(tE16vTyk;EJ>VgB{4~S0yK&5U10TTr}3XdQn=8&ZB}o#*uULs17E5J zXOw{#wKcaoc1-k}F+Zxh#d*<+q{~;^SFB4vai+eh)BX0{zC*{V)^Ew#vA4K?dhp}5 z0gu-PJXqroVLV?Kz>#xn$>m(5hW+a1Ienn{(j*tp5G(on-^UA5!UGStXfctomWaM%6+Z}SA^Y-F0u_^#)p?$2dyzc!cXoP0Xx@yARPwu*T^?CP@rj3j&A z{IBPo{OcdTx<9}EREf{*j~B!Dy_oEOJ?zbS^|OWF-$pUc7$#22TF$ua;O31D!i5LC+b0+%EJ;W|p(s3=A^EN3d6ph_zg@W# zB2>N!Ft6<3ot47!glS3;)A_rOY7UB%Dmoku#HW-aUMD!VBpMp4=zbxA8pd{-t~RW~)G-f-8e$^XJ&f zRVTg}9XwpHGv=J_;dHwl8Rwjra42qTwOMpE(e}wlrQ>_-&aK{WW;A>M$9HVlpMg4_K+e5kR% z?{~<#&AlPWsFmgauTaw^N_g#5vW2$%L!Zm7(W}uF5$kw?}6k@0p)m zv(JoEVr4=5!tAXdox8U=$~hzno}9YT>ZWn}ea_5ppLgb2oAfrz>R2_oL<+L@$n)O( z_3J{jMz5UV6h;=NWBu(p2RcJk+v ziMB4keZ99ZpNQg5{xfBpKi|?R>JzT+TDQ9?W3mT}z|ykmS2CA}D7r|-I$rz1j}Zdv>!>FfL34koWdA2SsAZf4>-$?U z7&h8E##En(*H|v@!QAP=wC(MJT=@y22}_!OFnA{36<3)qv5I*~ldt>)(|``umMgW6 zNty>epDFe&5%=gdYwKutxXizV@rZ^C&zfJ2YZ`o{n-{f|+E3t3SlSfSpmONyUx!z^ zDwRxAkEY)hUlOOza`RfPLrG@Cv9+)36ufSl@ve*1TrBS~*A(c#cyny; z<{7m$#YcKMp6Ay{@J!#H+4D3&a{kZN&-s1wDmLuO+*N|5#$w$>OpP@kT4PmIf>uYD z)jGsfMk6n!MzHJbE6ZF;>+Q?I>#iZIrmJHkT4RDR?^Kp6n}aE6lUkROkfu{R$GUmu z%#yhE>pR~cufMdXxqQ~dxCvAEiWWRR*x=PM{r2YasY`oyPs+Hkyy)<@*0%Y5#TfhtQcA!20xrqRh|3ayVm2d!LJ^tlzkc(?XP_N`t@t6nc~z72fniToyjP)Jl?wB z=4kQLCts5NyFE~6>U;1`)^7p;>KP`S^$?5RqP-e*@VSCAmw=O38OgOYiSzGo#*M<_!v^mbA z`yLhuX}3)A>Ui-(=Op9bt{9)Ft31<-L(NKwczBCC#k2!&pU|1IZ@#Ga$6IRs{1b2dyy~_r z@D2;Zt;rt8EP$3fYmuyym+Gv7G^{g=NC5dUt!)^|$Sb>$J!6LO2Ql{Vk=Ih!P>v$z48kj%-QN6fx{<+yNR<}REn7)dmtG-`+R3cyg)uE;=Z{roU;=i*Aj~o>h8P#-F>wI;xFNam7SFk|__guW7NV z>6@~9W1y2W&s#0OhcUZewWVEH?DhJS??0;p%B>SjI9DpYm0f7lt-EWrN~89g2hn*P zCof$;r@w9eCzZOuCwpIuG%jZ8pWr?tU~36SVgBS>>QBslRu(t~truVu_Ht{xaQ9Zh zric?!3A06N2+~Qvjk54NT{F89Ow3GrPB@WysrBeQ#?RT8tDSn@Dbj`o%6AlC(2wHVO@KDgF1EKmg-4i&bO=Qcp z)LGcow9TNIRfREf%aNA~iCo)5RSz~SX_8*GI3XhN{tDHziyyp8uV9Z)V|MDh>U1vNO9nUJQw~wATVb57N-}QSZ%nRFd)@{#Ox4EbC zLY6HnYW9S13y!Yv-gkA+S+}O+6Com-_konnT;?=kuG6-&epMx|tuaCE$pI@@crBdf zJ+sYk&sjJ319$EBKeyli{P>ML&YbmTYGCe8Y675-)AEQ|OZvvdqp zG*2+OPnwalRHpoT{iL2ZsW#=;oirzu{Frf5eWLGev$;?Bn>>G&El=cc^4#@pK{8*H zXUJ|1iKYb+I!`X>wRI?R1U*`j*&FwX^`J`Z@36ySER$D!3pp;rGWoLnUbVoxO0gDZfvrMgil}!wK>t40dJk!>4mUDp37Ph##k@;s2&0BOjb}O6Q zjqJUpZ?!mfWZEx0vgG@+Vzp3q&$j5=lJa9O-YJ~i8+Su)@|+Wnld5yqq`CL+cAdmt z`{>%y=(LGX{sm_L{j#Qa`pvu1ZJr9pm;L>9Ay1_J5W||cU$=7QB}6yKcFU@2C0k)4SKawCcV6XR%!Do=IyB+Vd{#xN4s^ z{cNa_yh{44W$P~PnE$WCz5Lwj>-)^}Yu|sevr>0fwy#^t_F1$`;MP)3vrzFS^^M;Y zHvOM>&f>>Q<3&3JTFx%>3gqiO_fxgh$?kN(iA2i+jbHgWr&g(4RlKKiwdhy5{`Gs7 z0!5$RXJux-(KxBszfkgPtHzBPJNPW#XL-zUmP-ozasQ*&jMRYma|T~;wwr%-D`1KF z7`rx1@3_CRCd={v*7mDD{J-|8(mrt}Yg};r-7Cw_91XHl5o4OKA@4ssy^-y!sqj8C9pRob~DLagaRT zS0>rJ^7>KZMP?^1Bu#u~Ci=*~_mjfW#QA44%rd%o=Q*Vc%sZ4;{Hvm`VCO2nBAYGA zv1jCbV^;@X*|lqN;kPQY=qovI0_ve3GTUAlkEH@}zua_Yu3&BIA63Osrj@G#$Bvyk_v==(1c?WRKMY*U{YvA*hY*I>&)6zL%4WSzkZWpn6YR1OxX`IcPvxFHwEo#IFa%_$!qbB)7@Wt zd(Vd62NpWK(vWEeYX$=!*yWs)ABJQleNYzSp9^xX7uzRVG2j_u4Vb!s9~OE_O~1sVEq zs+8Pf`K}?pM1AsM)l9Y^$6rFvo4zah1trYj(s?=O!I9<3tF30AQ$G1%RkOayl+7Ws zdMA&_F4mSaZ8@_`dD6{f_R5zJyCRe4OibOveqzFcoUeu!c5++ zwNa~y(>7Z;bKUi`ah~@XebkG&=2V+?w7)crIq1n__|45_;bFtxneq zTxYxM(<*m&|JuY!?<(F@hAV$k|MAB1i_qt}|DVgRzxCw)yZZmXc^B|4;<&329fYOs z6ueGE-N}>=tvexwHg(899o@elT>gGyg1(F8aKr?ro99+dQMs%Njo~ssFOF_0!D!5AC5} zRy2QJQvY#k#`6rFWB%e>-GtZKa>lf_7tCB(xpaNW{1u6<-CtIQ|~3JecL)ced4sQJ7#^` zH7|GS+|Tn$zwTZ1{lK!DvC40@%{|+ia=h68(e@=THcY#_Zu-3qv+i%6duwU$^?5BH zwoJdXdg_C%3wMO7@AQ^ zc=YwT17Dxs`}60^$2*tbf4=zW)w+An7yo$w`r5;ubGJ+Oo_9N48?rOs=kvF_*UR0% z|9pA-$&8~{V-8*lyj<-3`opp3uXmlywmx+u^L@F;%^dTKx9jd!`mM=ytz5dkI6a~( zBcO8WdhgV<(A4CskqYID)&%C}S1w&2Sy}ry$0(zB%A8EE%BAbe7OtvXx<011v0}+O zP}^wfdcVx9w6xgli8Io=CWMz(1Q!+u7ZxYAcGYEsU7MX7-`IA!(CylZ_Dfp|j_q?h zwbT9TQuox({-~<>=z+)EKbhz=Qu6L}Ge2 zTrYTmlqwhg|NkGkRdT-dAy_sBOhSn*P?|7R`2GJ4kg6vj0*qDvgHLS;fNalA{=ek^ zfeF|C|NnpQ|Nm!T1z@6Y&;KPL2B__mZt(EQlhi#7417V5cFvMZtbK=$KiTEm0*+bm?rGyXC!xw%c8>4hUj?UMUK~q%iWi!E{3W?~>XSKv zUNtgKTDdd$TW(KwnWK7Qt4C_jRXc&lYYboQkz3H78 zXD$1g_u$H1-?B(m`?gP7{c;kIFU@ECoVNS+{yBHcjORPvWtvo2A$cmllIK7}BBKD` zZ~f;CbCmxs-lDfnmbHn2C;!;>&AU!dv-ISC{19z>tC;$1`-1M<(6>`;>Z#YGz@`=&Ure!ZrDh6EHQlmCqL8Me}-r?XW zUaV^)biyZDt=d|(afPVYnNJ%79)0#O{d6{M4pR`*VFS~)X+iJgE~jNHz? zh1~8tOPqPQmQ^-( z`y=a|SQ^&pkh#nizN7%rWJ7pZ)Xvo7b+!#OO``EU7Bu^;2<*y1hu#kM#b_|36vG zxq0UuA7A^LX^F=_+q=DvQcP0dIACzqmPt=E?&8A>Ppz!(Jd%#Jyq=zJ6v=kG#i#O@ z=>NMswr_XnYpmov`s*5X91guYfstOwDoN$@YpZuqA{gKLGV!Z3a+Dvq+1m#szaVWG%PC6 zn|f+p<|e=6eP3?O_4__c?Y-uN0$s;0OOZW+96@thrdjsSXmoylP}QQU>?ilzQ~w^E z|B`Bce0lp`C#6!2&IBd1_M!-x%`A+^8!h_4(w?+H_u1h6D8 zwocYyFE}H_;`hWjSk5r{{%3|`DYxWJX5B2|ne=|4ftdKh49?afwscd+DDBtnZ8lq) zKfO4c-YbwY^F@G1635ew?5$frn3}8qe|B+poj}~Yx1G|l5_SJi%r=X^yxsi5Q_uVN zs^9N@cr-div02E8ldZf)Ax=T@6WjN=f6;CkDswM#{QS2q^!wL2X4Cd9$>hANx-fIn z^WEl7i|_1KH9z%k@&Cg$F5BLg-9G%);qAq{;>R;OQ%-RxO!dhq^tm6sFi`G?`Kfui z`?-|%3l=4r=kY&ly!DvXPkF9@Y|3mGspXe?rCMh`aJyOCG~s@&QjhKZMUOx6Y&|Zm z|JlbZJ>tn1z9(<(&!z3*+ILWzb*|iR^=)_acQL6*KjH58TgL>*@cB>7Da%!Sc87J*QmqJggXAARfE@y2c-l zIzxvXHr9!bk2X9%5n1**zw+%v9lp{NA2d>W`CeGPo7R(YY2Wc{ryuMHomwEc>8r{hJ z{SYepb>yzb^!f*(oWc)z?ms`?Dlcl9$?+s)v2tO(OU;veA1;5+nZeO<*2;;6&%OH1 z<3rrRpYpjB>nE0+nm;l3Qu_RP^Ijw>88q3t9j{U9`t-!^^MghY-idGD>nu`T%6fdg zk@3#|E`c>lsX9h{b%Jhh`0Vv}JycixFD55_a`yTgyA53@x@bLa^5{ueT2ji!@L%dV4FTUrQ`>qbo!AAIm_s8OB|{))O11E}Z71=X>jgKxb01+nO^hVwLf$ zuW-6;?2LZ0ZC20P{|4=@9LwTXaw_ru=uS}55Oh|W>e(tFGW}Jj%aNIl$L>cg;Y?Ct zpJI0HN(N)@f-FUj?G1|~gAZ#fvoW3h?(sxE%gIt<((g?jHWCZ#yIkbhSc2FlCr$LM z5>!xg7wR@X6yEByO(160jHE&b8Oa?lgcq8w;1N0!y4`H)+G)?PWt%?_d$wx5fvK0h z!o+$_+Z#G^ZM;Gi@USNrl2O?>+~8s*0s%3{FDSwWi%uly8T2kI-~OEfwo1@ zmb4zTR(bTfVRDGb%w;^nO-3)LDo@-z{oA@PA}@N`DrZbFYH^*W-%{6yXIm`_5e+;)pobcKCWHyFK0)G-o0mgZhhd?CG`;D4_fzBq6Z71)`q)j=C!S!E+2ZTN5V3}Pp-teFdEr|B zw$;=+-OJbfdUetw8^P}{m3GLnKUC84El!$tONYTBwdF_1qPvB*PYy~M?XTMNd!x`^ zuRnzip1Eo1npUPIQp;AJE#YQ3)>SukdcJX~8$+P2S@ zFN9n&de@50PUDq$>KLecC}hq(k5!VoEj^#F=wztN39NWGk@XV$=e@t(|IOKNEZfXIxphlR>Q8RjJ@X z){^IW)A$1{RR8ArKUtOG*p<3rh3pbO-W?trPpG8MX<;k1%xF4##bfS|lvUc^tDPU( z8g1FNCCJv<<&|=9f?@TAqUs9%^466mjclJ&l;_k#oQ7(UFFJVfAgf>Ox;5b~5Gu%iiyE zZMNGkgEg~1_Fi!hi_+SCt5Ea~W>PYU&j7ATZu3O5V{f@Fo)~dF4 zUTd2zu}*){$y3(-7e#NHJ)K|liz|oMO?-`Ez)g_@ktLE1U0H$mxV?Qd+XCh+wk}|A z$#{21qWxr1oT-mn>7Fn17A@Y$)wD}N>y)DSE5^VdbKigaaI8<*p|X1u$DvfOdXCL4 zk&hcDs{IRn)BbbEOtF){6?z3Us|2T7Zp_-_-rBc1<;kJxec>Wk?(SN-;P1iaewV=4 z;V;YtHvXOKFgMil=_REv2Pzeeo-dsBkk2QUPsy)eDN7=VMNjDM9s#516s}1Zl5M@2 z^p1R+nlXn%P(Sj+?RF(Lr>4xxY4cSTi#OJ)W(jEaxr9t_4PETSwyoXU&RIkAwvjD9+Jisy&wFu{bQ>v#C{sY~~W=GItx+a0}Zs-l(6_-n-pKBps$=fn!d ziVog6`G!gOO+!MQ=fueiN-7>PnyT%Xqdx!mV{eWf)y9 zd*&Ygz0G9C@#LFQ2RJ7-^*?ne)N)<*!Rf&(o1ax_&N^8ljZfb_NLD<>AhuCLIr!eA zqc%U?p3U{Xus3n`r;QQ33xtgCG3`G0sOkFO?Ym-Lcuwr)y}evSiRH!W&6S^QBln*9 zJ6r4GGF^dg9`Q>*PhZvf`R~lP)7jE~6|pVyTl_Z{9J~GcY43y|`^;89{km25clzto zfm3UhzWu7&d293G{^x(|>NiK}P5)mpZT0NG|7t%?p8w~G{qg;(OaIxa%E(>EGQPtc zM#T6ILk@I&=ko;hPu&{ti}l{-7<}&4_}HTLb*AdadhH)86u(ST|5&T@xkuyAA?a@m zm49rK|Gih{@5SJMFIN8haP04m?EnA&|9#N&_xtPnD>eU~vESKg)fy9Yu-|Omq@H`1 z&d(^#-M3=#pF`3RbaL6#2Mi1hD&S6j?dHG#=iHHhZ5s~iEo0&bYZ5{-Mei{%FqK03 z&Tp=x?|J>W{cCIU_M`R2>L(LE=9pDjxOE#y@0IyC$?SOnhnKYex)mx%npxX>o=(3b zGdaeo=-1ZDNZn(XCcfp7J-z9rvUl+=z3%3eGuHRE`KshbwdbDx{;g@!w*wO=ny40a z@l83hZ9?*`>6_20s&rZhOj6-Hp*dC_ zQtuv2a+_%QNMWMrvk+B9N$2BJC#js$obHg~YWZ}w;ig|bg`CTL-zrSJn*K)XWW=e1 zs*C0nak_=gH=I}PGyB3p)kQspoGxJx1fJP_tPz>m(&Mbax&7Ofd5;dy4$63Km=Zm2!}V{kn2tLsupKbiSSoEk z=lA_W<4<>5ll~@~{7RH{itPB^cs$#SPbFRPd_lm(Np+Kyo<>@K<(>G*!lfXg!-_R< zgMgBs{u@* zw@xTM)}Lm4*y-J$+J}l9jvbb~jQ?t{YH~2QeFzp{=K3g9%CpGgPnWro+aHHZ8&+&) zlM9;SG)1`~9GNXl%%i3vx{gEQ%bC98OXe9>rpp z4msZ1JR#iTM0VLWKCVlt;#K*I3U8~oUAGt3;a(Pfvk%*<5f&?AvKMUC$eOiYOXqp7 zSn9QWvG?ZP9(&Kb?Kq(f7#J>?CW~A39d=-7Yks`r%$YNP{+%z2`;t1Hizob0xzhAkMI0BN2A4RjaQekp$N9>`^O1uK;5 zkDOB$op{6Xz;jaNgoBrxM9kUl%lzwocwZ)(LG1qOU=b`A&GB*7OH)nqN?$(s~ty;06{rr}o zoiQu-eKc<2``;71ZsjZ0dCE;PliHG0)Fvj(lYJR5N$q^I_}|FYw^qG;Atat8;$ksr z(h~;G%0_R+_El%f!b10zUCFM`-Y_>*^ijYht*=Lo&u_KMzNVBNs3M@vUOYj??1<;B z{f|wI4rLT8xUt$E6Pj+p;=X0c-*302Ul_Jst1&)unXjpZM{s^0-?Ix-@3RZ8lS}q! zQPdVLec(Ke?_>A;WS(*X_t_?eH>&3B^HuUap1HKmT{d@;!7-t!9=i^woVcV|`Pk4+ zCYN!6=$2-Mh0ZO#J;94lg>=-#uga=1@R&3GzRI?&Ew@xU>{h;&+Bhv$OyTL5qpB$u zet*R8hh9B7f$MK{h4)p}>&mgxbseX<9fcwrpKN9-tW@++QuL@dkl|y$`z~XJ)c?jC zlTRMm%KMI2)@atbkk5JLHor3jn|vN@R`uHGsx;xK4$I75C4~)6s*Xw%e#)P);9|6~a!PWdrya);>-8K<_TT-x?R|ND@bvKb_^U5CQ!;I?7I^$G_+zi?cv;{s z*Y2b9G*ha1wstdL^eyP*O!>}ZBvo$`lx_BJO~2y?-cK3=pATmh^u`|KJg7E1HlgLg z^&cS~d`4A_FC#LZH_OW>{rc5bq`T+z#|jIN`{8o;ITopQ|E$>;Q2%@tV^Qr_Ubo$H z^~OyP1QpEHIDB$siXJr`Sk){qWX8c^tt@aOg_Wr+OkwgGhiQ?GYc@086nMsQTXJWi zla*v+PLfU4_bY0zm3dwUDt_1cckMxXsPmK-mYwBmGEThuzThA8N6!xzXBZ1z#8N{u z%Hb+PSeQY}xQ^TKFfcGkKx^oV#cLrbdg?0Ks-+A$i)=bpOvw;B!oa}549>d_y))TL zKnE*tg5<=vS6vyI7$sa1moNx1a5o&5<#k}uVGxrqpD!O-{oZ6b|25}#I(lDDoS53` zwMbE8;--kGAIg{FHBWQ8FP8BSap&6aILRvL3o8>-P-bqm<$R^97q^{VlY70u*!s5R zz8U+R9UL6KeCO2960nQ=@8;m(FsFWVW5X5k+w0QGcQ2bhdAS4&%Mtta?g9b=0u$an zia6a>;+D>vMw#=6)Y9DHJK6Pq>S}}FnpIWuP^lJRxCHv=)^pDjF zUuUR3I%Iz0P;mRfS$+p@I2?Gs^$wrqzl(&d$HJZoH}A{QhoS?<5W8Gj~2)yDIk?PPcFQ zd@uHya8i|0+eyP|rh7N)U4C7WRHT{bdp|;b<)h?Zj$e$6a!w{l%O%H8KDn!Z`xUje z&S^~P?om}XhKD1|m#u%I7Z+=lBTaWa&SC#k~rtxo$s`&Br@yD!#=C8j#eJtty*6PFAtOYHb6EfcK zb(fQRlJG}Mnx#hd&eX>N51Su2?wgk4KJ8xh=A`tGy_@b?ZLu^xv7PTz7q?^S4I!tM zfto8O3GZju6_MwtaGm!e<-r9ZM~C(gIZ9&lIhow}SQ@7ZId0gjz_DctN7LL^#{yXw zfdDS9A`wYpms5>RD^9FXP~vL3z`sFFjP`}3G@HkYr9j}lN2}>r3d(jbHA%U zfBr#YtEAC(;Z)nqR0RhQe?*SrL;&B@M>a!lXm7@SPA`P8EIWs=&r zManZ9d_7q z$UtH9`}#|%>8timH0AdD^*^;r)qd&SvcJ*0zNPdme7*k?Z+cNr@cvY(^U}xfI6r%+ z;=bGNbWztRsW>m2U-_f^YvziSI@bC2YDd|=^~@@}nhTFkQi#8{(%?ea;3)P&TCU{JdFEx`d>Xy3L&Zw;) z62&UlhU&)r__Q)mS0Z;!@i_^9mFfPb-g|isk4oOW88z(|2WM2lxARvI^&CEGVTvs1`y?$F@u}{(CxqoLbRXdVl-1lIDOUbwQR~Om;t6H#q$CDNR4j6Tw{uBI@ z$JoA4Wx2A_60V=z5KRkv+m|C8m->-CIW9KoOpWq zl+2l0fu|*z3bPE}C3bGE`PrfJ`iQQs-fHFf4F*-#(!HCWblXgg-r($Q*(c%gxGCr6 zv{Q9^pU!#P#jF{^ZRfK0XU$=o&%zV+EpFR{>U(L3CQE1wFF1Pk-lBP0^ZIh5gg5Un z>Nu)Q}~awKhba#b@1rnWEJ9-N&3gI zsawcr*ZIRcudpUAd$gvIv22$f$2+#k3tn0XeA4Oq93tQ1elU3@f0N<;h&9V^DfoPG zzLan_`}fzv#|}I!fhNuSE{WWICjX?$oxkJIjbGQDn*DeA?#pF9Y5(Wm>zvt6Y`Of3 zEdm!W-Q806;EiI31or`{>o;l`8Xibb{%too-Eq&+@N3~mI^Hijb6!kQuKwqti65dT zJ-lgk-)KUt8<^>A1k>MWN;F!3PIcv_{5eyoyldb`#aFCW(H4JKbLh*2~7E)K-A4$S=DV0XPSVbwGS2F4;tu77(ybQi*G}Cs~+GVL~e2;(E>YDE^7h_k(^v!y==GlJ5 zHQQY--SzyZe)wlj)UMs%{GCd^&(q_7*?zvH@PtK;SzR%QLW9re4Y@PD9DgYWo#&s~ zmhnfRmYrq7{-1ppEL^0x9X$45e{Y$*{=T;PW#E0}MeDW9;zd1|-JftN-_zMOYm*ZLBa47TkL{C;*_+#WayPr*{r|SK!(JpK z`a`=;?q~P6h1vJnSOgrv%6=%`Sjfo4p-{*zz!!;X!ro zHvS~De_qmu**O1YHF78Y@oM8t`s*bIGDk&Lp@HEO+u5+0RiCtTKut&Vl)Y44`;U{i?mc_=!KPycL(ZbesjK9wmS)ab z!)E>2gMop89h@cv>=RD?Z&>3P8_dAKG!>E}-b`mNVm9P(y(|*I_^$qz$<1FZ`BK&| z|6P{YbEtpY(?_yauRpz-T>4Y5=k@GQFL&*%+bwnAN6eJdBFC>!Zg~9JGj4AGr`BEn z{xrSOI~n>jDE969GwI)-eam*tJFl=`zGa79hxAm9tPgco99Qc?WE-93=3Lsdy0Dn@ z#lwbgdb{o@vj^=KX75uMwE5QI{Vu(B)33$Hb{)}RbXw4%a%;JXgLK`zDamnc6}}B; z6uh0JJ6QUaSFh%?=|2?tSs^S{N>}8_?^~O99ek2`=#fds+7yB0Nk3U6O>Z$RR9+b% zwPanv9#b3j;@oJ3TLB0EDujgny3nC8mz!0GSSgl821;)`-Q(CFUgz4x&$2oA;lCJxTe}vneGqlSclADYmq`jstB>+N zbWW8haD05^{wIYUn-^^<`ZN3G7lo|#O&o6-48{8lly<~UVAf1o-&k_4Q6X8reY?~( zK84mNrW5?E9seYscgiVEjS6E}xt4R$(`e%(s`s1EH2+{#YFLn_Y`?}v>l(l0=~;Z(l?4`@ZQ%~&6R!v)(82jVJ`m=Lo zew>-$r9J0T?eDLh42C?+4g##vL4W>lm-Etp^GnD3tHa56ySZ3cSXfkwLeFm34nJxz zef6=|`x_vjhH*(!==}We5uu0geEfDd-X}vrLE)Pes6!$kAW+>KD9FOX^5nXr?Xk;? z_KO8oM(!07stn#MFlqZ+Vlqt>G}B=2 z_+iLd#9zA1e!@xKL^r~3C@TXyEYPREw;`G?+r`>D6`s>6Zj z4Kw2Qt+BCdZ2WUbdhQ}Wu8Or!cBx-asmNkrVBmn{Cx=u2GYlH8{gyqj)_xh{a({u_Y`giWA-LDxosbApZwFCU$k82m_U#hU#9sd01k8;y_ zcV~at^V;^_krvx~2cDc+{QlmAe`~oGX`H;USM#v++McA`WAA(=_wP8-f1d!6B2L$75$`#dGxyUu&DTh*7x$d{%0J@p z$-Y^9tiE1?{i=1{a&wD~-(C2`Dy`|%-qaM-!nawkW6q{qL7o+vt~_3T-^C*jYTWYF zK6Fy+;e!|!-TjNi9`5b_CVXGzkm|zIE*brtbGAgXB)jbG$eGw_u60>Y>7>@gKSpy; zeEjEsWVMS@_ZwfK`%x}+do~yUzPY>O$*(B$jx$G?elksr5bX3-5`NIu$nBCg<-}G` zb){v>->!A5taD;Jv0HRYNK5_21>z4QEI4)VD>%ib|7`boRjYEs_l&HIkFQFx@=;aW z@~BJUEf(z8-Dk9}JMiht+daI#tJgXmIk8A;yNk&mn~RS!k1jZqb@KPuyFM?1mfwD~ zcYc?Rm;;*+!-w6myAARbI+6@*64K=LzQw0Wq|{YQwyxRVShJ9Mt^beDGvf~Naw>Hw zG;suNox8Nmv2DxTt<$(xT2;@tpL{R&EPq4Evj^^v4)@xKU+TU0idFE5)Bbn;rB4oB zebm9b@!M;~CJv-Mzoag+{l8lyK->ef=t7N~>epa_>C~O)~r{pU(#0zL@>>*-9zgEM{ZdX5AUKZN-?Si)UmW0)+kM#A4 zf-&y@UW@5>DCkAJc0ZFICjRE@ndLtM0@C6hIeYGxQ|hRdSNyxtNPMx(8`o!T&)y1| zKaP8}*Yxfe7QrXnkWl!!W~D^-2m4G6^PdzRu&yb0$E1n{dGU8n?s@m@{_~p`4lV5d|NsAm?MrX1@;W&$ z@xYASKZm5>Y%@AKJKbwd<~{}n25xYkm0$Gnz`y?mHuulp`4w@Qfq_XBl5Ouy=UjJK zfroYT%r$xfJN`%3e-E<#K3$_|f|a_&!^G8fZM!nho0Mku_MH)Z)wRkbWnMt=)J6Gc zrE}w_CP?ra@Et#HC^_-vgAl#mQvu;iE^?ck-|V?ynaASKhtj7-?vKh5F>!F+e`}X9 zXUU_MRv)ME*T)#8G}W!trq1(W%2?o4@3Yt_U~SprhODgxC*u?&ox>Kc3(LP^^*nsv z=Bnpw^0w|>bI>ei$Luu^oBqbFby}y8qoEWw`~HdlQa8)bE)Ut{Iz!Y&D8$97P*DHAspX#+8A%70Cv_a} zTGA~Ltb1J5#Ud&@{(k5Fve!)PjS^gkA8<-7t@>a6NdMs7nf9mH-}r5rTR&sTb!Wc! z?Fvv(nSAk-oA&E4{=WsAuUaeSCSUyIcDnI)hHc#q^CU(H`1!e8kb{GR!{dI$mOU3A zt&yDl_5y$VWpNe|cyih=UR)VmA5923-FS7nvs*s<_2b!!i)CXgHJ8Y@e+hT;vflVf za{><&2z;72K{E1kwez3o>!+|JW#(7JBxTr1ORKz+7q~@Da`Kt$7T#*-*kEJZW$(Jw zBd*`kYo%A>Oqbwku7OLu}KmY#!|NQ@}U;qFATz&Rv9s>h210)|L zNtiJ>)Kn^%b2tYU_&9CUt!Q|8wBWz@vIO4>`-pW@=4vg=T{Csxrp3!O5URD&#a>KZ$JIUHN6+ata;ZQc=ReaK!Z@A$T9-G@s}wgqW* z87lTokxGrpzv=cicoJWVC!f;w`Q4Mfuj*Z25x+#)mD6|X#pjp*T)i~ms@zJIoo_tn zaurqYc~E9-eoD?KjHzWxdcD-+xRR-YlH$$-^~EvsrTJxSx|;I7Nkiw0k8Vs7C*|gvs`jw(cOUTixxk}a`ix?e z&2H688;@^N>fqK4x_sgCa<$VNXK-BZwzraf@cHhM2zQo3<2nB87XAP2*d-GY)}lH2 z;oW;CyCn81^rpIY?C@P~qPk%k$3-cVF!76PFVxq(?lKUyZ#ENtxIL)*{kPXrorxM8 zO)n&SHvXSf@?Y5M)+)|3Jhq9_UxY43D`*KGmsZ#`Hzwjf<3;IDWj_TcJdKih-zXy? zpy1H9X13>M=J+ppdWP>>maMrw!HlnFNb~8>*!NkK&Q|%f zj2%3T*HCl(Zul{%Jfl!q!p9R=TTeFI~;gEYij58Y26iz*Y0Uad7ESK zpxAC@Z^hyXb(=f#PS=Ed=m`I|W$KR;n||Lu^Yh~VFN^EmmD>LM_8Bz&|Kk3qi7B6F z6@K5p^nIPz;l|jAE$8C4ov2v6)^FF%hy!PP4^EkPurdGOmQ4q<{~VHjeMq-#^TQSf z1_o7dA)xBixctET|CvG;g8m=4`~UBhf_?8%M+v_@xODvdRt5$ZXj68}Id?{81rgQ_ z`={3*e0qo%Wx$NApOoHoz6K-Hw?pHb8L>4$5Y1^2}AeP(ms5yw~5Y*@2f<_TZ2 z#U68hi6hUaD=!L=?)E#FeTTp6fK-2Dno`w`MKa3-6$K;DHj1&ZGl{p2qX*6ANIviiK zMD@n*y8X^aFNygzFHBV0v{5SS(z%UtYKNkQO`nhHw$8UgQT<$J<)o^C{%sL{8YV=;ptZ$SDUAIORHBqS=SrNRSa9#2^U_Ac&Al7 zB}81XaMcRelQ*s|J31$bv0;bcNn4j2&6gwRFPih9iD^ME$2Xyik8Bi=U68U4a;eg& z@?(f#u`CxYJj5)t*Ev>yuFSD{N|9A>x(#GqLng>Ee3@h6)xz!8ePPSR#V#h(n>S{(`V1mo4>zs+po4T*{`7X?B`lVr8br%B^}dKj(h=nm8oo99Fsl! z&b=?YmLKbSg1Ncf<=t}E2~tb0v2WOaLRMm{`Xs*2JAT~_H*e0`r2GCu%#+VQe@_&; zl{j^opw=|$1wz8Nw9VaIFL%9IP?(z1Wi!|4ilA5VS2<=Dt-r?<)mWoz+?F5Fw)`vX zeRAdex3^d)9Wsz;d&p(dbei+Si@*8X^EkU(^QlL;cTdk_1^y9(K1zo8t1b-OX{yCvvH*vx7L)mP8T}rx@mB(G5X>=%AUQAjc z6*njJYJ-@2=j_BOal!_Zgky}@W|X$Bc(QiOQ>NMNVhOLlee8DI_Ij6AcaQ645%JUe zb+h93hKfyJzx`MAdIq+J9$}%36B%|sd)nsoH%z#=UFocmljE-rZVQH#z8zCo9Cl6U zj$%k*$gD9->1*^k-}|iYjQ5rpO7$dP3@O!Qaq8n zYISdxpK{eSII^R5X2MyP%qD>r1s2O!4Qy=;d>?-*o_gySD|Beh?Ww8Ln_I+f9OE{3 zJMJ^~I<9&6#!^M=st688j!#@0ME;-Snvo0|PekvBGuUbZ`C`X^%iYVTmL%^J{$sR0Ff-q<+RepcQO30%i-Vy; z=ci9h+c9~m@zN)fElTr~7qi-My}f#@g`w-KxzvOszofsO4w~C5_Th5u+olgwPB*gJdEW3pbhJFu>NF?MX)*IV@65#bh<3I2PeulK38SD(Cp{-UrPkBq?s#;^BfRlQam zh?c3g+_Q9nO4T&SirIe zR&$BxaA;s)WMVn7RAA@(+kAEG%?o9}EGW}?^Y&Vzhfi%DyRF2Tw+T{L`kwB+D+sOq zi@q5*h)0=%S^ysoGC^kV8sMxvj=&S$taG_0Ue3B!DKK?Q;KfXVR#@V7w!oNb@>akS%OiaY2bJ+0xj}?lb=69dQ$3vhse18r}LoVxln`5wZ zS4zd=wVT`X@(*rtIPiSl!KQPEd~Y6dys*QkV)5Ebm4599XGI)1cPmn`6`qFO8-#!T zU(f)$^%9bT4>W9>`f-Xn0|R3?Bn`j4#aeXOK%n)ZsHDhYw)gdyKS?oPQd#xt+pU~?3@iebKbSz{RL@^Z9K=eeO58d{IV5mI-?%*!D+So|yb( z#?y^|zuv4^3mTATU}Tx_XM*lN-UHSq4h)Pgx88}HB4k(u_83~p^sE0_%qHMqWS?bJ zvu@%Z?$uM{{_b>p6&rEai0z5Jlg{S%s%hsKH~y=685Vo%Uc2L!(vHs7AMet{rI{99 z{;I9Qr_{dwxTAp9dMhJ`6Dx|Q8BJj<+Uo02v%iB`@vqTunI~0@6JCRc`y2iUJ&`?d zrR&GOuXn#;Neavz#3Y4MXpxt`WmTwjy#4?G|M~Yn_q@L1&%nSS4=(-$B3lo< z`hQ`AgTexX0*RDA|5rEKAISKb{Nn#^mnjXeZdm+dU|?DdNknI^w{B{7;9{{I-6ti|&_dT7%yjue-%wm+6TYj2skar<*hjVd}1&6B^+jhtEQnB~GIJyYedHF|P zu4~UcZtV6Z;OpcY3ty#kIv+`&=9Sc)R|x9(O)VWJBz{L2Gb<9iq%S|nd43;H}CzL@1cL#ed9^h z7WUgrL1#ZsofqR!u|ZdXyKasC%af9e*lsgTVk?+1+1Q0=8|xB}56Xr+8!jZw`MToB zuGaXICnc5Gj2)((nem|i%M+f9%{LW~JODEy6_1Mk^YcF^U^|01Xv=~}Crw@W(;C-A zU-itdWFdI{}!?gsNe*tWkx_K`sQoPWEI*N3>VcPpQsCl4A$ z+%7Y%Qnesh+u9to+UY|LXq`4RujcB%%Q1MBqyMo<`(2*?r#8*EIR-r;y6+10B5m|H zL>jy=*WDLu@G!$*QH0*-9*uW}`nS>yer}L|n_~c~F1j@S9F+dHNEx(JYL&vDgVJB7 zsezWC?v?qqUG8JO_Rmf7U+1X2%hSJ{Y%o30U}v;}wXuGcyS_%v^@$7&4DR3zZywMv z;lPdmA2t*SEJ#p*R2N{sEqADoj|FL*S@ zLsL{pGxgMFjr1>ze3E=cRWp5#ik2-^jdW{F=3IVblD_e)^0P{+X$xIB+18p}`?|+= zuAvvRzvji=8Ly}9S$Q$o(L3qOmh#y--hq?U|METlR?*v+aIm1H$2wqf@WucUyQ}Xy z+|`p8E+{T)zu?*2{^Gst#DmUy_hcuvtr3)VE z@+^q*lzH&*j5NnAue_2Qx(;?6EySh&&d)|&0B`5tugab2AJS<3CgSDDL--x+H4 z<@9$x$#|ioevrfRv&>^1w>_5_!+SR8tr9C1>skG>!Q5x^pPZ_R^LC5-R4>2#F5;7t zQsq2r!GlfyX=j;lgF46eT9*C2_uF6DCD6g*_x&qARmr!ybBg@`ntpHKInQBkvQ|LG z|GE2`)UrK7y&rs!38+cUp03p(AZTTt-X_=~Yib!!$lPx|-k@nIEb|73we#v0E3M*Lk1PPBe35D{QxlKOUvQ$|Wu z{H4XR+;gjiw4>Cdw${D7Q}|oxho$zvKl`qAe(H(N<;++h^Dp!;NB$P3g1F>q{04$s zqLRas+n9G(xdjVfOAlZ7bl*ko%d=i=7n=3pZpELsS$+H7)s$!4&uRTopkI^q>fwj7 z*OS*CUt-m|Z~XyT+u!Tv{k_Yevw(GXwXMRbiuG4Nm}blN<_R*cUbp8OV+X^r&_#zB zEw&iNJ`b%qm98{rv-Ir6+BFUjs;2h1ZQ0>nRa;`f^{Faa@`AmdmfOoGdK^r1d_OvG z30ZwrH9p~U@I%SCEy*=Ee~8_0E9~EM^2#0N^}+&s{CqciK3{3{oKa)S%gCz?>Hn=Y z!u{>5ExVc67D#mUN~)eYxIN&De&%$;x~kr$Lza>a76m6In!aTB&HA}Og-xvX%>VO~ zo=7Ci$h!L9Z%g=^yy901yLjq8-Xmv}+F$bsHb2>XP;1K1H5-C5?W|X%%|6efE0^97 zzF_+g%TG_g=uCSZ5c_{-daV3;0eOQHspg&DRw*ueVjm}VH@rD6$<|so-=yonWo!ky zJ23_Nd1!$SDk5QfUEplr-jxtG^3-qc#0-X&1)5FU@e*OO7?H7ieMF(!bn1A99#HfH-`x$Z;1x?@L*tMd6 z-?gQOKx1zAUc5Se`gBT4%C>FW^!4=}9UUcnGZbr9Oxn74=B|SYi;otpJ-z$lb>o)h z6^qwSpFaJ@jT^`K){OnJ1ct+@zms581`7A#j z!Ebgcd5!nAOD{JYDX#Gky_EXYDMH*M$1qdcY}45#x(hC7bKShD$@P-4HCFAdrfSUP z9hWv9UlO}XVCDYXjZW43k-I@ zC}-D@oN?I1u$^&=&KX0A1U_z#n==jz9y%!F?$DOZ7k*~PjAmxR^G;LcJ7!*RpZb)s zm!p{H$Q^-V7v8d-Bhv$eRg>55SiHkU`ufa-o`W+I`06!++U%aqkoasLz|7yhW8n!7 zU!6yerO7%5vRca`5_n8IHg1y0N{oo;Om&ET#8I!)wJ}fo3 zb7zU7SwW%R+{Q2ac{82$)~{Qq*Sds9ig)L}iR)UI@XX@bxp!h7NQ7tSo=5?2bMEQ6 z9@3ZEJj}G-iCt+t)OPDggy)?a_T0|isj`B#8@2qU!_RKmsJ4yW{@GE%YZ_g)8ot|= z&mOuJdF#lvg)Dt77E=-wCAqyiy_f9B>+F#@^~n9(p}%uxKK!-g347!0TRYQ^J=(Ij z;K;(J_RlljCkk2Yc*Nf#@ngp$7Nw_w^XeL0)+#E?hu=A9bJllxuN0@`-Q+H5j)hYm z{OvGvIe9>RS)|OqXm^bUb|Bhc=?LtW^BEtKB z3hnt@B{k`i%^|)fpe(97~)#S3+9&y@R4$VzUz8&axf7yqk9xt^RQ1 z*#1`8Vvmm>@}D@KV)<_-eBy%XpXiKTpCU|^a$-{6IPmqq=3cKp$@zgx)m8Bw?DZeY z^f;NGUy@e2HQ|)v!KXe7EfZe1TKQi)(t2n4`KzKuGyg2pxn5p6Z%t?UPXGDY&bKC* zJ$cXdbH}Wo0!}BsM$J{veiZfY^7AaN%=kz4=a-5zJ-?)$^J;z4>&0CQB{~+an9l6R zbBDX$>*Z^iT%A}Zz4Md*^sTN^I{LQP4=?#|_KC&2aE4t+R%;}d z@|0x*G399&zVZ}Om_kTMZ`AR?v&0R@J@!6;aN(re-iHncp8q){UA|;}_O_in?!Bzt ze!P6iI!GA@YIN>8Sh0BR>yMxBzIe6!;)MD3)eH1$4};tI<5NP>%RZ5bx)n_(p@0P3CW_V4-i^2Jy7y4(> z%Q9DASF)>q{=jbKfqciHgXe044qmGbntd`mf1Q8UxmOF~TaPKszI!Tds_E~^i^GrA ze+f)p!6ud)^tE#CUjF#vNgNs#I@RCIqvvv%xd<^HcJ!Ydvf+BygN+wl9QKD#3#pA$ zTx8}V+~`>ubkI$oNv&j}>&M7xn@t5JC%7)#`>CU0Z==V3<*qO4OP9}7y3j4qWvugp z$D%dy2h)N7i4rfPo1GgJf_6BZvHZ_=U}o_`;f1p6F6Xf7I0($VQqX_d{lrP77i&T% zp8i_3cZ=hbW0v;iN^?)73+%j?w_TiFsqfrG1)js!kxxvcpH5ZVbbKzeugZ-{@43rf zooiIuwETR$-C-$}iOhfZC9J(C9PCo_sFv~H_6HsU2lG_2gMtp83s_QP-m*t7;@q_u z7i0c+o}R4L#uGQ)4fwR{+L?l9O73h2CQb=yFl9OKvEZQMA=U62rl~CRMSSh8gMtpe zQ&zg+dv4m4kO$#nfx8zz`Fi4C;>=p>N0KWAlpalrW}9wPS38MAF=(FP$-8TO-gEP; ze|bRbK-yW4PayMkcNPoW5m{K~eDd`q(M_w>9&J{ti3$7~@6rMXUZc4U}H;BCb@ z>vmtw`udlDQ$CBR>z?X;T~SZog)*l*pX0S%p{8Vz@#Mkpc&{bGJ3sMkIx+L{|EI{RGHFk^J=ZW509J=siglGL;|J*V})cX~W>!lZU_ z>@^ECR+<=@`9kT-ttDqWmOQz1!S%qwB_<_;Rk<#~N{1kdfe$l0&KT$CQO!f zuy~WwGV^==-owIm-M%K)kA5+2wYHcIN|-LMg{=UDGz_uWS9z^j=@9Dn#d5$OJTD8*^o2d4*Rl57!HlT`Ky3bvnJ zbaI-`hHj_HvW7EsX7#*$y~FXwfydo9_NY|LxX)UtvwnZ9aP!ASC)@V9?cuUNVH`R+ zcK`DL>*(3#NBkFUco;a@c)O*}ESVSTZ@#fv|N5D4xvp8@fb-Hjxy$xPAG;~<|6F11 z$ondMLKkhxQo!uZ|k#=#PC5w!HXUOC=VqCWy*|&9e9{iMMRL&u$&T92~$t&5M zVkN$FKYst;z59vZ)(NTmH=PW=%5r%xel%6AEhF!#Lg7m3$zyA#u3t$ zcYL8g-%asG?r7)TN0OS4Wy|qQfAnry;kVA?)AX4FrY}0$R4dbaEZc6uo?9YrlV%&P zs!1|7c70RyvEzyB4yglRY*P|La|bha0C}Yd?0%@GG1B+Ntgi0V+2q zvZP&Hpr{}8Q>At0HSvBG$0+S~7ssgWDyN^ws~f3BPPoR|nPfL7MC9|sC7aItt5ouy z#HwUGY3bXU?#@x|Tk`&AXUbl(T2kuqdP0~8FHh#&$tuoKj1m9ty8h;lujD*^o!9#@ zwxX$kn4+l>+NO$Gybe;xppm|5naY2Jee;T}tgM`zoUE*@ zY;A3=tgM_vBlxx&fabKcU?tL2hx`8x1kyky(#!wne+6_jfJ>x;vK{Zw&j*!AFaQ7l zzrU*{td@a+xdd7o&1x@O93j9O9jVZ%AmC|fxAFh~MsJJa-ogOmDj(|r^*4U&E{ji} zvtse$#gE%Bz2;|YPV8@y>{VBNtoibYLHg#OO*g)%>A$e)O0~9JcXaRZC5M9U``X;r z+{l|0_=bsXNoOnb8MVUH<6OJS z5z9puopXCE4PRV$Y5O8`kEgw3a?hb73y!bJQhL4o(!<++SC!j$`vwSe-uvsD*xGRK zzwT^Hod**I3%5(wZR?r%_v`K0IfAYegOAP)ZFIW3_|7pkwqu(fZ8YbQ=x(07N9}u| zh09WQzej@2FD2xXn-dKE9fD=&Fe|Y?O8D|RfA_(}=?!gWJJ=4G{n63R@mel>yjfq<;j#S zPDkpOvnZ|2O*Rv!w+Z@aZxi&>mb>0t5Vf&adu~{cFvoJy+cPd@9yNQEdDLuDChNz;dy|VSg{~8D&O*ZQ*@si|K$1C{>%@5 zKjCM_r-Tljhac>=tIrFr*l=l;T;cw|dyijT;(o<-%e<%mjvrRq$8qdRnb?^}Y+ocq z-rBQnS#jsXnOxpW`b^^6+HMJOFZsIY#(~y_52KDG9~DZx&MJ1oYPxCMR}uMuE!!uh zcuZL$w$bt8IWO~$_5~a!KO{2tTpF|Lfm!ryJ*o-PvyXBh%M6i@z?4 zpRqGQSIXpwYf$%+6-z`z#h5bhN~v&N+NBi97Vo#jf0M#m=1EIGyyQO&zj z+fNfy|Nr>(|NsB@4Zb&u1OL8#`seYDXG{D3f4lYX{lR|^d;eba`*T?O-;1SxZx{bL zp$joQrV_k^!VFw8DHQbYZ%7Dm_|H=Ep!*-fZ-T%<_Vb9C+{EN11oIWSKKaV9{Uvlk= z{TYgr!i3_QHZ=a4<@3?Q$j&WaNN%I>s|>T_yLHp9oK0!u;db4tlHz%#(^>8N$zH*( zstYHc*_AsTnPU|oF#p!<2BvvYpH7Q@wpw@~ZFltg?Tt}0*8Vsp$NH@%RdmIy^mV*X zE=|&MUB|z~Q)P8nW5J4?Gjo}_WPY6M%F_9HPLQ=vC#`g@phiK`#-&_3KYDV~*YUVm zc6)z*s9-6Z<@TgR!YyW#-_*JNg?9JqvUT2_`N+d4{W6xPr6p+7f##Nv6Bcgw6`FTz z`qU@(Yo9H=x`&S?(dx&t*j2exkA%LIz4!m>Kj-L{iMCONGlDPg&$)bJQ^wQ({MCQB z%dc{#O%>QzaQ%nt1btPZqj{2wH=ptDkU#0$=eP1Xv(05@j*?gYlNx^2ahSc*%)W5^ z#ofhm*QKsYX8Rq~vguiW$jI5Z$1`F2!#g~Z#f-&wUOw2{c7I7o9B*^-^^GSgZgIc- zZgwTn{Gr07?4R8avw9tEoF^G&{AY7XR$t3n!OhNcyQue`;+OeN0YyS00-}EnJ4Eg( zb~=h~bUa`n>Ay+mboZor>prb9i?kE9FqC+5sa$gA*|Y6p>kTd^1yb$U=(Sh0Q`pMo4z~qj!0kw~Cx+DxQt|Ud_4W<>sD= zzixc&^G)~Y+ZO6=*RQ%|x}g%U+uMTzC0(iiFa2Xbe(GCy`I3-dci%F-n-=(}&t+%f zL;?0xwnaR-d_nIQiZ)M4J9g>TywA7uWsYX237m3X|5hW=aUOC}!^cPTl4^vvw$w$17%f)}6K>nmj9{LZWSciM-nZLjkM9S5Nj) zVRVk@+R&24-T9_&y~qDpm#C9ZwJqE^Bzk;O7RNc4H}M20H7%&kF;fy`64Mv56ybO# z?Wt9zVQ{)(;|>nS7qew%^dz^nOkltC$a+>qy}^}Q!-@9}39Sn8Pzl{Ip{wfa%+UYDHCuVNG0&mp4wJvGxtSHSk;m-$)5_!V8(V$(a%N0>f6z(tFvINP z9)qNm<^!4MTa2wrBrglj-rU1GD>$7)Sbf_9&X3JD%9m3$F1AVDdfBR-!*y2v^Y0`3 zewkV;Flbg9T={$E^PeJ#_kE`xJWow#WnFRWL)W%Psk|bG?Ctv|w?}TM3|z>?^=Pi) zxx<`uGV?QK4%zQ-lHNA8_Mbc#j|P_7jU|AX+HDuKcKd&r0TcZ_fFhWem6-CJAalwt5hIx5;N2iFa>GzDgTzi^-FFN|9-u}qDX;;lL86-`$4=00|keG z`H+LpLG$$By04&r{bLYg`v0f@{}=qv{(t^|gMd`&ECvQ@0}B{J(zO`Z14dP~IrbfYj1iR2!`V^HGEhW}wwkA7RM&YpiJ zLi~R2WAXF}roSbtR)0{O9o=WZVwc1m{$+amnq2NgTbEtF=lPp1bU$Lb@T^PVn)4lv z6(4469`JLH;LrT&IQLNX(L9e=tWt0L-cHcr`LfG)wW3~bTi0EkK3gfT`*9qlD_Fd& zo6V-);PPy8nsVvkLynCencsCMCHY&UU zY_kL|9^5bOFXwBm7F8$Z!E-@yaM}?+7KXLU$zzI29vtN@-d)9|-V0J#U&mid6b14() zYK46M(|!MaTOF22a_;3?v2&-;F()IQkFOL<9*4|{`FggspP44I(h60Sr}!ZDmuYK>W|QBMist*ccyn;ey6q?{b0Q$ z7P2H#&2)LR$P}C6_?5Z&hpd-qIZWKBFDaexI9^1K~#eH|xGpH`cf-qBJ&aoW^eU&rDI zzbW(PuDf(|>%&(NwDHFM8OxS!efVn4`KuKv(Yd~k5OFwT;`C{=R<42wF4=cz>%&*; zAH2-Am{6_}smPx1UeD`Sg~H`E6IT_A8I#Pu$8neJA?(ty?bUxo7U)4>yiHcJr2t zdD6+-vBz&k9=mC6YSe%2ai+IJ!8fO!^x4yZvHwb^Xs6@sw36A4rfd| zGVxil?z=z;%T|Ki~G*JUDdz;<(F?ZX1wkoz_Itz`j!u;r)Eh_EqZ%B;m6lkpEFp_9_kj{Af_L9C&^Ii>h?vC zM2`nn$MlBnR!+;^YNV>cvG|H_@V8rk4;pm2_ALJIrs=(R!nc;p@Ll^P`3^EpdRSm{ zF@4$3$veJ^IPWo-{HC}zP0z=8eUQLOrNZM^id&K`r$juQc{L!(viNlCgdd&eZl@(J z7Tw_BwCpKye-cnTN!{J@<*8qasunWrD*Q5!gilD%o%`plppmMjL(+kXCzSW)OcXyJ zB7V&&xT#s?!HFjm^v_IR%qo6pc@oF35ZTqA#B9&3w&Z@A@%Yxm;E2gG){|D`$cP`l zn(^$w!ss*0wI5!dp%U=mMu=J8^kC0BEzOmsaSl#K6FT;^=$vBFJ9$!`*WX&Oky*3+ z3ByS~(M5ZXTj$)@yn1rs=ZXh=3{))yq7?(b%N^aTaq{FR!{fQT`b!NqDMlu))t-FH z>b&yry^$B>rLQoy%~4j(GG3niP~3T@bY72nq-|lwgb938?@y{|o#MfB{F8ZW%Jc85 zgywy1UUx2P&cTNbEtv-k`ZQ+y#BI&lJ$3iV&~gRE-AyeDCsQV$R6jlYNWDpW`pKd& z+2Yxe-#$6scg)FVPVK)^@u$rbh&y}=Pmn-$OA zOzahWRP|)}x~SS_Rja!?kB{hOi*7G2nrpg{Lp$$i=jHk{#p3G6n!`RUh%S88*(-c1 zXM#^fK->L!s(yE>)_xQ+*-q%e%|LWU(*x&(~9?XP+2;uI@Z^GBb4Nv>f+oGv6l6 z{C&Q>v~B05O0}lohteO`&%bHvT_u_H{^+hZ7p}K$+&Pc0-EmThg~y`1A2Yliww0Gy z&$GGd)!D4_vLN97i?TQ8WU3eJ-1}elzk~ZTM=O~LsV@sszVYAlZ)WD(`Gf7_E#0$y zXZD@E_TZUlS@3#hzKcokZ3X1Z9>3Wf%6DV?%{4klA};=@X zWU=b;9sY}cK4MW&mRU;X^=hq9Ag z-ZJnPn#@XRJzUh%CTo!~>3LK|yGkXCHk*;_mriGZEvHZ15^}fC{T=U|I zhC$+FYf<2@$_@y4z=Uw5}79z z2gILCyENOx=1FRh%#^GXdzBkpWUqv$+x6MJ>AkRRhAUT;C!0`-33Ka&2VZh}Iv&qv zX5V-{mqF#_4TF92ocI0Q_E5N?uHeahMwPb)J@3UPy%$`rEYd$|iEOU2$Fwg|ydL)g zS4!=l{v(-zw{PwN#b1sVeswImd>T^SbzCaXt!K%6*sSPX#~8~enG{mrdu^db&bpSI z@Gq86_#2PP*78-VoPDwG@vbS%Wk((_yVbU$%JpGDc;@!o7v~wPT7UVPpuB;b$Fh@4RQ>86k+RI*TPrW5b3ZfTAu03(~&sLBY zxcLwUL(Wnt%7rl?B6-U};%Ux?2pM@v;^!5yx&Z9DK>J z>ye;O6hqF^MaRxF9C*yI@`9XaAp6AK47KYR_B>^1+r`kdjUlCiVbKMK`WYYtbCxm` ztqfVPr*Hq6WxMwKhJ+S1wlH+<02y`g<>JW`((QjfLTRLdd#efo^UpiX-yg8vp#T1V zg@%Ij0txF4-WLR{|G)qL|MdkAvNHQ{`YHF( zBtzcq39Q1-TN~V0#%Rc;G@J_ZJ#>2FOl_^Jk3471dpNv)}M1yihhGg9 z$#y%pzc18nO+Mvj!6H&)>wivi_t8%;Gkvl@+;&=!IiWe-vHiW}yQpsy^g1TS$OONM z*i+G|-RJ4Az~X7uxAMJ>hJNvf+fEl&9}PX8$8<+=z2gPxKlhy-^Y1gZ^Xf?pe(pZr z_`iz(O~GrEmNoLFRuPt^qxW8{cE3_@}C^fKcDP%Zq0qsru!!(Kb(Em z&L?!?rt^_$ym3z-Jh)rwGx3l0wzwZ!eo!#@Ft&Q=blrFClwOK+)tQ$Fs(02 z-Jx=M{j-bvRHMzlte)d{Xi5CeuP?%Ps&Qs-Zm(g_`?7kDvlGv^33B!BQ>&(K_J|0s zdA+e;^Xfd=#=9B1-DTO|dU*38D%>DZG3?FZY#QT4$AOC+l!!B-S%7Du$ZcJDqtfBx~+CLzyUe)&BtFrRp}d{zF+ZLcF|*J%|NPI&rt zqOr&N-M;aL$4^h%ZntGwqWS&wpE*%h&C+_iUhie*OYUcwyg=dFGCi4R+7@yj&x&t+ z8N5yNlUeC8ulmnh&88l1ufBIBKIV7rn~ckUQuoR1{%OS{-`{vx-HhwQS@G?fX_LHa zuRjju+oQbs)f0}j>=ReZEX&fVpY8W_$En0sM;vy%wp>@Fb7yV;7lop!%&OP9-kuF# zSG3_23rF2&UKZzv1r{PF_n%6fq>ymE`GN#kxVJP4E_$SY# zIfMHq75xZky29w4-cdBw%X_w# z&YJbj@>qr&dsFUQ-_6C7cg~9cU>W4n*}%mTz44sIo6S1E%zV{PUhd&yxutI8U75Sf z;QfF3%MA{TlT;jcCe8Nq_bqA+ZDjbGQ<)l?l`=7R*E8EItW7prXAP&`Uv}?$sj0`# zJvvP?IhU_Y`d)j4om106>WKhycjH8zelwH65-E!McUkg1izToybpUyda`}QX%t4bHW3~}aJ?0s*SQM0Ds^SD$#*)z%}3Y+$A44+;$(~`7KD zo66&29bY-=X;RCi)+;J0d`vwYba={Q*Q;8NE}R>$WF|^o)Jqms>)L4Db=bt*^5B)j zep|WDxWw*ubeEg)?%W>6OoOP027hyzmc`kfDLrKKyys#2PPZ9FJ40gCeY#^6*G28U z&(>b#aAfVPsKjqae%0?as9vkyR{GX}`I*{^?SK0#FEqcK^pB}J$5i*`9=n-X+A}Qv zM6_oZU|U7?_4Oe`I*_3oWD>G#et8sB%-2>=Utj-Nl~#M0?u!~7i0In_&^GyZ#d_~6 z^xhTgy(`s&h`i1=fS^}d25Z6%%G~r{XB#}v1PN*guw^qaFsMUDU3UF{pDtw%O-t{Uu53wl`;Ui_bib zoz=L!>*?J?W+$BNjvSTvT=ptJQdcrrakh0x+Z>hY{EKFtomS>JO)~AOm)#n{yl=Nk zx5iG`RljC}?LqA`S-tm;sU2r4Ke_j8`WnVa*BzTzofYDLZRhFrYC^>G1J~3}h(%qs zXLMTIGx_N3$9BO*Wl6=(_j%cG&P=v?%yMw@-+~EyB~=_}oS9SG{!oG4*uzh9;-$9% zpV~GydDz_MS+DfWFZ9D~(X#;)j?E}g*>^gl& z&%}lC+GEtF4-LTN_dIV9O2%>^PC0V*)2}hpa1{L?=aqs*}r~H zRE=nnOSs~@T&JXVO4pyjs72YE-%nYZ$LSEDy}0~SQgsO5E#0KMF;{NsSUr7~B3B{# zIc?D#-y8F{t+Oq9p<*m>^qpnNBp#PXYi#DK&S?2$#(Fuha(2UuMNBb2nIAppn6;K` z6YFVT)}4(@r#N~&+a;CaYs<>wabV(Uho9*)_MG9ov&uo&Vv339(@*#BD?DadX&)}| zb;eQG9>4R?_uZ_S&dpmMShTTOHZ88qbiO<7+yC4H8~J%Ru^+#-QRGn`Q{Unc8Y==in_V(DXNg`H=m} z(jOAMPgC3i%BQ^TTdVUKQIPq+PhAYd|Fh%gT`r*Ed^J0LB7udRt;A`uKifF z2FieNk;t+IE8$X$4jjMw=-KyQzyAOK|LWuCip6UiR&MIuv}@1BYbA4*#a7e@re>L1 zSnBKRM--HKgh$zXdS`S^%AYz4aIyc%|BSa4v2!H53=3J(M>CV>0E z|0h8DzW@LK2OZdFdtt(XHsARk3=FL0ki2_j2K%Ko3Ic3~pCqrTuDtVqk^aB7jV@V| zr{4;HacSD2a=QDIe(1c;_krR<)~noVTDKjU_)c2O@|;HWN1fWv;*@V|j&nP<=~o5F zo$>6{ev(}K=~&yPV^PaRU*4E3W0riA(ILFgw>~`a$+CxU_^Wnl_ysox@S5|l+a#Tr z9(3_-^`*dAy&orx`Liy)`(*xTO5fefl65nBRV$1RePopWJzHz>+eS(5)*lO}aeRI> zGsN5JjbLxcnrZbV<=f~28>(^Ll-C0vJkw<=k^5febDN&vLGtPWV4ywo`x8*!0u>(2CyK8yBaR zW&OHy;k(Pf3@3xi?KauZX76JuQZZU>@3Vilb*~>P+ZvW()$M-9?=xqC9B$GU0SLSS~ZwqcpMlXB$Yu|gR1CRYV-}(M$jp}^# zre{G^`Q!ISmbR&+G^odTyDd@TIB9iF zQ{nO@hlJ%jJZ|m%@weKvhk+sO_oc-gy5;?oCvbSIn%v^>NBoiU0?j*-p`kqzl3!FD z9P)Bzx^u{e?u+Aa?37RbW3N$J{eQQ1o__czGuJiWu6o`3&H3xoglF#ge_iS(H`u79 zG`#6>c6v8K{@ewN8o#Pdvuhq~`tn))cx~OwjsmW<{@FEkb#)>W1cT7`uvx{86QqB)d~{$`TP3S#S>=iQ7zkj?e(KR`*+eo z+^H{iTb25}y5isUfhChumRnt3YDZ1ha$dm&dAp{3x^EcTkr*RXrM_#zrVsabrO6&U zX`;N$Vb8za!ZSa=JhvoehTj~q#RixIJSz`F^#g1uD)UCWY zy|-lMZj)76nDP6VNObM5!s9BQK`j;=Z9imBcv)I<5#;<2vkq+W4No=3~LsyZjHOXfe3&~!sq;BsiL!EEE2NTnj}sK>`X z*w1+T#HBJNa=pyy6aTc%B@4M$l?cAr5wUSi!IW~9o+YK<%szB5Oj{A6CY$&$XxXGo zUXdYe_oLNsJ2$PpbJ2Cmgb$Y299fH>=&#>wY19{1@{(6u*XNyr7T29lEK%Iw)AITA>WH7yTf67~3*$-M z(BK}sCwX~bn2@Ry*EzrT@Mz=ht3{;w=E@)5Dh?=;)X{dGe*J*OQWx^!4?vtgQAPJvndQyc6dxd3$^7BLO=*yW4l~ZP<5o>%kMB zc2E1XYYKjJ>c&RUmUMG)AJL#-{r&$93Fid@-tYha|GxwHfRPFF;nmas|Ei(yr-G#R zC#(;+?=b7U!TW}StMU0f3=FKxA(d5<1S><*8!g)+2@a+WJgI3C%XshoZ<~Fv>{oZ- zq`&*yw6Y{_E|yr9`uNl~8E2hiUoWIs?~8CsXy%qRw7$=zc<&CYk z`A0xDZH*s`kb35<1)5*}^UP0eoSnKe;KUK{pef;@vdwE)9`6?GjYxTRid*>l)8MHM zPZnv$fA(_A`gNlA=?bq)K94%s+LHvVg+JNYTuBXfz4}q=_;s`A)AVB{ZB(A-v#$0% zKc{`u<*5%BYDjANU6|OsBP&f!Z|5v?PdTPvlPq?4d#_uha7F&tB#SGn)^6Q+i*|+d%xs5-w&*J zz8!3dS!cH9n=4bBXxqxroUI%-o_EEXxlSDAQoE5LzQxLI_a;`+OVi?1!wbEZ8*VZB zb7{e&yeryzw@;L6$40kn{c28$nzv!cjv#55TA`f^D$OyIy1sY(({sGF`CwOit2R&(o(LU2y9D zre_jDPnzudCWs_>^v`*!?)HpngSFkB#D;)%HiEa_-f#P&Rk-Eu%=62?nJ)TOYGd`5 zKY#gQw&u#6mlTAYl5Z-g@QCp_-Fe!4LZ$M)9N+Ew)9OEe*!;7Io#yxHpQm=s#hX7D z&F+s%)N}i3XE$fT40FR1f~(dpW36m1y18QELg^Vr-=^f%HnW}Ep>mz^-#zE%3-UX? z?OF^DKka`~|Ml6zH#@kP1M-UX^sgSiJ?qiOkS^(sAOHWqDdv7|$%7+N6Lp_6Pcn9D z5O~JWA15y`DSpi&`?jKm=3jrjvixQ8x}ttD^VuyAp6}o4GW&yjP3zV$DP5+kQ8zC8 ztrAI`%YWm{C9Q?|wT$cXu6ZrZ&p1@=vG$6T{-+}x754W%MfJiNCkv{bTfW_ZvC*wE z?m~ael?I37`_3?R>^Xjy$IFjtQby-qD-G?e`Ui96tD?O$D=llEaLoVDnqc`b*iYkF zI{U=QITIIec9Xezy=8*W{9jLO|E>0!a_K=~eMekz;gW;1KirIbY|@kx+uZJDz1fiQ z=aHoA0zNl_MO=mJKIu*gvA^KC=!&9%=8v8mUv^lVD!xCGU7EtnI5F9KOV$17oQoN> z??kQU+uO$Q@}sNvd*7Ijc^iBt%db)ONt~*1>c_n$oOjpxJEoL~#&?U(2 zopWLrgNw;3ccE_PLJ$5K&O)K$&e z-ExPht?yBd1C9$?Ry^of`<%tkM6mbhzo0ahh8LbaTm_c*TE({sGVJpt3Ei0 zO-thOy?5-*!7DTG-Y+r8vsilgw#d18>TbzBh3i(_us>0r`q%D>5HIsREWLU*b7CsD zY0%0Ia$LZlL()I@%fQ*lj8@pasI4(UEzyB+ZhKtd`UblL{bmzVL8pJhYp?l5Zg94# zk>Ty7T0xGs`uh5H5&n)AX7!Q&G44*SF+sEQJ>W(`7==Mze)iVsK5lD#9V!?Y81%ul zS;Ov>@BalH0<;%i6L4rKxbXkM27~|q{|6lVKjVLbt-!zkpC0`Guke4tkq-wZ1SB~A zdZ5O@z^VwT#m-!PI_b3mPg~;At#=Cg4r!LpeEpV=blh@2nE97} zMp`O|@t2cx8I4~z2qX&k$Ec={aCmWp+j-SPTB*}{wKylmpSdH&Vrax`AfNvytb zLtcaZ`;62RU6ZeP3EdJpB>g+OZI7Z!yy#8)o0G&NGgmC%u{@?FVq(y$NwrhcWPg3T z@#T(AZ>V`u!!v&`*F9naOWwLI4!qvGd!4oUk!vNY?LHO!dpwsd-YQv96Y2kC!LR3v zZ#j4jtJX8~8nV1_lYW-|Y-Q-lawii-H)*kwpc8wS)@ZA!97)<@rnbVxynecQj|E_xDfVqbBD4 zvy4gA@`wNWhZ&c6Q6aqmUhS*=Tsu3xjRTcq~+ zywy+BDD)S4)5~n2=jN&49)#rLB>&S_i=Wbzr*s)+nbZ)9Z>!L(kyV45} z&lGYSWzUw6pQCN`hS2VDj z|K?TS>iPXi&Ses|Urd+OuQRM!`fPHvgUuxJTTG3>GQ{( zZtcmH$~s>^EmqqvA$Dj{Os-AWqn-&S8mC=70%knZQ7V~oMdOTy%s-v2I~SR_X=qJ3 z#^q|$-C^0?5mPwH!&}4W>;Lu|)%-(z6HhO+{qO7BF(pFi`Nl_|^m9bSR!@@%)^D0> zSRK?TK5M~c5B*zdRlkmet0v8|6?gJaTkuC-WZsU)2b)js6~Cw9dgQgM-c6RZM&8F0 zt}0ziy}h^4=UDoRsY);7Vpx`*a8*ybvzKX4VAr0DcO`HAW|vsnkzjm2EM-r8&fXIl z`tw94nuq^c;Px!H9qZ^TZl0~z;T(lqE zOn&&dDEemKQnxen#4jf8T)10PPiW^|v99i(nDmaW*SWbp7u?IVSwFmaynff3j-}^Q z8||NFuXr)hI+1nZ3XezbUi!y3&lB7`)qTpn{VP|kx{*Ko$s&NI|%N4oSngMe~+J1bbFYpSilTVd)YG_s=2eliNbR98h_& z*XY6ypY5B{m#wS1waf9(A?e~dOOsoBvnS4sDXW1D+u6Fh2dC$_1cvDA>jzXfWlovn z5FQm!-Q=HF5>VX~P~8;QS;WS`z+eHcQ4IR`zyE*UL7-rLs#-upg2VsT`}5~32;2wN zDo5Y{|NsB`|NsBj!@EoO|DR8&y}x(9@!PU~1_su6NY(P@T6*&$1A${79cx&0P9z*u z*c-F|{r|6g+ANbzuiyT6@9n-{){+WeUR_-szJA|a(~Zk#Sbmwk)9jqhud`_uvoGeG z9h`3{AYSj$(Y~7VZ(Q+%@OLMYJf+O?UbJtTGxh!N?Bfd;Hdxk3J-WdEXq}qz7qi=2 zy~DlJ?%8tRyv)CG*5iq_*_>Ndvtw@Br%2pm%L@KKM@TlJ+$uUI;>+J_!C$UuDwZ<^ zeO&(H%*)>veVb=F9x1G8IhW=;r9fSE>s65-ulny9`53499qtIb&1T^>aCS?>pn4Q(Nc~*5QbFby*qWGnsXI3qlA~U1;qkUdfN&QDvieLG{0PO7`v8xM9_rf^kzjZjt7 z)ze)bG0*7po+fFmKd-dm=9(o>H&2M$VmI}T=cFR_N&ok)EIgj3+H_TM)g(z?*2T~3 z4(=7(>lCYWh56wvqaC7aG82x^H7^lPz0-a1bmYnvq0)!$99S$K$zXP+J7S*4iM=s( zQYKLgSM@U9UNk-D$$7s+>NATJoJ>nv_Z&RAQS;}!U%uNsPER|pHlmElO zxN%H%tHR{x+*|qO?Q4Ji5wmabmkK<=EIQ?0z17bi`9y!Ki;vDWTEEQOShCfJ*wnSO!mG=9$a|C!W1?I2$;@3{b`Ie8Ap5>Gvn zSsC7_!sKD@Q@Z2Kln;uz_Ks0=ROKb^TGkxpc9LXddA%;XaGecf%C(|%)1U3xCB@46 zVFOR()!ODs4-!>3ZF1iHX2J^rOVh&v`qf2eCkEf=T^cdc^1Wx;P1;f@dLb5*%3irYg!>nzfZQ-#OScqrN+T_piRi`GtubbKTyYt-p3c zHpatEUV7!RzQ;S_6~Ecel3_}#KU`P$Igg)v)8Uz)EX$S4wmkp-?kwZghd!+5@Aj3b za|eCjlB(?x(`hT?tUNKS$wB6xUCC=x#Q@gpGA7!q9WM2nm4CpmY)mR zEi749eY*LSVFkx0&fh5li+=bUbiIu6n85YT)rcdsz;+*Z6d zezmN}ONWT*Yq?rnr%!kz$r1Bslfr+YMgB61->-WMgvU53B;6OhY~9q!RC%iL2Vcru z8INyT0(%8jirDVwFmuXyY%*L@qVJFFnhqEfn6}iGz7qBlX(rfX4 z=9gBJx_uGvwqyINwuh|UYu;F-w{nZm>ZPIUwq#G{@3i^aG=a(NtmVX#lXN21g_>Z9m@XSPcSIx z-@m>gz(H(|!+cQP_W%5H&{9p%R-E1c|NmDAXb|{6<^KNug!S+L|ANaxHwr$I5_0krPiDK5rRAz6uCZcLQEq9)3h^69EN2!+*$Euuz z&O~OnEmB&oRpx4ClV*g}mpYd2i}ae!&*3E}gTDhix_Z_>PXP~>)SgXZko|LvX!=bhN)v~N-V z!}^AYXRcnnICY)%5t%M-#|4&Kwrd_)Xc^L>xprzRi^=rF-*aYMSXS91!RNYBOV3gB zvQ14}&~mkqJy)-(rDzD69&!>tv2}&q?8KHUQ~Ew8E)GhSD08^J{K#v)x1qbed^65m zyMIXcb=ZrTq?}j_(?y0{ve2+zcjv4!W?`Lv1-e_+-FFIY|{H&KJ4c6b?w&dD{#@Zy7^_EQ4 z7raY9do1xgBRYM;x$nJ?#iV=Pc3UoYV6{BJRB-Objf2ANi5im8p_gV(U84CjVMYFB zHl@WCzMN~NjMEv`OLaCZD%mCI(YlP~TRHo+t6z9-GJRRmGkeF92bW|Nm7?R<8*UZtUaOlU4Hb?Q$vKllu+AQdb#9%RlVN|NT~APPViDeZ@brw|T-< zmR_E7dvm3;#3k=f=N3AyKldf3`+x1d>{I!EUQhOO8;bt;`TWKIBZ4O%x2$asR1-Fp znP7A7M$`u5)!DCo7d`LLJ$|-#U%Q;5T4c84G2znG3*IL*FBa`u)3;J5CE?Pa_U$gG z6{EXOmQ)=N%1V5}{>pQy0NWHH-SE?|X58~=w^a#vbYgkDrU37C@7EIA>N-orSIKFu zlTivd{*dae%T}#<6T0Ft-;wsV@&|_L844=zEEnHeWVOIu#O=Y{v(D3xJ##bH zDl502o3=f#_j1guPn!!QO|w1XZR$^N4ounq+A@%X+4QPn2lFgac* z!EVj~BQa^WEr~L^oy@yKT9<#CU8L68^gVyRef_~&wZi#o9DCjb>h4oHa;WJ^e~QoH zqiv5jdmfFBJaN~2`KHP%?pI|LomOR!FrweJRd zB-@&tZlfz=IgIT^&dZY@w`uw zt#FKBDdBM1|J>!eO8X_pO|_xF9FA8kOmr2^7gt=)AHbw>B4rtKp5zjx_cKlj+VzJE zJlp$oTYN&>1G$a8dgc@6U#VJRl{cyA0k`t|kk{WhgDaf^>VCxP9e2&@D^y~RmoW6m zD(l{SI`?IVrT}x@kC%a`=dahlarW-rlsPLRT-s}I7k;jC`24=7?$5{d6|0QQE(-Rq zdJyyb2!r~OIoYAd_BQ&z7My>%Rd$U+i;kkQU&sn4yR}MBRxU}ZY5(;o)?ub=+49N-mxjUDPW0EYSUu>h3dcFwmfrc^b$FtH0Q-Gj+l-v)@7>Mf<-fwS^i(> zjmquUX*)O3JA~%DRGuX4b~+W%VOM-VC)C4r{!aF2(Mydpck3#y`}DKD?0?+E-b<~l7uh*)YQ(vn z+~C8~YE@&YEPYIO+x}xk+Y8@0eGiefS1qzwnquxC{l0aF$ORSaCZ=5}?j>6zw?|Jl zIeBh{$INJj-H-QVAI$G4ZwvqD*7%3}#^&_%^K7g4F);iVeKzr^`wVPt2vK6%5Zh7O z5Wf#f!`l#;jGqUjA8(ND$WxnLqw?#ZbakqFsHgUX64gf=2mc#BBwScDGi1;MNT?|J@oW6J*x5H9H8 zg8%<7Eb!nwqRha+b^%u3A7yl6 z=68pZ%qKFx3;d?Re(!N#f`oSU#x}ou?VgN(mRo*kAkl|NlRqrV>;k^frIpJHEx|SAFNYld~=T z(ATf~L%-kHc=z8QtzC=6CeB5kX+J9lTh*p=(-rXIuG*2yewbEO1wd2Gh zE4|t{URzV=rl&#`=K`+Ei#SDR6&_p7&es>EsI0olsPn@^)yCkM*!X<2kJs{NYRq0b z%QboG)~^L08~99EwMN>jdcO$oUa>uC`ky7s+E zSMHVb_azs-dsDEeY3r052QuO>yyJfV``Mzi_L+Ye3LfjcQa-57EtsO4HA7*sSK2-c z)~nZc$p0y6>?(MfwS5KGwgBVHp<3|_zfMW|RVefa_j1-vT)RU^O!KBP=fpWx#)ou^oP$I+U3a~lpIH!mwe0c%CDqv%ik4M$ zBqdUpIRxSH{ zBZf!UX!&A^itfp3m%pu!`DPX$T%F9{H4k6)iIm{{$Y{2j@0YpW=c(d{Qp~$foRe{wA$x3IYov+JlJUy_ z#&y2U%-PhBui{aAXNBh_o(13hgC0*vvH5fGaq>AUCy^r^tm>|u38v2s)~ZYv(75^_ zY}&0?0V*|rrHgKTZ~XdhM}0-jA-1Uz|0B(6exAD9q+nXUNx7ys&ve`UFUPCD{rK?b z)2B~wmajh1V>nado#oVJk8dUY>*5R)+O=n2#XQMAfqOERvp;@jkNvd0{-?sdIHufc zrc-8uep|Ht-_%yr7OWFlB*&#V@BQzu8}tqx4q3bE-o%URx2OJMy`I6|KjuN*xeT<%CsG1crzh*%9P}^ zHmwcYIV3x0;r@tw0}Hfw&jP1GySR9DaA*VOblHs#q@f10yj zuX3(UdTGc6(NB8?_dD-j>aQN#US{ZMc4vOIAGfxmzFITSW#>(gigb23$)$Qe z=^e9fLDZQ}KCwkyTq-*yFB^VkowR4s$~MOTO2wZCL#2*#@>}D>q+T%5Bh}x9Ql0;^Y#IjJ=0Nn%idH zI=OTG?H7l(a-Exe_^^NC-L9v*|7cHBeE33e%k)QEcE(#z)>m%!zTqKUqH#g<;@O`~ zH>McMJjijBN-*V&_GXf|cI-G6FIoA1J=2C;ccv;5udPhZ9!|rfzvJb!63M+dtp$*Z<$MKK^O#S?Rw8x3RSjHWJf1fDL_r+ly!y z;BO=RJ}6xnr!k>ab$XSGha;#(U~R5fovMCvuEN!2@*VkVA)eZgHpoKS0!hJI>${aZ z^3@=1gitT-4?96qvo}}D<;QAHtx&DcP~Xz0G^bYO=MLF;JN;cTpyt5U6oXSq`eknV zpV~BM1sZ&tr}Cj1wCSYd)icl_KV;}zAYsCR#sGx{|36-MV6egAcp0b_u=4+ZUC^O` z(AvM?|Not@p==0sz`lBV4g&*w1GFV@3oy2|F!FK`OoLiVfRs+eDX;@ zN9vqn#fy5Tm!sVlxL$d|?0rFOp?|~{msiG2Zw-F+WdC&L3)wAM^uW4Euz2%zmemGP z&;E-@^{sX)pCS0@cgMa1tsRRj6fK^8HEa`C$($x$apIMC>a?d*ug$qA75(SUCKmtf zO-rTvH?U?u+k0cjDVLA>Z@blPrzc*NGFh=9{C4!M-}`TFJ!0Vz;gs|9?_|F|KI3-7 zHs>vxre6fQcK?1T($L|%t#A8{%~>Z6&m{MjMsLFW!9=SiFQaJ>xQ60>IK?;zzz zah?kkS|{tsM(6yRx;-*-nY7a5TnFZzIYmk--8YyTcKiPoYCN9g&zewE^Q36wY(4*T zdBV%~udX=id&}hL%cq45r>rCrXNAoC!|k)Z_Vf8Qk88ukRwv(=-86yEmP<)zQB2sQ zwzJ_WT6YRdi==SaDM;z^oYr&DvGYOg-HY!pANY9lciqJ}j;&kw zdB|RO4{zJy$iinLki4_=S>~U~66=+nw*OP~a`{s*#j;J}O{T2O0v}%PDeF@9a|LIA z*l{Z&VMa5<3mraf z=eGS-$KKezd%Jd}y5Ogb0)=b79g4+PE*I-p{aw#4neHyBzPZn=L0H9Yk@~rvw`N@5 zuVJ0v_eQHz<7dIWCo)}1e!WtGvn(}F%vccla)pt}jfF89f1au3H|!4e+Sz=ONrH1p8MRjjzj*t7;28F?8uogRl-GlQnnXo_6kcyzSPS~+bqlN zF1#t9d+dMyB9~ixE+@1Se6Cs> z=B;$vDZsTic;>DKm22S_)EC{_?s@X#A-_VekFS5e;dIy}bkr(=HOxj&bYZ2R)dRE2 zPf`gMJw3_AJ58^5RCy^T1#fZQBXaBm&*Imi-tXM}ePg29CahFkv|vZx_r;boj4Yn~ zzrtx2>bb^ox$e!rzBpY&CzsS)`n-a_r4;^qoYGe^mDX;T_het@8MR6Fcl;5rM~WIg z5{B~^K9tbns8sp5_xW10r3bXGT9i+Ixkx}l@y&_;Jj-PJs|%ORk(#!o?Ed96`-%BM zP8`Q(IClN{^!4_4eVwJByh2s^r9I#Cixo%QPF?Xm?ftt-zu!jo`|AFF%zcplp_RqR zicgShFMsf@2`9HLKKF6;**n!o+Vj`jJYwWESoko0^}%yj3cqcA`*n}Nv*XiKK5qM6 zxg_9}1S^A|^Q_bV)6cu=wEVQ1D75#%#=5HV7LIvJ%026!ZN1}gWP8W^e*67z6kcWV z3WjZCWhm4)4Qh5_<`kOzc(;YXzO$b#Ejvr>-tr2Z+L)X>aqSbCWj4ATjjpF^=XyQZCj&!B5M83**c2nH+0-K-^!`J^!`GN=u7W=?xt~8Hl^y+O3j_sYrgXFylZ=H zx1QeFYIAnw#Pbu}N=x5&=7?51|NFGyQ{PsB!on?CC!G&XxN~vlo(Ug}LoBDwS)*0i zCOYe7aQ8+5^~e*eRNbcs&a`>{Iw7O#$_K$CQaq+d@5sXD?qqOniRk^WjxIax10GO+Bg|gZ>BYlRF&0^w}-neQOK9?%%)Kg`3rI z*79o^$CcLoUpHyma`*JRTe?r2U!VHVT5A9Lmg2ebe@-byDE(x(Bqe5fcAwQLhsS*Z zV#2lh+S+lcF~8G3XU!&}sr=%dQ|NQh6c|FIIA6y_tZ%)X+zvqSXCr`I2@h>3a%-0)te8<{yd&vn7t>pU}E zILc0U`K|Pe7yS45dbC@}m8OqzGsKimSnw*;bMnOR^5eY17Nr!Lu>4rpu?vC1 z2Z~PfPR^JwIrF-!81F-e-U5La42MLwCb3!__<8&a7keY0R)XW!M=ZkoveulMy!QHo zhG*YwnNJkjTuoSftwcSBGrBy|@MP(ot$sGwql_8F80Xa58lIS96%-it!gJ<{hJYC- z8ZLyewJbAGun10j)y-nhf!9-aKDu=CS-719j9rBKKUZH^ipVPkgM1~-di7>*6Or=N|u;WJYm|JN78yB zozK|6)M-wi^}bN#NN4RivkgK40SsN&XT<8ZN8HolLt$lfOjyWkZ{ZH|A{rP!Ktp{$EG2G=- zmHbyK^Y0=Xw`RW6fg5|)EcsNjplia{n9ql7?#x){^(DKkY~NfFhM;$@s;{OlwRya` zW7#4GqxGv=UoLe#lXtK|@)Pq47VkDer=F$0U$m~y6Zhg`bbS2#fuY`m%dZW7{o>tQ zUU&Q9yq}pCtXv(Fd9<7}SGSe=8@&x%o2oe>D8$IFGB)M)y{x}8`Rxua7U@%*$j#Jy zc~ytB*AmHpik!!}FBdF5EY!K0#V@~RYwY>F=4X9tS+-Bv{FcAuA`hciK$COLO}Sro zixltO-aIpG+K#iyH-D`%4Kz_L-oNQc-rL6)#pedPsJ=ZlDd}~_?^)+XSatX7FL__S z=*g`hnSxIB^FrGZcE8^As;g2cEq8InM52R88S?k^VFFDO(mj zH~shWo`A35LCrjYa~f;gFL|d0MyHERJ;a?ZCboUjr(hAuuNIbbFRYy^Fn{5TIdbn_ zsn{6FZNJ%a+$m>`Nc^T8|+-@hQ_)THCv+wzt*x6YtnT}eo&=kG)QSQt17Z1E|HCE1@bLqq3 z`-(@d?GY|5F?iskd7{GnU4ip~@)D0lXR8tm3MO0d9gw-VYQdinqxt8TJyOV${@W@HCw_lE>h38rTgO$d zZu0NrtM~f^P09<4wXg6nbo}^J>)?s@wB6fZi^gsdHuH8g+WYXuy~Q^w;#4J?jyeg- zg{C-W_=)s0R7Px?WOHWy2iM2akM>0^Zp?T6xTETzuJ)6wv4@ll?jJcE=X*U;X5!N& z&pm2WEPspMwR%*0rv1}Jma}?BtDbL8&${<|(Y9WnmIAMiq~e`*Mf_)`EJpy zA&2GJw?BWKI#yNsPuy7Ib)7loPUZ_X_vL$bnOyp6uyMNW_Ub!lV*0uGZ5R|5`-D!%*3gC z<0hAH`ukMDIyHgiK3~fw&qLFgm9IS){?S-ydPgO4QV9Pn#0lGJ}{&LkV>^-&nWW|H8)DkXoUF~&V?RfDW=Wi~N!~+8F z8y3|)UEkXmv4sDl0N0iUViOtVbQ>0lS#~o_u{TQke5hDOw&5FFfveJ_WxbElIl|sDtmp^*K;jScgV9%=y=kxqn zeA7M3xBie<`V^|3`>j~%*zFTKHK&!7CU|tYOj)1vcK+YsE)Er=i$THr>{4{hlFUq2 zOrQJX*B&nkP8rdI=Vl(uoLXELBOfNYSmk%(q0RBD)n7*2^RSn&cl>W}OEnfdSe6=D z_4hyHgMt>{tIZrnSSm8sb;ML;MbH6y$e9b@Cu_dw)`YWhF@9~#{C%MF&y}q|W}1DU ztoi5cvY!jx*W_xacxDS#RfXu@Z`0D(*T2-DH8DZwb+6{pDymTTj?fAaLOS$A$|E4h9Pz1b}KP#2!!(@BfVd%h*1|m@qJ~9EDU= zXJ);uTCE`95SZxTc;=eR<|{Xz{+0ijxAIPz-O*`2M?QaEx7@&(hwn|bO6IIWF(&73^Ke&bNFKJN_4vu2*eyRIVyRDX4_kr8d6$T9xE~~XR z$eolFKeKTlt- zGh!)k(DYb+BJ1-}7qNN4oC_s6CI39m{G9k{qxH{%wx*iMOkCIDbl0xGUm-Qg+P!BYKzT+iZJX zC+_JQBYIGY}5kZRxI&=S5gH#_le* zTD!$npnztviylXRN;^O?S#5sFn!HP-CntlhC_+G44nW%gV*BpM~WsW9##9RXSpm9&kVR z_UC>av-=&7gy$^XwZfK%G;%*b|NdHAf$P-bb^9z5dM4ktS@dXCXcn`}okepOv_JTC z`m}t$Z}Ce7fQm)Z4!#ngRs-CbVms3esx3R3*Yf9D6cl-NO!vvsHV z*evJ&TT$Wl=jS7dKhBXqOb(s@S+MH$w^W6VSrQ9)UOBJP5dC5K#jyCm#aj-pghPu}S5VAA(E(i}Q#vqR6R#3tcY1$Cc{ zPAqN6Tvyv_9rw_B$-`y_?fnzYeXXA=x&|0Oh+2Hc=iZlN{th80O2W8=XB?QvV`p-F z`acJ|bDwKlPH&W3`8F=E^$UaCi?|30%WDjlezE1N_G(WK`y$U0voAsFgCb|h78!$= zvxB#rEw)Z6-gMsW7~i}-xwp$0&YN2O5SU~f?6ruUDW;*l__~~x!-D5Lomvu{Gg}OT z&Shu@aX6>-Na!l?B#JFwBw^~hpzA@81Z(1xG({zaPG2n!)#Z0(c@Hk}7HrJXRGOsk z!g6Y9hl8WOP`&3Pe@Rc5O-nnT^zaB)7dfj;(s5l9)725%#qnWj$BUn?^KO5exoZ+j z$DG#>UvHQd`DE$KcGZqAib_uDOVfP{7tQUePJ4Xwgi!44i~co_6m$1TzI=WEjzOxL zpqbL8o_hU_M|+gg-0&bL=JnwD>qR;_e)WG`^Gi0JTP{GLYXgg|{^SP}{?rzT<+om1 zVItgNF!$7LFZCa*qYg>b*O#k>aV(r-R*~`2h2z33OP@;N&A-yqMXMQFuig4%a4lGD zqEo}-q>B%{nw0y~0;dX1U2r^E#EHYR_J`2kW4bqaQYPBUH2piMzxPDR!`Zo$ltk0} zDh_5DFBi-&UUGtG_RK{^tWWg!v!@scZN9?Y-#5Hl(P2 z*99tKKeuRqZq)fcS@TO9nA@yVT5o@>+pxdEsYxk=7ee0e*DbBL zU)W|2;g;6h&z)@Y=aBU6jVhn^%I;gNot|&)6JTm;20FhdCfPD5+}zRGcu|GrmQwQz zg(k1S*RLEdHocc;1i5MDZH_@{y?t((t&N>gW}%I~zP_igslIv09|i^ndvFb~r0KuG z9mfQL;12}{6bkXt>jN$!56(&*cn;!U9J)C;Y4RNUsX= z*nddssON#Oqz1jYl8sjqug}R@uub8Jl#~9ZH3wAkls4o>`0+~aYDjLEH1IKPsX8?= z>00EZK9{3czx-X@T;JX~y+5TKRzjWde0|Dm1kkH8EW&ATEAMgCndHBqdJ=`zWM@be<3RkfZJ#UuuV$+&W zHu|OvA15fCH$A7axmW7BPNxyC-qupv=*&Vj>kx@@iU$uNNNM`Z5TxmLS z^y=BSg4f04c6Pp;wx}UUonzs))$QNCR=%^BD&NkQXUAOnIIvAH=Z*G`Jv-+Ra4%4c;POY_h;aoFjF@v==SKRzew3-W#Vu=0D!-L2DY-d#|8X4Pw>D-dxz zbng~B|aPr?)>xfVd7ouODlzMcrdzK^>&m6&-UP4^8aS8;yo8W zn|JHi=RaE)=VZ0yp7xJJM<3sP+i*N%hReGA_3!me`3pAq)-pf3CoY@w_u=Hy_egaOZbytyA8=m~Y9`de**?%vC66X%SUTE8}te!dO}UVd+T|i9W^SCG09n)AmI? zQ2S&NdHKPQ9X@lSvsw5!x^oYoEf@I7vOV3QTy@ElQ_uJw-F<&SO#Tgr%!|z_#tNQN z>~ab3a*qml#q8Tx9uRb1cKMy$cP)(0ijiwKwH!X|c`{(iPcD@eW$a5LGP=|+D0ZGy zsVw7O(z5KyjGHItbjconkku`1Q^wI^prP>4%P4u-*&=Sq<+rXjR?q!E*@9_0??tbp zPxRz&)mT`v2)sz18GPo*q*d!AHl=S~X~DJNz|Ob4Z@V?EEHZY+-Z=V3>dw|^CI^nw zyhiOm!?kxmy>qk0ljBpxM6Z4}Kf~~C(nf#H&#BE(6wvRzcdW8ZTy*1Y=DFRkTAGhe zU-$afI>AjBf0ln*pnaKf_FcVZZM8!;HS~j5%$?$OLhkONVBu#a|F8T?J9$UB6Q zl$ig%g-<@-68FBlqHN<1?u%xROqF!Hjdx{F>kl@HiMy?4uMx8E#zg-U2d+C^*UM2W zE!CRgm$PE`RIazj6rTS~z0>!C%}yhc@;ju_n#^TWZ~w$XvbHvn40u zA~%nqiiqR`2MYzI6&LyRL)4e7U{rGRbj{h;pt(r7+lIHMu{TcH^|I-v_EoY+cjwN{ z?0+DVlJ>n;(r(Mw4~#0GrWdaJz&r2Z1%Y~h)uLm^`#C-xv!9$Ta!~T%MD#pUWS<=zGzR}`S z4a1w;Asg?_`e)_wV*9DC)+u$LGcqP9&Dy-;)Pv~8lo^-i@h!EK6aCd@zULwDf2K#N z-&S^;PI-%^@?||jOyzqFTKQJh*ukqvJdEO6yHapH+t}k!-Q+NRiPP%cE_=_r^~`YE ze!_LpM(4x~E5Bf~!YVue5HmXmqoho$oKjnRM-NnV4bKQER)o)cjJR z@xwgBV@0NutE}JV7%Z-^oVBRv{-etuyQBaA|9@?L_xC*u|J=Lybw%r(N~_c7xBvX~ zX2t3zNJad<(iy^lko$|x&RuN&!N9=a1g?bz90D399C+}*;KPCq2?`fLyF?!2Y{ z|F?lySN=OZ0@27AbYsi01^*3R6a>`G+PJrmfq^9(S`i;?1O;)!g1;-pS28g$FytM# z6OlgJXu!~)qQiEvaBr!9p=$NLd$)h@zw&U4^S1wM|Gi91FAD$tvq{{MnM{kSTjN>O%WX^1^n|0E$i{I_1lgQhq zwBiKA`!#&C7?>kEI<_5QFKlXOS`n*asGhmiTG!@@#JR?`e#l-DS_ry0rd zPY8SJJFhu(a$u-<;j`i&ieZU1bNSTo7ruUTJEHfX!EN?7<~uw29QZe@guN)Tn(Zf` zuKd}sL#*cG;p7+gKaJ-VZj=+8@}xRKTimPDX^r&d8!t-Fil2U(wfA65cG6_?zJ2FTmKe$KeF&Ho%9d-XpBFdr+fttt zW!ITPx2!C~rUjXEY)}(>xvz4zSmfSg>?xsL#^+W~ba48lmmTZs7}nhs+sb!n;gS=s zQ_n0*`CWG1$m6wT&@9&P)_PNp*IYklz3{oq`^!Glp0GwPnJqMX_7Q6*j_$@~9mR4E z&z!4XKmMj{sBON~ERsF2s*WLj_i4u)`*yuf{VrQmzU-YSlb`)1DWUnsY7(%CsTE}h|25i78iI2xmJB8}nL$L7VWZ#T#{ z|IC|Vz3UMFu}X&ezhAG%tN&%MR5E6Jepb&4RML35`njxgN@!~6U`Xv?U|`80rZA6% z7Um2&i%3EOr7H^7p5Axsg+}wn58psLJ{%_QY}j`3-kZ;}j^2uxf5>&p?v0lo&p&Y| ztXJS50|SFRq>N4Y|6xLa!iED292yKRJSh18AGC`ET%b-lzw6R1o?-?D=Gl+}^zE&i z^A>A}uzg@=7Y{SdyLjfzZ~JFU>aM0#b#QnJujT$Xed^ofcA*oSbWTH23&$TGk(c}@ z8+p#TbM4W77!w+4@F(a%XGSl-jGuGXAK5u>56*KaeQal0`LSMNPV2(2-&QCFX?36C zidztRHaqmt++anPxS)$o#w8Mtk1u89)rSc#@1F9ZX;a39<(es1c(M$e_a~~lTyA=} z&n@&pxagVxp1d1Z9F$11=1SbrJpH4g)R&I#MHkO|bf`+#xH>-Ye0<(fAt>~5w*+f= zryZA4VB7k~q82N@uN7$JsNv3D%mov~Yj-V`pWN`jl$|OC*nRpXc3WP?65X zTi&RmSrnoBW?_b@N-5uTg~HYP{__r}YJFJ!_*I{QPlM-&pu%c~zD$h|nTzi&HJCc< zM|JiNFOy}-B`%SgImR;t7C*e~BAc<#g{ARAm(QjC87FjS^h6YiEL+ZWILKkarAdZG z}TWDYg#XT>}8&efy)%p6Wb1^Kdn1m^7(Fq z;$IWiNi3T0U5sOXr~XQPx!(9!>9^YKQwnFxyHbmK{_@&BJ6`=E_iLE=%WIjJi{2KT zHi-OTw$JeK*~d?e^V}uv1(qDWy(Rr-)`Hhx*7{4h++EgC=McXAM&M+<6Y;?pDk}Xp z-D){$m2L0(!n($YKQsJjU6M3Un;CpXU-P;Qa7;Vbs!{GbS_$ zhBQw%sZa^azuxnt!p3i}d1GH%N44+^ovqc`Pj!?&n5;K!H}`#A8Efd{G{yIhaMHVK zm&i_$$4*QYr&FH%dvyMkO7h8LJCt*q_0)2BPOr3D#$n?z@kOKDi*0!q9+j?6Y!>-u z+q-J)f<^>Db7>G{O`ZK&(%d=4ZfvopL<$+D^{rN ze)_DGlNyaTYZm^qJbiUm-KLv*Q^j}R&9iSjHcRHU!&c7e?V%#BtDB$fxGx(Y_oaFI z^~L)Gez@f>3b1VIklQ1Fs7xZxe#?R5uMNL^ydjXjH(;9O@6%^_A|o2Ozih~P<8LYO z{O&9nRc^8Ag_cnhk3>Jezqj4v@W)NT%`+#T*>l-2$a=-Yg`3o7c051&alYK)>=)7k zr)%6~k5q}sA1@T0v?Nk&aMGpldtG;{v#>n{Wd2~JaS51>6quR zkVoj`oD(ynOvK$8T^4YPt<>);n|h;R%W9RY!LwQVg$k#9X}$cETToVRC%-nMO?`h7cspRl<8;V%0aqta<`E+RR*!GESp z%_7s3hYO49gEQ*w0+^S}D(@>|)I3piwf=zM+n%6(e?A55bX|XqVg0$tNlP_e?<)ED zAT(*t?6#1brsqFzS#$hKwu{hf(?~yi=cUO~auck|OsBn6|CZo?DNXu9^P`Xni?1|H z*;i!T>|CVK==$T`_T;r(NlPqL^7a&&ZIb_%A@oI3OlZO!2Tetl9mTI(J}kF$GVzgF zIA>E%L0nSurWy5o@7eEFq`kRxN6k>G;QyNszqVih`g!u#16%cDHqV>*Ws)27rsaza z%tFg|#yk{`S4dg2!eoKhj&|+1!>2^wvg;Iw9WmS05Ro-$nQh;}OUJ8^$TeLMm+D>d zmSy#kpJ@eoEgP53a|z<@d>R{ED*UMAh~h-oNm&^VkJbsTOSm7wSF3b=A>+iJ{6ji{ zcXj5uh}9fDs;exu+==~th`FHn%>J8ADZ0s;nL9jm7~juII1~ImRw`!Np??B4o(G|qqh1}gVtMlzBl|rr|N39E=foU= zjPyg(O`~@uyDCXJa=E_I_nXMU$HB)baI!`2QMIUyfJ>WeP@oE{61SAQVcZidj}&j^ zl?zVX{TFxbu0x8ivf#CcOLQk0Pn`WB@uaNjLiIx z4qg^qq*tuul~kOjer}qzh^J>n7MH>%A-+AgKTLR%uy&)8X2G|!^M4X zhQm(G$n*TO|IWTjlgj7C+&%icG1~aSsuaVC9hLW1hh#pIoAojCkBidOkSS9=pZ?xb zAT=@i`{B5E^~!P=D?Vh-J3jYymXcsDw^Q;fTMKrEhUTBIA57Sz*_Z!cs)p^Jv!q7n zgk!;3oxe9sxZ=s7XUX`X@8XHGXHSNErM-|~_E%)VoT_5IM$~-q%^h?`%RkwocMr}JdzfaIUvcFOL!>S{DUwyct#rgkE z$^)Yqt7YrBf4|$-6MtWXIgYOLu{>=OLXx9Bbzr=Fb)e@E(OfKO|SZy<7@8v5jr@9-KF>ld*;1Iki zQX@Ysc$#L0c*3Xkrw?CdnR0x;dFP%>Mte^>`Zndiuh1!Kc+jtQ+bm?VVf63z6R9T<(inX3{8#u4Tt4Ks`S-tbuX%<08GvTK!2DjH$>+*4b z-EU~^QZ#)J>*Z*LX9vx0)o{9$aQv&8RL}0SXU>t&Cc3AvRK{$ZiK&d&K`Z0E=iQE6 z3f+6&4UYC*@PM-+jMGD=(CAFh47+_NT=$-Li%&COz1z8>$tt(h z^6WahTazu`<``UDYWp_F;7vYgQTf{(g98_QPF#*Vaw+8EwZgl%dLQ4J_4Mw7Yd7l7 zT*-KFX9{FQ22NhPQG4rV`<3gJ7q6Avxz+PF$KcBKikml^uit1edzKLmI>@{PbgsEW zY(s&-fd~ITY*=6*?|%W@kATgc?=$!$dIKy1B7U|MI3Gxub2rcC?efm^d!4TCEoNX~ zt%B6>Z?3j3Y%vgMdFW`y!)N*Z-|CuoMK{_muWz#7wc~R6^UAspDqn0YW1SO}>I7#W zIQ-&|$}{;#CWkvdnLOLyV;;xWZ*1wNpgFs>U|q+}HbDzj&gd>9iz!ocbkE6@9eJYZ zEoCL;<#*q48Wa1HlyprQkDE(YY5fauh`l%?@V2^eoiO(l&m)hQeG5IBpB5mt;ozNp ztA57vg$iwU%)PHO=U(`H-#5EYz0}pLZokmJXwI8z_Zbd>C)}piZhhjWZyZY6858zLw?U3Cae>=8)gzA;!X=tEb9P#^e0vj{Z#Mhumo17ylV`u}{_5#0 zP_(z!*fx`+>~?u}S%}lce;aBy&z$$c`LOc(v`u#xtaG_&)K}f?E@`{|Ip2hiJ4wQ` z|Nr0crBwf;sMXd3r{=Zigv**L=!V-%b!XXLo1LGu{lsSW{{Or)Ej*{Dg*+>&{1m{S zce?vxxyo0ixz8FSf~LN0vYmGE$7-oHjlNO2J!PMNW*yf%{Wj~|o6Z&Dw)|VBo;}Qd zw(Q@@R~zo;@pu2+FY~hf!<6W(Np?1?Prs_)|2^T{&V9?(HUxHiK7Q~iL9ca%xpLOw zf29vUByf4gsIPr~>94z6m>&PG1i{Mml)_3?ZMN-c4*h~ZzgbLhNqJjXSN~V;r1vJF zS6VkOxczYGKl=aVInMrjADyTDYrfsgqvx@F@6nH?d^YQLDAZ;htuy`Ket1$A2d~8L zx7eZrS#V44BHr=V;pu)cJkmuYB@(BgWZi+wE#Z8uZ z|Fh%_+b#K1Jz&~eNv|x4p7i+TSI!4#G0bxe(YdMU_W0E#nG4PuER2$0Ryd^>+~4jV zvb02Zm(N%E)@1$lvFUrt|Jx=tO`IO77Sh!4MV0-z@P9_huP*A1laI5iFe;1B>0z74 z{7L1DLwAFXLUzE%1GmlRIDP1|e9dVyqi=sh&l0%>DxVrs9@sgUOu3LLE0E0Zp>jsk z_@l@Khc^em>|uH0S?70#mlB&#LT7i)#Huwx?tUo)#mCU6K1|Kb3T^5-)#x^y%1;Cwlgc#XF0^Z znzpimn`zmtpk_tk4x2~2UQY1-aAq-w_>p^$CThsP_PP)>`-I5ZpXw!S7tr{%QcRHZ@u&W<(UY)fz#sYbABt&CFby>KhnydME+Vy?mlbJK3=2E~f8 zEjssNA@dc9)HnPy-IRB1+|R-PPNi4#=jGX18&Y?B@rM>B`|Y{UvVU23x^Y~3&H>eB z51K_)geLaNq>BpHo4U1r>2z4)Zr1fpNz=S7LWOy{&7Y2xJ2UhPF6@ePsd%!A+f&=< ztKuQXi|M}{7xwUU)U=eIWlZE!IW*Vtuz9A?giV{06ebGHxow!q-2caZb{AW`rc@NpZ)zs5}S~YrVAWgunQqi1qso zGpFszvGdrpDy>R&|D4{oAJ-r3W8%6mK7IEq$Q zzT4ZM=)kD2zc)vUmBHhM$_Ig|GlQ|!UHQb+U0a}aS5ra=CG%iCguI}*cY7A9`(D_zx`J0U%4enl!o!H!845v~rFCdOX2 zR^_2S`uh3}kpUULh{GxM_4SPnL5l%E=dJWju2{Ubdg>f~ef`FQoXWY&YP$RDT3YH_ z+v@A3Jwk1qa6O5%}n?(As@PhI^e-- zx_Vfj(L^Vb zkh?Wvy7nGJrqX?`_wMZ6_=&}Q(}}~ELW{m;wwzxmo6>AEr~c`US$w~nlXfhOQcbE_<0i^_-|3?#r}(8*Q?$x45IGDcV%Px^qr8 zdrs8OYUig-G3V#+nB-Gx-O?0u+c{#joZ5kQzmSRHe|Pm>oxc0=&Y~yRA7qJS`>mS( z_o4Ff*7zc=nXj}Cpa0^rG+1)AyJv}7`7y6LBhHWYkskhPhLi5sSUE5B6ZM!Rz4fm^ z{k2EiJPRkOFmL5ke0}}*b(P|+J^Ire`RYF@8{Rn~E2(y_c@hD8{;zLSKL&8axijRBehZtX-q;lu2wQci}S$}6a&%S@$tee4)f9?xBg1I%(&Hb$6p+!qPEZhItCA4g+T4njAxhEiMp+(~h_K&)g^z3KZotpjU zHJjzze)YWXYxWoKkKw=C{FPPy#(~=(`~=QTD7TV3w{@|PC(k`DHM^P*Oxq;vzbUfXl;qPnyoY{55TkwBPZk|NpNuU9+>Ad28mR zJ)cB>e7dEXBK%VR-)3`$Y4>YPQjSf&tWxXRx5u(HmdEB+Mpefr;Tz?l#l`HLY5$)J zEJ^zoo%N1?%QT+;9OL7BCy(Z9dOx!lIa~gCWAqI}$vG#xJ;NK-V&6^-G_|_6JvHZ8 z#{Df@(|h?H?)XouPKv`oH@zLz{qdm+!o>b z(JouT!D6byxsX@~XB*#Dr%t4ukx3GG?Q?ZyhUY2UdwDuL{S`PmdK%jzzJ9FUYRb~Y zuv|H#W4WOVi~6(lwF({2y{>Zp`D}OfYN$;5pG7kJKDmci%OC#wy(??AM@2FROQCC8 z(gi2M2~K5SCn<_Gv8+3x^RVmbWH0f|s3tM~E{0`VyfItXUFYyW{8KKa@m-^xDchsn z4iC=NU)JDwr}UxY+iq4)hqdKGvsCugXLd(U+RmC3@HNh$SZH6#;x@+vZ{~I`I$60` z&0&>Jo!qIyuuF|TCUrqu6clf(cpQ=rUH>zA--6=q?OZRngx%hMcBP>^14lq)YvNR~ zD-BKpv;3yySxjoOy5{<8&815_zi>#-4%;~AQ3%!n%!|a-I}f4t4%YoHcm%DDjY^}# zsxs47PMvu3+ErI`lOj(?2x?D_pWRej?C8eD7Dk4v8dLW#pL%-NhRY`ou5HhqQc>KOpE&M2%LJs;sBa4fRSFc|E^OM$M z1_lOia3vKm|NQ^`{R$2O4e#$K6d0^mh?)NXzv2An|Ns9#2&$j{{jUH~|Ns9NfYNYk z{r?;PUH{K-*#ADYfBmodhZ@6J85r0?Aa&N8i&q<26a`o=Fs<5{cKp-%uXp|~NZ(%} zI3;1$vdmd_MRp$=UD~s~CHuWX_g&Q6F;9m1{fhDfi~cCAIUo3bt;N};A6^7w`E)J67s`=GFr@R=ru&UEAjul(5|78+V(hjXO((r%Z9<#8ZY+u1EB>-8gf% z%rbDvTqgDj>X%5u*eZ#_V{jYf3@eD1g|*B>IwtR^}e<>ANP0tQC`m9 z(|KZU&WFULe+iLhQjQ##Ki$(X;J=VAdz7i;_zUxhx@R`~&b$3~?~#}o)Fa_vqp^_v zkwfoej*QA9vskh&Nn{5pxNQ4(GxKoD>o-#3r^BR9S{+YcB%y!g%k#@~=CrZ6YCd1O zJ!#SBv^85#8>=$tJTVp%;QZEkIZD;%T+xEVA5{~pA7;${f8?tX`+-R;GdWT^91nYy zeLOPb6AcUjEQKU$JcEWYMCy4 zF5HsF#1JnO;-LBIi6%pb$-ZNrCltFUJ}A%(`r@Kw;yziiCG}6;zCGu5O2E1e|*;`K5^|vj)xkhe-g^{BC~?#7Hz#1Z;{x4_S=@bhDr+0 z?mpo77TPTs8MrRb-G%S>tjEjrm6{gmbU#RXbbp1+vneaguJ!y|pk`uyDcH4T`Iq4E zzpZS0zxu@&aQ;1NEFE%#&wj4vL5^QX_asHF4%$CUr+?!!&)KWhg;wrT@>;rsLBWdi zwd7synyXj$?qGSiWcAFwZbziq$`6Jbyfq1VXFAs)_tU~fuO7_zPzk*gcih~1YEAq% z+aJmdPfrL&Yn^Q=6xpcw{(gp5`mz)o`;W8i!V|mK3o_n(Bq6_K|2_Tb-s?sCCnN^X zmYK@w(z(*)@`q_0dyIBuy3JeVl;ZMc0zdD^OAp@JIu(Zqvdf%qot3Bf_d)jk*Ym|L zhOF8!^P1P5ME(1}LpN9Nsx-S*y695Hlub*YtYiD3;%WUepns~g+R20$*2P;p>H?mq znzYQ7%G{m3)ph~j_TTB=r$0RlI+*JEV`}J{vP+j2uHt+CuTiR~VuFm_2cw^FVIa$_K{}&at+W-QqbrU}ImxZno3z zYG$t^L{}EH)bN^WFFr6MK6!7uw&XS$&lbyr>_OeK2PEpHa;vV!ZITzSWKr5s`t#wx zJ7GWkUrds)naHxP<>`VvW{Jml*)LDsoKz$s?75(O^9E~2&9G_+mCEKYx9LI&_4F5dUne%qv|KB}|(>5Jp&HmAO z>Th-5+oJ22RPy7^9*6F9`BW5|a=PxplJ_02{%-zqbC!KV;E&Fz)0ej9O$vzLTyEw) z|45Ga$uCu$3JULpqtuTq?pRVatWl$(Nk0y)P`34J0{LDopN|mzy!T?Y-9Q_BnHZ zw^HEBeH`b%&0MJXgU8g4t7g@~#p}&3$GZQNdEj`$JJ4aPPuHTWxu@^#vdDX$YAU(F zA!5~@HFv^FDC%k4owMd;YxhX>sp#-`d3gd+%+{)ok0!^e1&CCN^1o_E1=n@qORnO+My| z0b)m<_#bD!#mxUmTIrl^mgTo*$JMv_Ppx|CDj;!d^7-PB4_ZxcI>XESOiP+4On=}g z#k;a^y+Dhh>^rc1-@)zs4({E% z_t@D>=Pq4^-0rjc*qLL;j&0a?G$!pk=$sA*aK)W4Yrn#Or-BB9_16X73pj)~6e#@P zzy3YwviAS~|L^~QKjD18!F+gS{r~^3TYF~JIzR>9fBt$Po`HeY7*boGxzbwn*?{Lj zp`=J#(Nv@T|E248_?DJ+Z@#+gNqLONKQ{^crDx@%A|<9BD|d6u51gaoImgLCa+A%g z@Q)wo+a!3koZrM$6Vi9a!GddMeb35+>6{%?r_5DdRkE2|Vwub0!v*agoo{b0RNQf7 z?uR;AE|wW`&Y>?n9GtrPMC`o1zb`l)yJ6mI#pyQsYYL7_J4W}+lRxn${4wX*hLe7t zw{D(PkExmd;@lY)mdNrmbHn2pCw=;sx8_xq(cG(F_xzp97IXEyJ-gx}XLiltdBHfC8OTfWECYMR=52ft8%>0h@p z`*ZfsYi!sx&v&-*&o>o8d@j$qSxO>fUs`W#XZ^QTk!xnq*Yydv&nE7_FZ9=cr9w+v z+_rspAC`(7DK(R~XqlV;^?>)`bHP7${+`9OD=b-4^6Z>BPuC0W6!<1_{8EVar=NG% z)n;gNIWtP^^Jma_&NDrD<8?(3@sw|W?`M6CSeKNbKO^V=w(s?mITRmf?Y;LRZcR_; z&3E6n`peg6tSfEoD0bJqkz{`T+O5Xdf3GgIK78eG)6YBiIdUHBi2r)O_xEmrr_F?8uzPLVwg=BT;104YI$pihTkQV(?;68pKT_`xS#M! z=g2GmBxO{0^VgaH;q&jg3_tqCOn<$g`s~HS@>(mD-|YDPt3=iE$Bp1Xu45AdJZ}Bl zBzW-O!DY`^%=cP$1GziW8FUNUpf{Xj)wfve6zS7g=sXZqwG zzkhsFn8J05T{rmno`j~p?a1*?@axmqw{PF4J^xl|*j(FEAjVNx>F##uy!_AG=fnc1 zrcZ6J;d|}j@I-%G>}Ds~nl;a*rT9NxwUWBBFzL95&hgW!Ehz?i*^8fBrON-fDZlf~ zx221;-gAXWI2BzoGJg~?b&1f8+Y%Cw)(Hg0D4n=?`Rm8YE|(sFJqaQPR3( zXA5ikvF)Euu5`E}p5$re^jPYriPV&Zsw$IPR0jZCWn%F$5shs#qB#eLH6mH9cxx}2Zvh7D(=zF zwt8{lUe2Cd!qwNTRZhtt`L^KhKOQMXO$p(9%&e7XPNb+W%2yT|FKGJ!Auvd*kHUEGB zeSQ6T^X7GQbXZwg?LB>d<;sCT8Zj{nINJukBv26s^w);g*$^K^Wei{{Q>+2?F=$ z?+++yn7{G=|28Y|<)+Yj20`8Y|Nno&|6L*$Df4eO&kuOtntS*c0|VfW&`Rv&Qu|gc;PAa7dVK>lc}HKYr_xFDeH-I*lv@1Oxv? z-2AzcorODLic3nufrwi{jLPf(9KYS4;;>=bOvNb47bkOlYDj~Cw^;kO7(BYHBYByxQ)$M9 zZQkqE>pxnkXr2|C9k^?WZdg>sj-%OACuk_G@z6Odyo{l8mt2+xt6L+p?3_b|w{{gR zId&+c{WnFxXub(+y8y;rP5Bz^l4^4H(cwxv)FCXzHQ5tn7pkveqB7_ z?~Da*3)Z^t^6=`8U|kWQU-`Y3q0zs4#ey)GF4gum-}!}39(^z)Ni6rX!a~&+hGk() zi#}AZ^N_N;_;*6cnmJ1+-O>^M$=Vd;*SpvA@|;^j>-{TO7IdHa6K?!S@MizdGwj8$ z8k5(V^6zz*s}bL?6=4EuKk%*E*`_a;B(oxe|sN2*0$o9cB*^**MNZX|D^); zt4#_r+pd>82S1YG+v3`*9JlGu5sl)keiB2Y(9!DPso;Q7;;I*V<1Mj=|-)S2a%z0QY%0(Qz9K^r4SS+IN@BjUx5(P1B zGn6#H^mUuQ6$;yJ{PEZbYtTL z>H17oTOrSU?+cbMA*j{k1dTrTi4du=0gmr}kSqpVD2 zwn)rFy_gBss`-~)cm0;I*J9&gGz;HnspSW*-Y^+$$%>? zXJvB2ZFx2xR6F6 zwLW^<-_Y2f_m?!fU%s%);)>h%@YXDy)BhAjLIf9mh(5cP>yi8U>*blc+kQ)4+j)e$ zQ}18yKgw5Y+XSWQ zm8wp*x*hpyk2c7CYSny~WAJT`3UlMz=?n}Evfv(=LqWra1qlit{yz{naKT_gz!%U` z`KK@cKmPdt>4eud6B!uT{z7WEGuK!rwHgSpT#^{+70wzBGoy75Ps?41xTfVJ4*I#oSza?FyGAHR_lJ6l;CUM~!H-YA?!c3{h zbM_ooQMwn&e6@0p8_%lEb`L$Im7HCB>L+r%thSolHLqaW`WdQyVT(_mYhQ7nOV4}Z z%Kb(e?TVb{6Zo=z?Ecjp>$4*;L1Ws-ex3`GvhwVA^lqL~b$Y4Xx9y+ayw}q^UWnaW z{&v;&Rm>ba;$LOG6}Y zR@OZc>)!FHd*^djDD%~-Zmvz93$aC4aliCWCB+L{ZiXLG z>;EHpZPUx!A``qOKiZO%J#XGMkIi07lr4?aw*IeP$H-l4GL5rp2MVVotnV@8qFv%A0k){-SS?$mt*DisJJHo>+R+e%hk;cmCRm zI?=i!lUTVW?Q4IE);^sa`uIfqWXIy}7n{pp2NcP+G#=cMFe|!h=Dbh;?SHH?PR_Z} z!Toq{+23nIZBxS>`h#}=(y14p@%eb?@uR-)HXgpTqQINeEbOY^)_RV=>mPosv1@wx zYT0?Cx+D+XJz5Wz+-3Uz^6Q^=#_$L}9nXay8$x(QZ=Dycm>6KXx};>zbWWZQVIdzE zgRI)CKXe!IGgjJpxUd{A_1!IUGgOgdrKD1ags(yJQva0An+n9VRX+XMvbgg{+oC|Z zrtl3e3={P>r7meXyd+BKO`XdVvAZsh=P_MXz45>0gxq$~Ko7SkSCv$D|1iCDobAZ- zM6n#V4-N70cbv5M8JeeFUgg{UdriOjL~#!ujdI7Lm>EtEYSsc1m@}do6%O+lNIKb+ zP2L=Bd@N_l#*V@dYi?YBZCWwqM4jc?gF?raSi60jBkM7(&$CuFF<2<_Q#90eRH}~Ti0aI-0T^%$GG$3V!yS&!&m69E1Q&Y z`cT959rkkP+uvPg=x#kauQ_PJjhoY+D+jK3ub&f~>G(Fpc$16v#`%vv9xIoPW1Hr2 zgzHq%ss_8AH5G;qSr-Z>Dz&7%4^C0mvQYVLXsDE&+t)Om@u1n26F;79`KfLh`I1dw z;|hcQdjCbG1G8?mr7h3ySp2j_YTn-*pXQk_bnRxZ3Gi`YRucanv%0R}h3IAZ2MfxM zKl|~dp0PJIq13dK$$6_ayGxm#;L(U@-af9Xn-ce^c%D>@`JJu)yrgm2$)?uEY0vAd zn3o%!t5jBg8p$__{g}`Bhl)B+|0w+2B(R)MRE(SRul)7DZ!UcH+OtTBP3C$2Hp2vw zDoI|S!(ZYF&8^o)PDUGB=>k(pX;_v2HrlHS6gIxP6@P{=-(+P0>MK$3LGqKR5ZOYSalI{Gi+pQ*w#M)I2#{<5~9mA}ZUMVFdeSN~#*G4kry`g6nUTK2l@YBF`& z4ICc)dd<`4taTHuuL{vUpYtI)=Cj1Zf716Sz4}%1Q!ormb|2zIS z`2WA){`vI{P?^*J1ONa3ZN2|_U4+8=S?8_KCVpXHU=4*gDK0S?@~}Qw^JQ)H=Kb15 z|Fs{LOn6}Op*L;KdO53jflH5FHy-qvl=j7=l4`OHPBC2yJ0_r7>N!iP*?CgW z7M9SaWTi_2%h;Ab`BklC{BJS~Te_$7r_~2`u9{?Xs&Jo*LVZ%qfeN3dZj~qAY%_nE zt}C25#b#x}%tw(;D(8h*ex2_qnjkRU@Ra_Ze~C*u#5=dz?_DycyP~x&L}M z=Qck2e>>`4LVT<8q7t85^US~U&guCwi6bzsmGz?42K}T-vt+i0zYX>H^v$pCssKm! zrP`WF=8mzVY(l4J=X_6^xxZ$qhj30+wsd9jocvw;jl4Fzy=wG5e_hH!{=2cM8y0W0 z`TY9TJl6V>c*nvQiz33yxx9rA9=vTot*(->U~9?)_2d8l7g&@q&)=w2zSp9$+feFU z;>w3R{VbIC>G{1$(#hSI`0Z@2D-kwOJc}>7r5L#R=zk2zYw>o^EmSi{o3Xd|%sjb4GHLLGEIwlvk6|ULK!fxXo9f z$n~{g&@t<&0?PL@dH257)lICPwx?(Rh0e%|r1Ui(v?EXL-qWq}zS>q_?FW;rTgyG| zX{)VcOw^Y6xX%AC06!Qy<3p;O5nWpfeNhtXH!Y@&Gp67drOuDR{$h$qI zcfu@{k}WNX6%!sfc|EwFedt16OY9MYZw(VVt_!~NSZ)xdqOEHuWN>vRlcU^~2|Y7U z&I;QbwdLErhcC0AEX^sJz``FXlxO?$>15CKYtLDGGxW8e2z)3rVM~vSaK)NuQxCmd z;BNZBWBuj(3}F#&FH%LVs={19Ij&uF%rBlhZNn4WEm^X>oe}0|edJthDo;DDeaf&+ zP`oAUn)h)fg9E&}=R7)n+*b#!NL0P|HOBiu=>u2Z4iE8OzU@Vac$e+}zi-;*uq7%C zw|}e7x$`TvOW8`{ypV3#b=F&R6rA4A+wOe0G*&@b#P;eT=86FQB!6v=TQe+@dN{-K z{=8(I?YA<{$NlAlI)#)eepQLbi`kd2yP_R9M`Nx{@cI)49#b!hz6#ac_2+Tw5--a) zlT$fTObQdW&b{ToR2p8`@Hg*-`jgi9iCVAZ7CFD+ ze7#vY%*N?kzrxiMwkkhcm*}eeZspjwB$d+;#NbWyIn0H0v48S9RFG0jvexp8nuP=i?KH{)w33N9!;`+PAWYxlJy61o-2 zYeMG!nD!_37_07~^zgmXs`Xf^D%Rt~R8_Ds-7m132vQ#*$YSef>!w1gm4^@RLm00+ zqMvP=_2|@o2=~E*2XD$99^JV3;K76E%R1nKFJ_g&*$*B(__Cv?xDs(=zYkr-j z`g^DBpF`3=Rx4~h2&$y^o;Z8@;+3m6Zruf61-SFbsgLKf-d(KwaykT8J@tC$4>S0f zu7GXZ{r~TmoXx$ze|}>Dc)sww0_d{a_W}L?6AbPPC_t+x7&ZU*e}~HbFZx%UPx!%5 zwvK^;r3q3+y}91HX^DXV>ji~g9lys$>;C_5%-(zY@F%V0g)PBmON(D0liC)wHf;6P ztZ9q1PXF7#tT{1j79Yd2ra%$yDxRsjE?W~aW~yvsO}3Z0{+U^AIwy0Y$m9CX`Fc~7 zyNhJBQob(YOM1|wG&R!mAh*xEu7~FYn>5iEE z?bZ`&BwUu(YcH1*)%gw~)pIYK=xYG*UTpOD=mlkLU-t%J5jdAU3TJ>@M8|gVKg48?& zEwqy6*ZqF7wK%Wf9iL#{DJ#dXk1V%aq=)tVUO)9#<{r32L|IVw#r8S*S6h3Boke|3u>XU#<(Eu~8q zoJ%=B$8EI#@o;t3uSLfvX(((GnLf{>fZdUA%CD9sFOR>h@pU_)w8`?)%dQD$O&r73 zlZw(3Ps~+1cj~iOf5D-L=YF&7^=7HGD?6FBdimrBI*Fe17Rr6z#?ftgTPrMN&GI)2 z6VAEttLKRPyL^Aq{3|2KX}?D_sqf8noL$5}TmNVxktB1A*R#%ZgUO7E*n z95)l5=w%wd6j}9Mlxu;&-p9e=E14`E41Wk;T6fZ}N$XR$n(&Gu!=!b)IMXe6*Az_2 ze#)<%VK`IEEFj5v*+S0yr*6&Wacf-ramR;SbLNy9dA*Shx$xGlzmQe&by~>Ix2aNx z^R`q*NM(J9i(J@{XZ-%yKHZ&S@9PTd?*H06`NOlSn`he#swHU@uAQ%syS4I* z6OAQZS9%m!FKJ)mU7f&kiJ$9(!x%5(N$V#@O~(5}b#$)GLiXylWA z3p9~$lQln2)cQVIb3&ru>~yczn4q3`{|^(iZ?_t^#snR#v{{<%ezx9XMymJAKE2IF zPLDbbFE#4jZZ*EwrggMRJHbOwUtfP(l8&Q=UR$(Ih@;-70_|Ks-Kr4X?xr}~vX<); z?W*h3qAN?33Ma1a2xQ1vbh5`muwd@aPIupm+F32(Ikmao{VOXLuXXVD>sl~l`|NDU zB;kb_fe=R3v(SD91_l@K(4|2_!-NA190U~tHhlPhq3}W23Q%bd*<|CG_3f^0aO?L)z)z_Nm`y1#K`@_Nm(UGP+(T za>|qZPxtHp+b)fan-UpzwbSi#TIBWA$lGrwFM87{+jp}3)vM6WUK8hc%-v*V<>q+b z%2xILs^qvi9baANeX91nc6s}$6&j^}*)JdWe*WB8^XuK)8{X%mb6xoU@0Xp=n0zw- z!1ChQN&Y)`>eyCBGAF3)=RDw2cXZpQE4Hj>7-TASD3rkyOPW zU4l+Z><`3p9#2$J|2s`Enk7uaaMAL+QCF=JBP1T$*6zNR)Yold>uz&KMWakgsk`|G zJKu!sOTt+!gDzzJ=x+&Dy5r#3#XBePz=H#pPV3&!kJMPu#ka|4LUDodeyQA&2{u=j zd|I_xaQzuwJCA~+XJ1(?-8%ctyQMSFuKKj-p>Ee^Yj(+dd>_0vm6oI@H*NW6YdNWF z?t{Gzy_U~o86*-dO_IM&(fFa)nZM)^`-7x)3wD2f@4MuPs%#6l&{I~a|8s7o+Ww#A z``zS|Yg1V5z`~aGvZLs8Qt_mj=~*t*ceI*cEXfyM`o(KYPep;q!!CB?=tZ-u|F7KR7xJO2z1pR4 zM&y&@?xkTOkqR9Xoad*A$;)4je1G?0#nW{nuhT5pt=F8oJY}J^Jo}8yWwJLeGWM-s zRpWU{$)@K07iU?ixb7`)mR28R{+n_1`M0yqrz1r<4&?E?+*~f-P+SyZvQa$fU)=rw zbMrp5tbMehY5TL=_x8_~EMRaxF-xE%(CY#3JpZq&4z)i#6F4#VfCTrp20^!;jk2wc z7BfzmB{gvv-`qIOmM6LGYo>w?i{O_>o3$SvIFqotYldgi3*|)HLl)WW!Z!`~)|)0x zQWV`Cx!|@6<7Ac#?8bsO?>sy`yT!B2O{s%@-yTlW;LYhm{P#E`U%h!*IjdeFBt;IRA~Qwqdg@R}`Er7T%oxrh0MEleDY5 zE`6BbB64NQ)Q6e}nagHQRS@=>D>+YShZOGwxBnMEFl!jv@V8Ic%QoeSd%)%^{GBUL zbk27?d&fYEeww- zk`#zxNnh7-#BRb@DVE>wzU_N7XZ{&i72%_+9*QO|KQ37y$UNC1DO_&qCBJ@UQ&GoP zN4)j50)?tJ++`Ky4w8>^JRhTWY+lFaJ?-U1D}J`}@VI_BDYx)R6IVdTP2DLR%cZ^_ zaQ)yZ))=u{JVb!BhIE@v0E-dS$f znjZXk^VeqaDPMtTC6>4Xt@B$q{P^qhPALkZI7E4%UCH(s@RQNIa z=Kmk3U1Od^yNO0Bb_e}dD*rJ-p`%0fLR6^hlXDwSOP%i7>@;orv>A_mEgWrh3?1bq zc2>x4J)85g=Rnc7PwRKcCeF@va9XCFt|K=2=HIJHwvih9((gU$>H6dS)?r8C<74yr zzD8{_|2Vq}OWn$PotU~6b~)OgD_j3u*#aiFLdY*?)`A$9p@N6!Hl0}51`@flb;qQN zSBIDWxw7@-;`TpRw%*!2?dIm`=U4TgUDkDf`|J-VS0A3!v}an)!(DT~pWpE3%GUDC zI9m&2eSQ64Z}$TWI+G#-X10{9pVs{AK}YV{|Nja9 zKd$)y|Ii)qnwJ7lE%^gPpyImCJdLpb+LLBmi8LfKw%={Y3HF%TdEHl` zdf)%qv8NXw`nd3*!UMj2@BT(}i#xe3zL;Sm)$6wS;){B}Numq^rk?75jeIU|d9zkt zTwGl1kD7I@YQ(nH4xCF%m{Nl;@t!V=4WG>M*hln7lG96`zLQphe%ozt1a|%lZVa|t zYF8t8;q?4TiX|pCKi-OeWi)hla`IwkNX-&-RMGhOy4}GgIl;!)qxWC!N0>2tN1MM_uu%Q zEahOUqcAULdxVUW>ia)Jm-~O_tx#TAEzF>(`X^zoPmqPPgQS^`l6Q#3{PXPr5hq1v zd1Ui0TyDPiQ`fRdyLkAmOxM=$DLiA$EjQ)Fk7+aiTRzF!SI)Y~;{~svoDfr*>HX+NiMX)BtEgqt>ckc3bxCWG^ zvVXsl%dsi!b5mtqrCwQF{QYgopKdsJaNh|&xF`SG+)&^6zLU>z|Na+Ge@}XT{qMnF zMStURY#S_=G=*2LeE7-k-OJ1aw$E7IUTjT^dOz>k<=Er02@|!rWGXG{y33~DZwUA$ zX}(zK|jOUnqI8$)x zfbrqTdmD@oTfSm2HohRt)qN#p#|6!x`8QL$yw4?`I&9dpHy|9E;&yI~yDY4RlG?1omkyMj;kHl8%~44%sTI?4U} z(@YOFjU#J6cC_L=U_Lp^4(v9%C+CFiiqQzuG5AQb3o6?i~vRZf?UFRwB zJGteVe&O1EFT+Z5!o;`t1T|)Px-Gu=|Jwaq54hF5XKb&=QogfA5mUa;g!Y}_3o;ra z1K?~pqa`{J&TfkhZjA}*OO2RWn7E)kb#iv>vbyXYlPWsmL)NwxZ0Rj63-Qhi@JRA> zu`mIZ=^@T`^^pN?))p(9icc@@xwmc3m(%P1T-kbk-L$^csAqc@nHm{RD@^}M5;5{IC0sazH zp8t9O|MIi{EB^fd^#8@ToGqsq7+7r~W%-+9M;TcR1(*%aw^{x*uRe1oV=s%6l9JM* z`)WpKIyClln_c_qd(iFRY0ppWtuY^*j{X#O3aRLn`eUgVZgcm6{-vCQ##i6zUt4qW zhWa`F9i5(v5vKXlm$T%ePHG2A>tFeI^A(Gx^<<{E?Cpv*TkgxK z5wT6VAoj}VKdTeeHuY?=SvEmJ_~T2S{U841@0otAY3AzxzTPQ~`C?b?1379uA4Ft4 zF5I!Atv~YUOaG&p*D4QiIiIg{G(YxO`Ra9-)lLT<9^H1~WOLm7hDM#47hV=!%z4AU ztRrM0gQn+WRkw$nJZl^t1o$x7Z*UCw{nF5E!C6Z?y}E==;!1Tp&CIql3mDh(Z}r-- z<9hP+y_pZgJw?<#d-!$)PmNdc+%;thr_}}ilg0BhLZl|~yuDEK+{nS)vXbLf(jzv$ z&{Gk{hP7Uy6(XK8>PIcDfAlKwZl=)u6;A?)$>$r~8MF=}mJCJ>P9O zbHU=|0fEFVdd*Mn?6nlpx&C+Y2?3c;SzRt&t#6Wl=PPm79bOU{XMA$XuG&XkGZH3> zxlX#Cn{-uAE=xttzf0$s{DwmgUmx^cW7S>7Ib%nkIE&e=ii9#A-Bp?Ac$#+Ehg3ci z^Vqbeqw=GG)b*byicKy3n-4Z^JSKA1y2m1qFIeE#sXSF@-eViqvv(fZ!?|jbY3r4k zFCP^Ix4Nw;tD5y>OX#C{zmBQdPQAsxRFj(z*{pw;N|#^718*Pkm( zJjuMhV6*dl8AT<3kqxr%G6H4wrKdTryU;Yl0Q`f27rb(L8oXJ*M)+Q3xo!Y*mTu ztPi)IcJ4f}G@|c7`Pw&*d#1i`OWV1xh;Q2Me8KRVN8uAEHdN@J=HHMIb6+#|G1Ig& z9qf)9Cd(8o6q)nxg=4Xc%cB>p$K^FA1(^9QZI~`|Z0EYfO;MriSfXP(r_4VlYttbp zGFhO(e{ze*xm>{(7R_F+3_ znh3r<`E$B+@MKBeQ&MgzYJ5ke4>>#P%lTMe3$IvpE+cnRX6Feu}~U%!8UgwoYTtG98?b7mCCN|`H|!`*amj_2W)uYyOEgue8-ZJVHZ zQ>^D#jazc9;jOSE3<*{5!xvr2nEvG1vuC0f{;t0-2c|k=t7069sbVGs_=LFnWEL`n zPr{EF!zMx$Xd9X9>+AFQRA?E47z)<@5OJ1}E;Vx}WlImvfO=WG5MlRh1sh)}$0!Ns zL~SGUgo&Gv-+b1*_SFCX{}&&=A&@ll)w>TCHLDIEJCTu*p`10-(AZQT3?!Tr&%{rD z!oa{_0IpdS5*i!?3ikg$AJA_w|GlH?|NsAwufGqeSN{F~-vD8O$7(^IopXCzU-)xwrWF65KI867Iw$9`wR}(!=GXed zl2YDqe$tf5-jf*OyeBbUewNKqpH)1qW#9ANwFff`UMB2MuL*MMP}VE_ed_gOll(bX z{x_w+p7eQ&8t23Cv@O{w((mU<7SFpF`eE%Gx06yw#8|w)b+jue{+Z;qIqBB7*@ZSI zr<^KSd`x1kLU+gF!;2dx-O~|Dzj0!hj&#q2of~g7t`Q7&ZPL>ey8ATv$AiVXfWpv+QBAx*wN3)`eEm(&%363PkZFpY3C*^yNp${HH>Mm zccj^-?uA7kA80&h>-?Z0zwYnL)Cp04CQeUZ>gT>t((*vedGXNy;*nKL-sQgG*?Q!S z!ok#!{X%BP>kfVi+b(8X$rkJ)_HAW+oe!nml^>aM3aTAN-UXg9RpXOdxcZ5Bj?&P7rwi)XD)uR>V%s3wO74cvkz@pF8GW8 z>M1T;`FVS)zrS01p~T+u<}#O$Vh1V&PJF&P_0QvW?)k0DROX1X8t8H;ygsgSX^)xg z=ZnYBmIY1F>pHZw{BPHbrn6#~I_{m&Nz^`hUGnJz<>ytk%0{4@Bi%UB)W%f&ixt|XC{o&{7JKuaBTa?{+~e0%Qmv1LXsuo_QEVq$ z=bUSAryO4Li=XG<9tHMxnQ3>H|C`YLoHcRAB9E7Whur(`taZF}yZMdKt2fWscm8}V zbo1oBJJ%G>n4U;8anoe6^>%AknWpe(+2K{knXPsiNFBL$wf*AdwAJqpy6lmvagYA? zPAZLi)564)->Nu5yZkEiOSaec9a*yU-R*lSyLt{qURz-#e*P8L$0rIp+d}o0XkOYe zHOM>W)KnI?CYSH|b$`>=#(K@NY^n4(SJ!dwW6aFsQU)&0`b)Pcd7ZfHe^KjvZ;P4K z6N9jqEoqgt@5C;3I!gRJxWJb`=ud1@!=H|X8-G+CA3a>|`^>hZR+guI`s=0|&N7+v z5jLMH|5<<1=;K?%ko?;>;Y=G7pYi48Dk&FsmH+(L+ka;N&a0qO?;rcrDN(bg&RVLEv?h5=XpI?~f_KFhKaVW5O)su4*!naImY>Nq6nBaMR z%dAD^>5q5L%erwIG;bvcu0{+38V*cIa1c-^`2S$ThXof(MPK(aFtERX))TW|CN172 z)Dp?M!{LoW@?#&HnQu=1w!gwqP-79!M z)iGnOG6&ObBlj&IHz@d-y^1feWLT2TvU}aHA{}PmIab$9gM3(~F{!Ju1TUT>{Ci>z z!;FA7l_wH~qEVttHZjiM_iE**CQdo8y$=(4IVDBenJWXeT5qg)^(@LmqFtympq6J# z5_g)WgSr*NiIli#|1wDte&$wn9@<810VXzBV%Cs&P*LFs?C%SEH zS6m$`ryg_F^WJ!N;aN9#j$EemEqn?~SDCL*@^)?8q}bYGxbNt*OKUXB0!-fvoSoOh z@isVi{tt49Jt50VPB>&7SZS=j zKkvnqlgvW1IXDC-P4Js(qo64%z^v!Fq*!cMx}mbFbIkd`HkCz_vu+w3%<);r<;itR zNwY^_;`PU0{?s1ZzCv)ud0vUFk2InebsNl3TR zVJG&K2jUBxgBGor#rEM`OUR-a#V6-=p7gssl2tkKPgXRI9)f-cU2SP-$j!ZpBwuSgz?DMJJ#dA{j?TN#Inb$gYEiPA` za6($j=w;0lgCkGgv3bAqv$SqVn<-h8CUWu#`;I4aEZ<8^1z8`&-R)$(@chao;q0HT z7A;ccCo(^uS*Fu9XNFm2#Oc59Z$G}Pf1)6T(XnFR+z8H#g2k_S&m1_}kn{cYTod-6 zJ111kn<$~UR4iw&fWxks>sQj94y-#9^?O_PZy76#D?6+L8Td9zI=s~~)H$(xuf)x- zx2hQvw+UQ2D>ifQg*p8fmy6H68aL<0(+E!G-^ur5^bRR6QV&*qc{E;AYi)x;(4(dn zo6v~1B{#c`zwx^9Wy?I8aCJ+=tA&vjALmE$*x1~=XJ_YYc<{j4&wHzGYdu(X`C;V) z-`T=me{L!yJ$PyH$--^9bg9jL2R{Cld%mbmI`LV}8PClM7N2cOm zgU`8~-yck7Rr>6GazRZ_IbQgtrRs74c^kR?5}PkSN);$7{<@>>Xv77sivo<29Log5 zk7RD^=QJ#^DYV}8g8^eCIgZJFs6_jFSHxp%gkb*ic|@}^#EydKGME%@mv=IaJ* zypj7RN2>SlSu;Jb+jir6PrJ?u<_j{PwV8b|2tUiHeX{#}*_kz~EiPv*&Rf^wVsoeW zW5tY=mzF8oEgHx5mN)p?Z(qOUv1CPkMTMwx_1Q@)TW_qZR_gPW)cBO`m3Hq-$$~pm zx9|mdT5ijmRHL4D?8qLOeYVY^2P}R$l}rdY=U7=^UAME*tf*dKYw*(vL8ZHY{r&s( z<=dxer6#N1YMwX~<@@5Gf%B&2x=(LxD=A2v@-LgORb|VU4aO2n{>Ic691pVHKk4V` z3Aq+NkK0#YdZ4?cWnH9ZW=ibw#m}#_Efp~0P+Y3v^{dnS*+GVnX}#`qU#3mF>>sm? zErsQpRnU{qcG|}G0)PDKN_F7h^0akp^Nk0NtD7n@ykzj6&;oQrz!q;M^`fPASmqO?3>p1P-5mXj?ogw%7d83kfwOs4$ zFWK{ytd5J=AYpu`U*x=9YMs<%Z}FXz)=IRhOyj!!^@qZtV&6S?`B*%_@uJf@1Ffz z_cx4N=5J26H(8skHnpTfVdkr?`qB(PH!+wjtU12Ut90dcnV02UrU^^>Sk2biv`SdK zV}BKH_f_53=c{2}bX(%bTbAM9&IbzZy2rqwvOiJyYHowi^Hhgl2dv7JnHd{#4`ZTn&8`Y2V}@y}xU!?M~qt-*-N8aoJq`<{ba^ z9lJkOPZhXbGbi4($G2xr@QQv9? z29`KTBk1gH_OitW0&EEvZDu5${3OL`cGV(sxn=hK|9P|BxRxknvhBIg`LF%eWu6?L zdGal9J}ly7IIwVXMIF!iWpdUF3b^toO_A-If6(31dV+-2jl>@pL^n3iU}O+a(pxGZ zGf(FRMy0XT1>c4+}c=sdBo#tbwZqt8-~6k9f+& zhTfUS*&aSk$b7|HvL)g+Pw|!;-V%FdVqAJ;{-`@D6+AM`Qg32z_|f3JpH;bR=asaO zk83Qsr(ZGD+cNw97xy`{y)UgVR83XgXFOg1)HAzF$2yjD?_tZ{x*}!ei>8W1K8{dN zVU@co4M)8Hw5oJ9I&DqS$mDaWIC7`b@WRUAGpaq8rtFOLf4KPd?AyE5Z_myy5HS*W z)IR$5@BQ-a57d&sU3z(3;`aXB2N`E`etKHF-R8B3N@#mpcD-}sZpQG&-;4I{dwpcb ze#Ua)-7>)y#hbJ1d)~?!6kV6uzE+~#ykUy)LJZ8z@g!d;j}ot+Dkthm7R^ z*EXommF>OrZ^3PT1Dy%g*O-~Dk8D^VzwXnyQ+w5Ar)8%6{dTElg7qmG|Qi7xlMC*)h$Z&ibuZ&AmNh zs#m#%$h_buB|4%Pn?oC_TYesT{rIZj=1Gmpb!)zetF))@iRd#jT67_P(uZeFHzNX$ zW)xHyC!47y^o#$BKKK4T=Z#hUU%zwxIFSC#W<#iEu9S+zh8Ka;qomnSw$EPe^m4xD zj|8h5W!o<8eXw|8)0C0xNr`taD^CP~IYGSui0g z)A*3-38o&IZ0D`n6F7Vda#t{1SCG5dl_^u+EO1|Bs@ajd%{~j_m-1@5Trc&o4E1)I zAo5G})`SC7&M&)gx-_LIE!j~#rFGSXiWJ9?-qq^ILL5~#b(^ZrTElhs)6~m3YnZIm zp45hD=RTOR;E9azoJv;L#l^E0sCx!ZE@5W*uzBaZg%*LYBipR&xc#nnZ+DB0?3N17 z&%3Rl_wo3W*h$9M_quQ{((7$IKG#fG_2sWHsn@su9rQYzJ!#w2Z7bU37Jc0jEmQ2G zDL9>_Aw1|*vS#=qw=EeDCPjDzeXCdD)QmnW_(<`8vef_W4ZOL0EcT2&DZW4Z+ji%i z<@m{&6ys4TT_9B56J^Di?P>8K|G(I$DZDDZ!UofR^6>vZA1=0O;nLavbPA8SO>CRY zvTyRyeaGFV{BoREYW!rjK`Q%1w~6vLkuDc!Ewo{1=vb$8Q8E)W`_F)O0T+ihF-313 zv}@TBgEZ3>69k|2>WlSnjS1=plW@V-n4qWG#&2^BUS}IZx}2}F4bP@q?@4i3mE<}v z!LvWs|3Q|?+Z=;8IR-DY4fm(ozsoatU!?!BLicMIXbIxyMx7Oj?oYFgzfI6A|B`>1 zfq_92T)qbU-|(Qp;ll-i0}2TX3<@R~6|6Y^A9C&CzjpWE5Z3>vi9%@x1q=-A(6gc5 z&Z98}}Ke7r)!MpONps@b>L-+ic5btO@E!j?jO{ZKmd^xn%mfJx3-l=Kk2@bgY}R zrQl}#2BGv4#f6FbGg;cg9&{+Sy7(v?wW@rZ7~srdsMh&Jw9LKzxHjA8iIZkz{@A-! z@cQ~1GmhZ6iFX7oE(%rb;OX1Q7VBgq+LgU$;Wv}@GiQ9~ZQ zmu73ZQ>)=pWN|vc?Y!;|C$e+?e9Miq+9??E!8z70pT8 zTOMp@*O89rua#OYe)+qbM`QeZ4#t;flWosw&bn!_D)#FQK_+L-KK`i-m>y60=6q*W z%eskcruK^TPI&w?=#K9+*fBCjaw};oKES#fB#f}{`L(={EHVCzH;8mb@pBB z1g2L$GG;PA-t|vD{5+vG=yI&epQ?6Mtqs3d-;>SZD@~i{f9taThT7CKx87Wzs{cs# zUZ`u_0k?CNkBg@ACC6+_RsO)OEG#PYHQXr%|^}uk5ko@0~^kI(`P0izof{ZGBw7TP68+)m_aicD5SK z^6n}d;y53EG5XcGch?`U3-Nbv-p<=+!1^pEnWHnoN5%eAvD>;;v$D&{BiYeJ%z;lfH4*H!V1R{qTd2NjI!RE!t-MQ&KR?KRf9NQ)oc+ z>@^}@U0Z%kU2^k<$6MQ|mKg1tEmjGaH6-?3>t42fRos0uVy(}3g(x#=e<&d0k%yb9#psUA@`CkkDY5i3GSlEITr-E#Qi+-$y zo0ARpTFovWMxg`(DeYm^Eq}1;qIe+CPFwd8>7$ zWdA)WdvmhX`|wreAX9~|-VP@2y$q8I67|fD)oRyf`fB9QoS;xJWy`m)z3P?4wrjh~ zH+s2ryc51R93RT3CvNa>Vsw|JmT(c!|3$OSh zr}<^)r=Id{|M+gd=%R#43%{zo+ii4to~!akp{)4Ns%;apQ`2tR#YQq$?Db&M&gm^T zyDsRs(8MgbR>$ql*I%WNw%MhAJ$EqkxdG?nh3c7C_jYGq>0sH|&eOqhtMq)u^KFM; z>uJ<|dGJ3@-7`^WQQF;|GnUR5(g~8Cw|PaZ+&!*m7ZPXPaM5T~ap!dp`RvZ|a)Q&w z#KfGYtz6ch7t~HwIp*DcWuLWIu_n*`cfbBDlsS5Df0;?ust=rTVZ95P+4t?137h%z zuT@uYTlLn~=#=jnPtWE|?@n{G^8dbl;_ns}rFn-BESe`9dnH?EU(KSRITZ&(UTj|^ zKI3)qHD<|wZ_Gr01n5sv%*|MRU&!pgQgn*d+nVg+xv%%iP4dr@oy?(XaXj}Z_ZdmW zjlvacPc83q+RGQ~;xv1EgyxKs*>5t>nD!HK3Aa6mLC08%KMDp3(kV0-{!bBxJ{d*sq@XU_~0D}>#39DSFvo~S>>d) zz(&G}olX6Bd(gAr-xj*?EoA=wD{q_49nZeIJ&f&tY-F6;Th-TupI+Be`E#4e$Cbg# zSKj?I*f`_O_ub#GW=&0ir)VW@RY7-KyZ@uaffc@`fFKkBu6Re%LL~Y-Xky#wK|9dEmikSGP|+?RNC2 zYwy1Gdp_uMc9@vlO4gcKN(<-;aLhd&DF-`FV2gv{GB5;@6Z(^&NcETul)4o1X%YezDzNQ(w*D)+=0k?(&@bEmMpZsoep`(ZXe{mjc2h0RJ=+7^C8+qR*N<6j|z?s-R9y-S~MjvQ1n z`((rP>Q=Lh)jZZqR}!c0dw7$j!{G8ijd}exK`I|=?lda3O;6~!uPE~u;{w5yzNcZsNLRn`%sLaP+C;y=&a#8LGnE}Cwz^NL*1sR=ua@NSK>qJJ zMqV}J?5%0#{I8z7hY94K68)N25!Yk1@j;?Xkk{*T7rd18RTjO-fBW~f_tgwpNtf!9 zr5quX%g^U-zduoT-ga-zPdtmx?2fgY;&Od@hD5rdw~A3*#m$(U2=f<;m3D9UuZs1| z-q@IY$ns=NldM1ga_g)4+WtYw;?sNYS=3$9)O2|}jsL}-#Y+A!k2*e)d91tch)Uq@ zuV*Z7vdRhEx+h}hWA$=@9W)AtaSQ({!DErpRFf874MAcUi@kE z^3DgD3yPO?^4f5ph~ZYtyw6m>?X>*l{ItGhWs$toU!QP!f1P<<_|Ak`Z!Ug#p{r$Y z9n)j@LQgvGT&jfM6FtQx@!@hc@#RuNCX!Nq-8-K|J}O@!W&7yXEythtDo$Pb^S?ta zYx@?v3OniTmfPAdE)>;&@<||Z_ty;H9+x|x0)FpZ`u#KCc2+kf-t~*`m%UZHwXx$# z>5AHQp(%p#!Am6Lr$~1MtWit4{U%W0;#QY6+NE1Km3AZ_;GXz;*~=9S$1S!5B#Bo@ zwoOxfC|L7wgD;=ntWQe2wjQ5*PHfg^iyP0Pw)Hi~?v%VB`gy*TjcQbq(BD&H%k;yu zp7nE_Tx@g3o?qHYPOT#$>HLA2qCdC2m_Oman^MZ{WT!|SpUZ!i-ko26(C|Zc*xS>y z`;wXaAKjAeV33T<XE3TW{Wf zeDnU}!^ck{;t(!`go`*iIlX!R@z9||&tANE^Zw(l+jq~MKkww^RG4U9nP&3$pyZ!J z(ti&~KsMUKxxWsA4jsO*zvs^(>Fi&K){o^i~jzXi{kK=>|7M2&J2?Lykodoqc}j)u{RQ0TrwPugGuY87`D8KYp~-UJcPo8k zU|>i9cLxOuj=%oDIJ`l@!QlP>^$GhM?mMKn81xq``Tt%)VE+B{`~Uwx|Nno$|62|Q z0s;N||KHzOFhAk{|Njc}{|A6Z<<7qck^lexhpuJ;F~IBK|Nrm!zx;Rxb4L^d1KT7> z;yFphvuoAMW3%$2>}MrPsqb2Q zAiN;vdh>0ayE_)tA6-{bw?WL!VKdK>7JqSe>$*etKdP!07EIW6V3H)8zvndZ>`Kl> zs~#+2^SQ`tCfzq>PbUAaW$cR1Q`y{=6_z<_CN9t4_04H$@SK^7Z-SWjR&(tABRsjGa;T%+#=YWvJTUsAgB{c86lExyS|WE%yA+txg%vmzN;eoD=(Bp9@S^-N z`-vwT&p+cW%PDe>l3QJN_ONcD3fF_rSAQSqQHk03T{qID^2J5{gKirgo=jVDV%q=z z`zXqyOde&=H9Xi%i4!VD?P zd)f0mmvUWR!5Vt+n08aTP|R<3Q)VCm4cSc z>`Xtsi+$pO%1y%Mts#C2R;e$AZg%W+;4syh_@gb7ZHmVJ-rYg{j-8kK4o%az=HFj%C0TlY3X!F|C?&)av$4#S<4Yiq6gE{SX|YAM!OQ_oHE$^q)D$cf8o7bE4p& zd`9DZ?@<1)ib?Gc;>6)>C&1_a=OUZfst}J8pOR+AUS4!sHjLxolRcU`H9XJM+gvy~k1=k1Wn$QJ zzUGMO&)^AGJv)M|H!CXj?Fj1Rc+Y9Y&bm4)ocWd5^5D)2fp@+Ym}R#46T$hS5hcd_~LA$JZ|`d_|v8L_kWo??QQ5d7-DGRE8onQs8n8|)pR4oC4JSB z9UOb#avcm?s`O*$S<_{wZ1|1lr^L6--|c+;{NIEQ!Huj+vZ4G(9<*$kSh2_QPU&A0 z%k}rGq>Z#L1$wWp~d7XIeQd(Es^V4tMGnEU|x%A{#wU}}C>wU|uc<)JV`*J+!Qvb>mt=ltW0qt@@dzC|#Vn@t=80+g8h8oX5XqVF%MG;V}OV z`5KF=r7BDsJ-YUqS-jf%)$&-2((DhBR}&yu}wc*C5z|NmK6lR3E-Pxc9B z$8COKeV;{UMQ6TFlkeh<`T9o3-Op?m%ryDsrt^rcK=173;y1sOkM&3zr=9u1-=-I` zc%Ec(8q#I>;+r7oHZfRkpg}LH_2Mi1hX5iZ1;Qasl1q$!?Hwg461k86>53ajm z#CfF4eUAO_U-GOqME#UQLI35HL$wSHY~LVt_?@e*g-1XKdg#}Fl;r=VZ@M9QnPT+0 zC!z`wN9q@v^d9{?=Xw8v0(0+!9kX4_nweCoR4W2S1w z)U_P_tgmkxa#fyquB~HvwlDmI)4sfo-xAh4@cju*c7A!YaK}9B9iA_H7O#D#pX1%A zbmy1A#XnQqkL2(Nez#w8INnvVIZZvJb@uXQj%;^CxHyU(ukVPkSYvTGH;S=99M^mNiNS6_TPE;Gi1AGM@QhFpZ}h)=9#FhZVo%q$F7#*zR9Lm z*+5lOP4R!B;>%yLJM8UlZ#d8z!XPlaTvqbU%=uBL5}2&=Rw*zl9hYSkSXch2YW34s zmmPa@1P$Ay4&RLAb@Gb1ma;>+o$d5w$)nOuov(M#p52~Z6(XqQ<}jyXSHS{p!*?8w z#v46T%MWemUR-Cjp~2a$?00Kt`G#LR>UQkhxjXN=qvhclw|6EUwBPyf{quvRS64Mh zx6Fv;b@c98lh`e-Iy_dZq?CHRnIm>~<&wC} z_wUvlNC2l~~iJG?fconY?Z%-{GCR zMfipG`*v_$Zi!N~^$gf9v-H~J*Ve)-E^5}dyGe$mC7T4b9gKUk%H`3|bkF&Esfr~< zH7r~5r!_{rn;-P%=;`Bcp8Cpe)Zsr-ez~yrrvDSezfZ2ZhfOQo!PlhZvw?g4{-7(2 zGpe8E>KT^YIe$jNwWy*X^-h?Pe%R%Z5Np9tNzJ}V4^~J-|GX42*E(?}#_}JU9y+B@Y zajwLx&qiktI%GbVZhUUB{?ay=b6$BbRPW{J3Hnw>Hch;s=fR?Kef^Vr4o|LT{mws; z%Ie0H^YHb=-!pl=C9SVVxV#q0+TbMJJag@YPo9&ObTlhZuTT_HoY5KJAGxBIM^(~d z@kc?Y5Oqb%ZDm)w)=5`!KMdUT_U%k2iITesic2!)Yb*M%-oJ^fDOYQDfzejsNu?h5 zeHZthKP~p~+yOU^8MLjFu7KDL*9&e< z@kvpXxT?GE)n1Pqcf?zkmEKwrJ;!2g>DD{zHh({V{q`oqAFgNBI=LnP7yW1X##6QQ ztQf0P5i9G2TMNQEp1nH!cB+{w*OFEL%FSNSof&k6OEOC@F|Brysl&t@U#9O6c>cla z#ir}Lo-Ia_{)M%vkMbnW&z-2wE%|k}nsBo8fyvACAB!C?xVCJqpz8gPU?gqYKlgo0pZg<_LX1)O4JoETH-Df+YURWWL@bxnB-=ad?S1 z!NHKFT^PGV|S+AlIkyr_E<`Jk(4$b*kqdpLgPI#yJ~BuD>GGze~jC^QT{Bg?2yQyz+hSJWDOB#&$K=tD864 zjm!W2a1z?Lug-qH`;XI!-~MDfvF(rN;J$XBcj^20ZG2nq^X=XEwR+*A@4s8m)Rk}9 z6wUPCpHt}hcW%kQnofH-dl&AX*;srpe)UKDOueo&VpRxBJ7}6xH=j zjzWQ6noFkyd1)@a!fAZ1(vne5;Y7Xh#Ok{G0F9pZobYFQ~ehoj8}C@YCznHq(Tx zX9DIwSDe3=QV*%uvj zreuGtD93{RvupbU1$=Y1%y{(c-}&;wKhEOE(mc*@UpMcJ8jnrpH)U&elcW~OU*+Ha zFJxs}v*LY3OL4)+P|KVNOpJalH@gctmCXb`Zk~Ut>Zy;w1Ji!*GdfCNLM-{TX3t+( z^{nvO#ssBDC#TzU^{}lgdgi>r<;?O>F+cG)^D9&i+37wz=&<6bj7x=MlPXiy46*&y z1#W6wTQ%ghj|)w54f`RnxKf~F<=4#ze~W$OSZK7TQ)m`P)vP(Y+GCdus0sF^-w`M{3qC)6*4alw+1;PP%*M zjC|5QzToLK8HddUDwCCe?QZ%zw^MTSL80VH1=5B)7k)Ettd6tcJb6&0LtE%o%S=t_ zL*3?_hr*M-=$&@5o8#FOv)iY-rr~(I=0C$^rGH{qFI;yDEsae*k;u9;jYW`INkcI4 zl9f%^pPH$ybz+rkC!TMAeQ@9I3LBf>RePoQSA>;Yw8}{`cJInj^!MHTzWKrTg?;<3vN}3FbN$kz`H#vB%wt!&$t(FZvmWj8cs`Y)ZY%h{#i+$@o|JKRQ zC9QkZPTjh-DCg;gm1jK6?>ZefnY#MYj5MXoe|OoxAL5R(KvXEnZym5&*`6wSI!U)3O+fdVCUb>Uf%-#Zt>NZ z=PW$?YJJmNvDt1b_iT4_z5m_I^ydG!H(Pm`4S84t+RvQ&cYE5A)MdZ(n-^rxS@MM? zF7?hqr|QkW&7bUxJll9|i}B9yRxdl}IIp|MT~?*}d|p{$ipfjcJ-v@rto^GdH_us> zzj4(i^(kc$jC*b#bQk}Ud5cfzy?^1mi{J}!7#J8HxUXe=d)0NOC-0fF*osaiVv5cd zXwmt#L;L##&5xCOpIdak^=N&p)%{qZ`@T^BZH~eF61}gTTAy2VAZKxX>(~6!uKlS_ z_kD>TL`>F*=(HwDtA%y>0dOop;Y+U|^5|mz#Et2MXlFumAl2c8UR{%M|cokHLfW2@5Vf z-+5#W0|Sd8q!4{O^ZB%0RwC}s`O`JLwtoLV<$L|U+b48-{|VWgW7wWjzwJ$_RC^0= z&%p!(2_ClQg9!!^+a6o2JAUja|DhGC-)?49^lixSykYT2%%yxs4olGNV!N4Xn_qaH zX-l71>}ZzeajA(rWpcrTdz#vHhgEh7ZOB`5r1S7K>vg){cxTP=PH8zeQ~%TcJL}^+ z?_Rh4A$$1+Tm1ERW#?EY-waj#*~fmScc0ImR;|8;=U<%pseDnlZ`a+cl51a<&SIW8 zGv$%vf3N>r8*Xj)<~yM>G3x%i7295@ak~3h7bS&l`J2J$J1IZ98JnlekuUOIgCTXFRWrB~}R zx%w{lo5)wml-<@ZV~M=+ERoJY(QY^Y>V-)Lq-X;&NuH+oS8-YQ@_Z6Hh`N^9vU;pXYZwCJ`X`7d=>;^9l%^AghX8e4z*O0ZDrIX{= zd+81D)b@72`L12M^VWwm4?iCd-W>n_*738Bf$JD+me=IF)~#yfKmOXTDC~*awJm3V zpU>h5Tace3=q;7;{{8+R=L>Fmy(ye{#D~jM{>^rw)p>&Y&-WJG%w4}mR9SZd|Ldxx zQmc9ApTGT9v#+4FqxpR3uk=Ot=Ly@1L>~Wkr)TTL4b^Mr@E_b#-TQso;`JH#b#Ja( z;lVgDp<`3U!9!n<%yQ@H_}8*|rA4oeX#A4z>%v;r1x;;XoFM3Oq>;f=Ez>pryp?~{ z=@uce=pUDjnfW{#PG7zovtgS1&##rWk&R~r`X683`S-^3(}#4QM=UvbT-o}=9_7x4 zSXJ@Xn+$>ilQ!2xwYb_WW9PS&zI)7M)$^-W+BY&?ZcN@$)ZU;MuNA)caGLgx2g?@5 zyo`=nw8x(5toX`beyRHHEUruHJ~Ew75{g?DpRE^f7}yo@CQ?hM$+NiT!S2A$mi6~^ zqn>0>ef(~hW%{c#0mZ>Vw_-Qg$4>EXI3CC2xxL))rW=!+!rB9Gf-VQRtO;NLWcK^J zroJzoS!U~a3ceBhC@EMd5WVDlrM-GQFKmR{@@%{gY|4;t^fBoVA|NoD^{r~E- zP3-{#1B(l!)O>U9XrqfGhwDXm$xo{PbB-^++g)}}YA45g?G^zi4#gIMj-Y?;AqD(X zvLE~UZW6oGm-&=gML4ffOWriZRHt|4sp&Bf+@c@ZRKt@uTQxmxjhA79()-ac7ly>#Q>iZSap&HuSM);cgxg#8dh zPJvS~+vzR66IA=1(~9^0XI{6`MD&g}zrq&t__@U@KfTkp&$;vY=fiacy`LD&PtCm% z&b@d?Y@Hy_+l|Eyu0NhmS9h)XD)DTx`m>IBtq6@@>x7#sCK$}$QJl@Ssrl$8rR{f@ zEG)gxwuWoc4QBaA2Az%C|0X0!GhV;Z{A26Z`LE6?Khl#p%gA+-^UtK9`FO=_ulgF zrRui*VHLYwo_N1s-n2iY&|2x$bMN;&^($wro%qUp`p%W7u3x{tIjMeS{ZG~1w@gln zskG}y&AY!#VR~I`=z-8rUW|dgFV`=2`~H9N+i$Zn^Y@3Hynfwn)qCwXr5D!SIw$y7 z_DP1o#W&uzEBrom-<%$FDy`kwE#`Pyc=GuzLBZSpajTY`3R`gTTCiQ~y#yDYNx{|A z7NlkuXj+!tZE<*#(7T|%=*_lHjbo`BvaiGov}|9>ShDIgcVNl)s5wWbI=XMk%e*?N zW(xyt%am^0Q!alEMInzOd?Tx00`gL4IUYV5E# zt`1Z2NtIg3nBi3N^OnZ#GXatd>~~c!vkzsxRnrta$@b3lh+UFDYpxykYg&Cj(c`Mc z*}PA)gE-DG>h?56GpVl>y>tB6f#n}%wp@~Zwrq}p;kWG_kN3_jlM-~?T@rmn@Xo18 zywk-lOjh5ry3x?M@A9Jhspl%bAAjn~qg;N*`pyMoHWhF4y*3N{EsjNfm^isGht2Zj zHKxY`E&Ac91x$}WeUJ`fEWQ8yjcsv3vUnS`=+=14@*_ig0jSY zM_x~mDBE>@LYiIslLs5hBkkX1pT2OfRDP0jRlr8kM@A|IhmQ8G({8cZc<9E}lb=q! zE%@xX)xdMDc>T0(UnjY2Qo8Hr9+o}3x-lbmqN*>z_ zXK%bM&N8hR|EzxU!EC+nY;Sq?HcZyI@nc$^@xLYaxB~gpoVTnGIv8-QKlps01+UD} z1y>)&OSu_@9!akF7LX!bulnx1xQPD;ZU1^#u1RdSkKdT~uuyt~$||z4urw^JvI~!~Fg7vRd)^I>wjFofd){r$ z9+yQMon|g~Z0NGvd){s9F_7Ti^KN_2x%JO>geY#GY`^!s+k*AZd(XSgXnEttz`$Sx zZiN~+6f`W@=dX}({r`lISN;nugAL>V|F03yaNri0Tkzju!^d9}6aGJVy1+-fI+}rj zwGmp%USw@*Rghpw*pT{!x9sl!Ik)frxUlxW^}!Y)a3KpKezcZ|sC&+e^`4~C&sDl- zkq>X&=}SSYAHO*Dpw_ILyR<>c@W+&u-_9*Eu9dk}wzD(|gk{2ewd3gGm)`B}sFFg1@q$`PfwPq`yXtvUljj`|*0ZTE+Q{+qLAY7xRVz>9U6b;+9X*@;@~g6}l5?6? z;}5aE&$n5+jTYO53Ks60Qg^4Ok!PlghR~_L$1}_d?_SW}#$EA+BW>AMq0jnBhJG=N zGfb8w1@GyrD0#2oYy7+a`O|)%^Se|{ubwMBwn*sc_nyi)fx3t84ttL7HlF$~WWogt z>GY6P&AJ~w+71pplQyf%?p(|uYjR4t(tblA-x78GkgYF@btf{ro%hr>S|~MB_(7a# z;)A;!0m=)D(@WN*vb@>!IA-ztqpO}QtX==-(3B}D9(HPrBr_)3spNSt%h7Q$xF~jO zg3O6Ik4pqq(k-vIK52>S*-&pQpu*?y{97xh=hR zmR5r54two*e+5l(Q965N!u=aU2X-%t^XYo2WHIqag|m$G_3bW84&S?5!02?TK78Tp zITA{3ia#5#YF-RzS!eOb&%>c=`ldMBEz7_86fO4Pd?UGHdDoLNrGuY+H>w8kFQ2Kr z{MnDFmadmdD}+qW^}U<3B5&vfS0R<9ph$VcC5p#?m9T<^eZ5ElwXV zRCu&DWR=d+=axbtR|4-o=`%@4R~K3o<9x21;yT(-gk-E%!=;NIkH^0<+#x~1Lrd?MMrlZ-9AgN>5+JRjapXh zR*!e?(M-1)TD2NumoMb#kdr$%F=MU8{^VIluD;!WeVS&-&Ywziw2Z#b*K;h9+-kbX0tc5CER3pJ=V8Ri zs(JIMfuYdM_PcjOgcx@q~ZQ&)mkgcLS zCa~VlbNE>ppYl$(#^O%1pmgr@>`e;ClVtA7RmOMda!z98uB_dExIlhVRF{HvmeP?& zosWD<5+3}WkTC762%oXMQ0=*-n3y%+U5zeHdC~EQ^^#&bYx=Y4JJgxXu7BLw{x()Z zZ_kauqBAefc_nVjTI+Jg(Zu1T$QoU?lPX++(z3m8t^CuhH6yRh?XHi1Qejg*@x&=nDaT-y zZ~l+ooRjP@k9w6c`>@wv4$BRJQNMVWFN^85KP_c;tm~foUX`t@>sKr@TR&~acEnWXOFV)m&;>&v2=Zwr;zcPsxmvFZE%rFH4*NwNMd z4Mi_`jv6yCFnEG%JB5UX0}BEK9{e}B@cO~~4d4F%|Np(<|MSld6aK$fa4>lBvtYr2 z{|_311SV`q`0)SPs|(OIXy959L0qtQG_Pb}U{{A!f=8~lPFrmy!uFtd^Xsl_x3`E( zSN@;AyK$XQ71QzwGHD-sOE^D$??0G-q2#bmWZT;V2{MO|ieKYkGjeNWZ8q58)~-0? zhsjL8^dBbeiVCLDI^k2lF5^k&yMChRs1G~$Cf6+E8i5NFX7R|h=-+?(!STlp9@!&~ zS=*|jzHH4hiN5Y|Nk+4O*@r(1me;D7Ozd*#>zg8FeI)byTF-P^!vyJaMikB}sZGWmi+`854 zz&0Oaq075Zv=q%2VtaixOO$)6hVg`1A^zOE?DATco-A_ZoT^d0iX(gdFNxDKPd8V% zZVlgLA8|mGW`V=>&3Ki!3X?g2kq<$&y19#A(2TXgd1w>t$YIh5(YJPd+B=XkLb>7`g z-j~;UI*P zp3ahecIbcog>^C~i$&Z$mzDbE?_9Qg`NU&Qi+E1juk&fO+Q_l08BvQ)YG(Q9J~a|D zIO4i#@z43cmITieKh?%{Xp+dqCgVVl#hNoKP8mmSIDR6;$>U&;pYhU(t8Mw0e?C~^ z~tzVvAsp;wfgI2rmsBKFPN3M|G$Zc=XCkC+sqDEGcLMz`>NHfsZ8-7B&P+` zFDtpyZQPQ~X*wruv14tGW7~#y-YMBuuKkSbf6QIIB=Eb83XIZ+<_;cHa(ydi>KRASB zD?%kceGBh6yGMkpue{PJI)3%5^-B(Y@$9(reCBqow_J)RrnD?7@s=}K@}>7d#ce^& z=$V(U_?9lWZ&FO@oaeqwlp8x7hcFb||OJG>e#^dFrdP zV}_=S##7q5bwaL3{<2*A zt3O>$&fc~rA~numwoLeX;1B<@Yaf)p7BD{ekoosa`q_>Djd^brG`rpH^Vn!Fk>Gy+ zi2933Esigz^zB<;s3!LPb)JprI&Nt^nk-~;Y#zVzL-;9nn}7o>)+QTyIrcN3Ew85qaPR>*KvR$^bKuup?zdT7JDMZWPReN)<(zHrd$P5lL zX=9=Hc!TV<^Zga42fnaPYzZfCUpiBnVtIfHwpL5|00${YJd9 zc?|;t^Lt2R;O(vF)7EGRuzxU0?BqzAU6s`Sz5aNty4mvJn_;Z!F>@8(akEpE*7 zMW%Z+c(KWz5l>94G+tIXwaY?(gy$J@VOzlzqs zoyLCf%psdVqoo|pC2yDWi5na}Z)_P)dWr4&=4%;A~O z&x_nYbn z7?-^b-K)-$sI&IZw%ykZX3unF5V!vEc-!mWvWlKwH#Lkt{5$Vc`}?Uu{`N%^ZtvT@ zYi7sOW){22Z$9w+IqEp;+u@sY9(9EB&VTsnpVm{`MT#%<*;iKbf8;0=Z?@Q>I_>*w-5!u!vrNu)oqm}KvB;6m89 zeFv?#P4}2-=@Lo za&d>6W}}}$r)EN@mAjlC6Vp$**{Ak@SQubhpuwY;r1kT97mM1~1L|R)3_DiIJU=bW z{fDdda|$cRN^j+QcE6A*JO6}uiG<#I80r_^`nZP0?S`>rsgQ@})MbUT*BEB9M$TuP z^t(GXu0f^xKgSuXwwrS!7H2<7ifokdwG{60iAeA=SYqYbZSL7Pc~*?was`#edl^dp z0l-ODxJTso8U=tSvWvAC3+ zrM$T+QxY517xpE4pOpEx{c6_HH~eW!WzR7fw3K2i)WV1<)DobD+Lt{tzYbz6zYbv$ z+}NX(AFCM`s5PTn<-<-HeSLjX7q>-jZ_+#`e7upbV#ybO;q}}VJgdtRB<@Y?zoB3HOv4>+$BJC_lqVO(wH$jO*t6tu z`gf(zmF(BvPTV0rV`b?B+kM5t^=&DCmdQ@q)$KnaY6_R5wtZ@v6HA!bvV&^hZDlih zUNoMZa%Y3DcID9&ue?kC@$CI?^KKqK^uf8)^_lH1{)XQzz zVdqZynbtG;p6yGk(s*@tS>Ml14tIW9ELV*=u6RuH(K88tPtMDYD??7OEKB(jd|b%8 z)#VxY=O?@NPUGIG7XI;bVj_e$)385WhU3MDOl%r$>^9&fT0~w|D(A#ZT$4 z=Wu$yTYD_^-xChTJI^d9^O@yNw(I+S(D{l`a#45wt%*geR&84S;om<$7gLw3DRuw$ zhi+KCYL&}AvrDz-m$xlw`zF2T9N)vpjzX^Z-=}OC1EPLKwyu9NHBK?}X?UsiRWI2+ zQ45`)DwVlCW=)P;{qfY+f4k2wJF1tbkh%D_;W<_|zh2>Mn+rS4B&sSaf7<`x++Fc9ETQR;1-9a4NoRnc zJ1>_M7Xt$WucwDg5Ca242Ll5`0|zq$1H*Iki@XdB46wtx%(pxuj5ggj-}1<2^Igj= z56stGH>sLpT-af@;Dmv>mA<~dNz;4-2UqjHbw;r{i7U2GpWU!;Ld2Iwg)fZ?pBojw zG%DOKQ}Wz!;Y*{!^-ep8c-OpML+?IiIo8B11=TurpuGcmL0GCwtvs}+aA$f7uu_iZEvdfikfsG#b~CF+T@cdMh`!R zh-5dbcly1(KUL{;;VBW-&ft{?MR!faDrE_^Hw! z6|cj}=R+>6$-A>Tvcgm9$IM4%ktXNP-rcO5muXY`@J`R7jkn)3H6LJm{-D0YynWqk zzMAYG^O+5+jHc=BwJPiXc4xzU7yF5>z6%${W|P}=gS@=jtTcpU6lR7za?05 zvjI=_#K%iiQm;cYRxp~HvbroB0*WR+9aC&0Ivjmqm zPtn-$Q^$8Wb|3q2A|<&(!b2nLk%`27z0T>0Ii4=HS0p5jWrCa+Wxw)1UD7)JRL$BC zS~J&u(5Z>yNzvj8IsE){%rcq&2am5w97r)~_{dhs&5|v`yYS)1n`;G5xFpYck$YDx zam%8{po%qfvIUiv9W<)YnKN6_!R>J5j~c#Pvs3mIf0)WGb-n4`gaeCX*`~7WlzQEj zBo`($<5OQ|s@J9*!37H!W)-O3JjJq5#_sK{oxNw+(m&j?ku&ak(`)qMmeu#2uKGKd zRxf$*?5kntfu|e1c0Bvyll0P0tnPE2=cbSG6LMtjH|`SI!I)>io87q1r*%?I+WKuQ zlXC7Zeydbsbtv@Bk$EnhCj?IwMenKU+$8xsa$48TZ#L0+=DNjNrOTs?U4OobtI^E; zwLmLVW!p=^r?01*o9wgl{S&yaR$Vi7&f{Homw&(OK55CKkojT9URbQ!&F(%aJW6`$ z%l^L)KZNftD?DHzz#Ld2buy!O*Norqb?119zKQvEx9MNn9?Q5n{?;yhcD;g^Je_xO zST0elZn1FjvvZWcv^;dFhI60953j@%^VsS*o!3obvs>+yGv{aF(K!!0R$aUJGyGbK z_Wgj#hOa+u=3SAMHiI{_Y0e6*)EL`OCc9W>2aDN%`_q^7eE00NC+6hyna=+C#QICs zW;x%>CSDI21Klq(KHH({g{81!6CkFrnhb3V5nOk|n6n73Mxb;>!?uebzWw_D|Nn-I zj|@7tTzK*hv@iOAT?@hlx8O;z@nE z1#3?)IC00WvGKv%FMke6PuPF`&mn2omfAmuq@~%+-Y_sQ7=rtO0uBWYkp>GM{6DC0 zal?lR;8xTB|7M3k41rbuzk&|pk9Yv${a5%uVZ((0iw7SW7+8Ko3aO*F+h;8@5Mcjs zLGl*cv8oMWcSP@g`=?*-dwxfoFq80~+P|;<&kmWy`}&-L?r;6$sr<tWLgGY{CF3~=4Jp!00o14rZjm)}_qDNnXgurcbK?cnY2 zvzj5QSnjrglaNtv4~vM4kF<2&N0Y-BD?Yq*(L2FXfBM*AvvVb8^Zz&G7yVf+QN&}f zKW+coed?MYQh2}mxaDn*`nR<;TXNo%0R4m`W%{S<>sGKZPPc0NuqyX*|zRP7zzk6m4_nO#op4d0=Cyt`*ju33@gHufFsof3Vwvc3QJ=lbTe zd8;;PS}h8gl$sSQTeo7HJNtP`$dPvNbJx4d*A58Uee5+10ky;o?%F z9YOL7->amZ=2I%LjknmA)#r3M&o1ChB}q#zw=11mrd0hVZc@i5sRy#rCl~ZNR?LV`O?@?F& z@-Vl6!^(Rk4sP4AY^DlR<%Jd7d%aC(cfS9V$KB_;&E02X_-&Vz@(R&!*|R6SQd@A~ znw!b5IbmU_m#ys~ialwaE}PVQTJOS8jXyJt!A1kR7SiawQh00LWI-e1*daETf6QpoO%0- zW6gvmD_(G%J#$Ug<;27+25!&kt7i&v-f}B!>s`PXw7pk+n~lIr!-*czm7V$RvF}5* zLqZ+bs(jGde%!aXPiX4q_|rU{dSTaZtj>*KcXPPn*>!Jvgdfj!rI#ErwX@!TjZ@|O zXA@y~o_SXC{7C`#3d3r>l8m?#ufMZexbJuG?rAEj`=*=wtDX$F84(rvi*py>9Odca z;!T^kEV_Q8@x@6a-|3H3=J;>;Kk4yqmh~*xBprojKbn^08z9{NM6J6&;AV^PGXeGL z-)qkIDHOb%7yps#YLC~Y@){-1DXmVXt4#l%cJt1;(Wl!zvDm^}$L)Bp%amhrvpYrh zSF$Omb{8|v+b=G8ZFb1-jnAe}P2{;=F>`t5$J_HgA_GMho9G_@F!wp%?`@$^rP~gC zK3-JaFiq%u;;c7er|)lDe?h0pXlBd5%9CaPs+JqH|12|2z4a#S()l;%?cXYJoICvM z_``x3=eOU!EI<2|PJ2q>XFuWDh)clN*1zse z+zjWQw^tv{to@U@OS5{(%P&{_X2%}?_=!7t##>)YmU2}r6$9%bVk(BE(2AioCa69( zq!o7JVPkAaZF?t#TNED!VKir_)ipKM^i3|GKEGn|+J^GdmZT`ijm2g2mO~hr06aK7RAAV)5Fvw%*wCy3p*x#QIiaGc$dCeP>_)tlp_s zj!wR@iOGoxH7W7274^>kK@Q%&(Hk@>85kJM!BvGrM8nbpDgqb&&nS2ct`PqJS6%S` zLxDq7(}N8cpd$Ydz!)I<>#OIwlU?K(7+9u4DvY;xz9+Bp5IFF0>v1mT4#784%^DuB z{{LSd`{uB!#qS%DkEg!(FJE7G@7$)c)|l3$l_BfiXifJz>J<9NX=~EYh5y!iEv^Xm zT|3ihNp;4(Q$f1dJ5QM}6p1d~)pj9nvEEf@-|tl?EWdbbmEN4?l&zcT;hC}a-}&Z{ zcU+(Bm)teOm+mw#$e2v(S- zpT2uqhI^&crf2;V_++Bb1YGHxd(Q9d!z%$EVY~K)PZvKX{FEVOpT`V^3_almhhA~s zTDN9`<%Qn)7bbmhu##xn*1jjDvrmZc#H2X>J1Ld(c=?YUI^OXouuZ>Qu4C@42JZ>^ zJ#L3LxW7`9`d!2{Y2o3NQ!FnT1Wo4{p0^CjcYY_fl2uaE>D97RlNMzDS|z~!$y@A2 zR{0afH{MOvVy6VSEk0dQG&3*}cqK6H<`+u^HVt!;Pg6~u*i04URn=8Em?q2d*dK{) z&E6rBw`lz%-SdaFc@)iFmwgvkf9E;X<#U>V76&AO?GPTDoDt;~Pyr`D*4fi5% z>F;|oANlUN#<@TvS}pS7f6FV^3;G@`Dp9n09OuA(L_y(+r_v0CX)-DeJ#H}*w#gi6 z>DhHkAZhXu!93>3$}E8@v&5F_#x+?y0>4fFy*k@E-^e^DIz{7(;?i#y|>(aRny|`U{!F+_mfu@ zAM+8W(oS^=1+yip+Hd)I4$jQ<{Ick@WBk4dA@{&f?vGzqHZeE7V_3k>zmR)VugpQV zjlKt1IjxL3?nx`9i*`=8xLZ(O)w+yjv6hI!mst%zH{Fb8I-ytbQ-CW}<-XX1b&tN> zeQct1=YP&bZl^uQ3K6XbuU3DXZ>3NX_@YUH=Wyu*11E!{MnB^Vmnq6jle1@u=9zHr zar*iZtF7u>nG zac|t`_HLt9g-!)!?wgw%61o;%Z`2MhfB0}h<=rcxr5!<~BEA!1&n17ayno@ljN=mFMXUcS{&!x{^-EF5 z+-%1tfpWt+VWAo8q9#W5&$yh1<=o&Ubh_W{uPCS{m^>)hSZ=b$^ z7Hr&oeyDcF*@*VYuyB2S{Ym+?mWC#C=FE9@;nu^3We0=nBdy#{pFX`VptP&2Yq3wB zhr9dJr%xN5V`^$@($dmC9K2#{YO!nAu8HocDKxGK}KI^r!p`w$b!pmP&0qS zfe8T@{y$Jy@WB9dOcAJj24UyG&6gfCFtF}{l+b6cTy1nVY3^j(Eyra~YP9v_U)A$F$;a;%DE3OU zpW7>pv*Ognl-?%ws~Xx7Hs?>(NUhf}n!W0Q#zzKMPj(A0Aqy`nH;E?sPu{0>B!aJA zk#+jutHjWCe51tE2&V~=PCVWn>NnE&r?jz6IOCi8Q-$^Lnllq3osMj3@lfIn)KTPH z{OHZfpDNdErYJv6WU#q?V$oW*Zh@!#y1jQ7@B4rHFH3r#a(2oN<;nS3TK7*moiI97 zSihq0i)~Ejy}kUGZ=Qe6$n=!?;^D`SZG9f^Z+n|$#y{bQ3)f3lrIJJyLBXR8yLVr< zk>h*BtSOZ9(Z=7RpZ9y>>4saIg)(o$Z=C+|3Wo-d+KFu~QE?xd87GFTUP|JR z$=?0?Y{d?~1FlERgZ3<5^t;dH2*Z~pE>p^!W&SDOm;7DME~tN{=&zK3sB-!gj)?7< zyPNu^X0mHjTE2ohhOkzpD^R>{a5Y<1gM&wIQ{jPQlPd{!V(Ud84V0FKmPi3 zSl#pd*w*ndL(rml_bp}nIfVhIxwk&)5NgxtSn($Q^^uMPow-gdi+qIsbp0_nS(FmC zY^}2BmkpK^Rjt=@&AWHYbO+0g=YNCGCu(aKT0au~5>dd|8Pz*&wTrCJ(dBLFFOs9L zRh3>UwGq2L<>-}(tQFnthf}noP2aq`HT!FcOvKE!db?z2s;M#Z2(MO2ytTb`>Hfv< z@;R3&e0i^aTcPNnoX@(l`q%>k-~JhEZa=*~RFp?4e2*dv z+bgY3JGI}7%O-5P{!Dtm$r=w&UOS$o$Y0mWR<7@peZQyU-}?CF{`%8ywY)wNsDEhs zma3}t`!A&3nHsg}v~`w1Ley-Y2(!iRf=+5bgM}8zF&^96x$Jzh`GSLACp3zG?DgFA z^m*uGUzvoJAyc2bY+Xqh-=va5vfJf;ITqzxlBpPi#^V9vDXgpZnN zxJ7nyYV7%MZ7wm=a#c6&&)gJ~mhe4Q^XSG7qYd*P>Pj8eKALlW*3Sb8{SuAq&8#yv zn!E3Nt}(-1f9d8q(mK;lFMY|gL(0I@lQrd>bENa67e4c}vnuBno9$&twvTYD?VTZF zdPZ`B>V_q+CavGEd#T56WzFZk*7G~&Ph8X`t@X;FLgty>yndrgLBEXW2k1Y@_u0f0 z!PlK%QLNOJZxZxhny*;L;M1+(m0a>XI{V&M=xe?D(QH)v_28MG%l#HV{QvB%^Uaw8 zEr*&~-`uG9KmG4(-CYMol%LI8xpLl7s~>?jd(TZjV*35jzOPIDxq5n+lzm_GYr?!W z-8I}B>{Z^G{Qs0DwI<)9G<}ie(oId-FTi^X;wSDz3#?8c~4x;IktJ#TU;~+?Ucn98?9ThqKYAY(eFgfpOZN` zRu#B!+Gq3a{@2FLwH^vfmuvC95>ghMIM?~etuM@WTa7;mDQoOK>0fv#Z?E9KU)iL^ahr4eMuTR|`qkpemX=yBf<(0`HU!1FQ!gN3V zIh}M#aV2l4#gm6=OYc5ol$ttCEcNKY$&aTNp7Q3p*|zYR&7DZaFU-=l#Tilijpf(o%`clDLy;(+@m* zv*ZJFt3$@KuhJSXN=eWHsbKbNLeSLjfOT9ylac63R>K87lS-isG!1LNA z%UAYQOr15cG*QEA_uZJyC$m=XzPe2Q$7Z>VwR;{FT2Goe;d;6I&pq%mQ z|NXxO8nXXCX9a`#vuXwg)^m`W^365YswW0KtO=|lZoE@>zB9P@KgYY3aW|L6>3{wo z?4ntY#UD1{0ijK~KbS4_l&bjtl-boiKlonk!D@lN2tlP?Vt=d@_jNr|=@Phnf}fc| zJNT&eB=J_D?aHco7W-99fGmXsk^PBfcL~^d+@wN(U*e7DCry-&uX({`M z_c>2WZO{wet=&^oKU?ndPEtPoytw3tb>`)M%@@I`&*cw4kq~lTTyFCu?IWIr zs@##E5_CID-@VYWX=6Xm7P4^t)(;ZrJ|3SV?EJVmW{uEiS!HQQZt)1shuWbFUo0rq zUthQ5U(VGpE8AvA|CKE+{eIZ?o$H3__BKJh{uerg73E#>W~VD2IXz>Qjn9Hc3+J0( zOizgLAGqgJV_v_6t9#GQhkDWX{#Q&8eYez||5KLFo{v&ln~X!E{ocP{t{rmyMAV*Y z#d|rIws=VfP3ROToxJBv(cF#a*k_(`d8^X@C{mf-`eK{%qO%oxb~&BK^Y3QKygk!v z_U0mg^2fw8|9T^`<5INd?UjGqFE4L$yYO;oNSNo3siv<3@}%1qo;-P8*?Q;Ay_gQOQQ@=Abi0tQs4}i|yJmZQ`SD}-d=7?C!@$`V+gfZCIy{f0_mzIV zEc*JY%C--xO`ERGRe5RoW7Yhmb6-=6j=LP>m%Q0hdeZ!~>CBC1Cv*ufE&Abe z3lEo|LuCVj~fmL1oP&1AJeL`d-G9MXPy2}wOxnyh;?2+?DXzc*yKak zk15WW^dRnZmp>1GlckyG4W~wh0_OIYHEVLCF0Z>kPp5gG+1Xj52d6$RDt>3qU45j@ zd15B#gFiWTA5(=6D4W?D%+x!vGSBz-w`Ciz$fsVoa91lNUrO|ixT>%6?$v!O|0{Jn z-qLE;Yh66!Vt$HC%Z!*_-A;?JgD-S#>y!7Zo#j$;+P!ji!VVR4yScMmHOr5htzNxu zLA*!iV;9YzWp9p5oO!ZDtEZGjGvrE8YD#*cg|+^l7@;3$8e6qRLn2selNchUCNDki zyhrr*?{$X`Yc*~1VD?+Al)L}#jGZxZwyoKUUPUd%t9@LrSAFT~=#iTf#lf+5>w|Aw zrpvi#JZ*POnd)iOSr@QuNA~6Vx3j`$-BsXmbNuq_&H3N=)2n3ucl|!__Ic*6KE_6N z&(&d~b3O|!N!~f1^P!Ugl;b&9*{zP?qvTZ^0wB{sC}c-vbXs`52!*5f0xfGv+RM~3Z1>=O(BEjRA)c^S)mdf^qvmS+=1 zyZ$tJ{43Y>`0JK(V6%FDl=Q_$rpgH$3iF?4T(Y&^(%)OV?O4R}U%VZiGgM2K-~0Ky zTi}1Y=KX3Hrmmhx*CJ*}-pR=CD!LZou29B5aca)K{T`J9f=2QaMJKAf>pqlr-I~EX zM^(G9UZwKm!^7>-A7%f1^y9v~SnmwBx^q7}^lx)WYO!Ws4T&Uxj~-Emb7c7F~@ zPi(V3^TBdA!H)^+fFl{kk3bYCAfOYa4B+v{)7= zXk1^f@^zp5^*+6AohB1HEO$;WKfNGs#{%6qJ2Y3#G@L)h z_QUm#`=%8<-m3I$vt_hsB{Ks9gBPSKEpQMx@c)8>V9~w?{SCGs{>vvUxG~{FL_@%X z|Nk%k@BaV)|EBN%X8m3e^&fOg6}a*Q)ugj;|Njr>fQY+W|F2k(yp)rHfz1t8pSIRL zwh&+|XjS78ZZl%J7CNW&j@94=P7lry_r+Qzjo_{mD^5gdOdjUa_i~Ul@k>M z-|AIWZT+-S#?~flZpakAA6#?m7QU#>N%79>YZU00+-7iL^=C^zKO?5VM4JW%d+XSD zEAN!g2%DK9-F&5EHrv0IxlURqRtwb%Pte@+hWk_1lA5x$-=6nvYOx0+1Eg&GUzKDAP2V|Z(W$JmN0;{QPrK)|!m%cJvYl~g z;F^@jx7t^{Hhvan^Ld>{`aU^D8yehUe47fy=1Y~*Ew&+T-syTRQMG< z(73Uqopqx0!Lr}16*-!xsQTBU#ceyr@`tT3&J8*7`XuXL?g_ zm`iMAzpvsR;hV?Z0;{QGtv9s8Z}U zApyr%&t|WSe&W4r!l(cB7n|Hxe7NXaq;Yfi?CHk})_u?3j_R{XUtc-4P1oy1ogW;#!bIeqi3!k6p)vCs2ajMp#v zJJZ->QvTwL?utA1e&#f~GJUqdhUpov&z#ESU6|G78D{sdZf)i3!Yi+P^ZO4v^%oX5 z|D16{(rHuO&6xjp1?J5zSp3~nG*s~4GkfJvyH#TTTS+`iEa;1W_x*mDT|}If*GVPk z#Yz4Cy8=GEpR(&^e11bt$kJ15wz3#Kzh<2z@&D<=kE!ny_wk$ciq8+bQdR$Y+k5%z z?z_2kx5Rv!J9o`q_d2^33l=MsDRpSLr~6%B`S_Ca8ug|hQ_in6_?C9+r%p!G9T^3& zTYAb%KR0u{ap?`6E6lPu=GogvJ^@ojPOX`{FC^%_y1(7}g+D!d>@NH;^qf1zB=p>h ziAfup40cQZVykWmK62`!`k}aoSJ!Pa^q#w8-J+L5izhAjH0l-X6f<1BCG(}qM?ptT zpBwX6c8`rbAbtq}J8WpeOHaaY9Mo?q{U_`Y-dNGX*Wv2U31cykTwch^%Z zryBL$)2+_&^LF%5eU=i&UA4c(@|MPPjyA^A%YP+2yu*J;bMva?IMwYuCk&=f;re2^ zRZx*5RpgqsblwuV3~{E!!zaqjJ(`uhw*;sqN_ns_UJ!Crc^YoqqjQFDf|6mrrF2J) z^v$;nKYPBn&f;Wo|J9=)nBI6YCb;fqMoQwh#*i7#(>|^4u)n3`apQ#KT#HkIbssBI z5(SQQ7dkp7Z98PevhbMd3R{o08T-CW-C)zj8g!O> z#d2`?oBMpbBY2TxQD&y+31*Egr@gKOotpN3M$dWewR$W|b_xirvvc^?U}3eMMJ{Y! z;JMvfH#VJH-*q|Z*M)YwFYLeHHu`OuRHecI+8XET=d#Wzp{b#RA+>{nf#nJ@^*C%r zK4dWlWA0)I140VaZ-Ow;NcNHyoC#fW&Y*>1+9npl!6odatK_F0G2U>?;lOjvMdxgG zKNjuSX|e6T=Hd%#^G>VHKcm0;s`io#%Ck;*itoI|z`&pasZ|3S7aW|BApie?z=jV6 z7wkbb=KufyK?_0t|G(J2?9qXUIj8SzWnf_b45=^g++d&fMS+JofrC@w)s^4!U)SIE z{!><9^3=L(NR83w^uQ0Q?|e3S|8QG)Y{ic- zQwb3Eq^VjQ#toLqnnv|!)&SZc5D%&LMykrH|a2by|clM~P zQMjYHZEBb39P1;$TIPSgwKa!RymQyy8QOZ6OOqcY^?p94e0lY&DGEwCYT`VFZtcDj zn~k-Y+$2Sf-AbcuSz5ogOt*02yXGRcVn&9oXh?RO35UmeW$PD_Ze6n$oOroMNPEMd zqZ<0^j*%Ds96w-hxzlOxV?Gx-&Uytd-OL+K&*df8?mptwe5if-aWkQMW2@brH@X(r z+H;7-xw7mr4{dx}9{RZGXxW{$ERk}0C+hYe?^q@Bq~OnEgGsLHCtm(IpXtvvDeT$D z^PM6ok$E<)I(TWrD7SXSdr+K5tgJxmQ!b=N9{15v=~NkLd27|6j_O8WJ>6>@=tFI1Up7*1-a@L6%&Hv6!4SS%{7ylvjW6#a{ zeX%DFn5gc*S3RfDWPRGqeFhJu9CXT^4tx`{ykKT=iDl;WLNx(Tg}mQOjh}w*x%MI2 zT~0GwTM^f|=1+ zN?$0k@f>E}IKy6P7qbAn@F5G%@Z!Tf@jI_*vdm04ekyZD$mWj1`x!jki_$81CHtBe zFkA7&NIjkN{P>%n`(H`U+nRjrOzb5_=WLe4AEc_gR$Fen+VuE9&XUS!1uE45j@B-iA84TkmNs-E!>rJPv`z3NhBe|H>X}?Typ-H(5Qn z7jP^3siRRu){`mDN`jN8u^+6;P~_RvdTZev5fzh{0{7NG33W)CI$5tT{QY@32F?E} zFWvw1W??DZSf`OvxM409z$3E!@Tr4WZ{B|Xa`Wkn{hN1x{{G|t|Nqb4eP~#@Y0j>L z@ion6R-g^kPCot_ofE^e3kqj0^o>ohb#$_5?R!EzE(kiEI_e9;^Q0oH_^-K!Tf#W~jeXZPj5IQyYRj_23kd!I5mhw@v_ z^;>@VWr@{XKi9~sXT_(l+Ovv1_VlYuHG$!&3yu()f9W0dW+*7CX z?$ynW>Tbqz&);h}hHFJH)m$iDz#PT&>kOk*71J#y5qJNHu;n2wU$>|5`MSSyijg&y zz1XS3%vsWE;O@?3en~tnOUA}wv z5!M_c4_+d=Wv#&L`lQVK2e$=^7pN>PITdj}!fDf!stL+b8mmMDg11y% znlXW31xsz-pv{-BJHOU$3VEZL@bSc-E(PV? zKmFtuE@zFr`S!c&Wpj(ftt;iFZZ9X`09yOvsSoPof6l6QE#6tc~zZV;Icht zKeu^rJ>wiw@HHs>{o${w4p)ti20J`47T~CPcr7>DeDcfN@65If_sK663Af=p65=uO zqU`J!U;bV((|^VFe5vEf;19bB-~7Jpz54C{mGZ~49K7bW^7R#!9{*r%kNhaxAaPGo^jS$B{J*d#mr@S;)Q0xB@j7jO9UpgTIH1>E=I_OI4{ z;?t=;_1Hn(kI$VR-t?Wf)WuEHPjLck@<*O*C${qEH5ZQg_3+(0xae-)_Sgwt`Z{EE9`}aS1@E|`{^ZdGi z`=`49)xT?HU|_HZ7yP;nd;ec6m=P=BAYo(RFze|5`hbR6_y50NpSb@2|NRBvi;|!% z-Sg{TgIUpF5=1DlSwEW1z`z;}sVCmfVxPXqL!hBLy^5Jlgq7R&2yeo#LK_dhYybjho8sYE|!lKTm&FRMyvg{x$quSmC+=lY1J|Hl@3ySR|D0&H3ka z{qv3)E2K1|ML9OEHtoG&5v9VcFL5>5EEJ!wwo+sROOR#e z{rvm&5{mQqIZdM9rc7+(Re$w#@+A!^PmxU?Dq9LJ)LYAXEW7>gp^V(g?~0wXI*bh_ zNj?h*?mM=SHHnGk^0hY_La9fYnksyrv7J=-y;^dE+Yu&@U2i>>#4vJ23wJDZG}cM& zSGqsRogVAM|Huh6*PCJK^c{p6SQQn|EGM6o0Sz(dU7l)(K@L^O_wVp~9Xi-iO<}cI;A^ z$uFlGwDHp;o1K>)^c~2_=V}eL&Tq^qTIyuj`t9v(-d|U|Z?6#7?5;ksQvPGwE2Xbn zTwVxn|G4M$?rY~#E_sHhJZ5g#Z+U<3LH|&FkH8e+7XMrG)?U3D?altO^M}AD>+sdp zH9CIIEdNuFcWh)o(sJ*P`IL?aybH_I)>W10zwB~ha$4fovF4IcV~U`{s@Ed2FMyE{>&t#R1E|?k(>HW)_BaEXd+8^Ze=b zW_t$Da;2mS*$?HnPrtu=H)RvEhkr|lV58PVro+xFJpzBS_RgGiqKubcaOV=omd6L9 zuZ6N_T)B2)PEo<0lTz;vgVgS;5kt-BUJp0LWpY+m0|ey)V+CsY_zGai+( ztuU$yXgN1aNjSi*d7|WU=2siu<;SJ-bFJ){ExBm(I;T(NX=$gwJP`L}oWJw`sXIKC za)0hTIJ1T+pue;@ZI0{`$N$&PRM;&!?0CnakB@!!tR0O}3@Zag%>!D$Y&gpMMUk=o zWvg@ER_=yl>#O@dc5Pn8{zj>hWg1(O+JW5Q;NP!`Z3`^XV{)~KOIFl z!&$6mKMqbgVe#_z=DCewCnhHA)TI4?<&vy7XJXA`>wj)ctY;?*?hl@O^wq2h_A0;j zs4K~FotUT@?ZV&~?e@n(X+`;Qk0nR%OMg|I8R>Jx-{UN|(9DnL=ZdK)Z#*HU@NiLi z%e4=#S=T#C6kaa+E**6_<^DApz3!gZ1x_0}x=Vh>?-X*qv^#|1U{y)r6NMi;GvjN# zyp=?9qD+53O0M!0y)dO?URUlOPEViY^DieYQp`0n{xe~VYT7j>pK`V2lBsv%OeZ;C znrvA0HthTL{0r4ae*PCjd%eRsS&bD~*tIOfFFlj36-<3F!^|Em~}#R(+j`G zFA0kx9WLi?P0QaBeOGP57t@38>lws@S1e3qZm)}5;bilC>xL={E%H z>}XUw)~m9*T;r=f-!aghL2z~BP|z^@K(v~`hW{UKM0{onV_@LC2&p{ITufzZR^(ty zV2xw`lU4h_d)@Bp>VH~q|IJYsbFgsvZmpSe*YM*z^+hw}G^gCTzVW5xG5u{qo(#bb zC+>gU|AJMF@BH&l;|0+UX`ep+S-bK@^6|c9)1RIVvU&W-p1HlGCfk;=K3_ic?v~i= z*}s|(FLi0U7ozf}DDFppg}eOWU2nI!JwCb4>7w;a9r4L&OCs23x2TEy*%rH;Lqp-o z|Nm#-oa}P0%qp6kH$^sXrg_1CtEsPrUax<#u;t3T*Z&{<4qSTSw?50!C*QUn@O5Uk ztp6)`u1zG>!|dRb$Ge|3a)bu_$?1_iov!S8*o8B@Q)b3#KZh{6pp3PLk9j>^FZ=j) z^6Ys}WLHRpY%x_-ZsSU-QGMUc;jym2b8D&gjA}hAb|1+jC-eJ7%^fE2>ppqiTJ8Nr z_ix^>n;q7?%#4~J*xhB-9|*0LpU-b=vOvf`#OIcpU$Nds{?v@*ewGx5gl8d>b+4>q z@<}kbJz>e26My&)oU97$tGzKvP&c1V-+(i4z4Ir&%4c6MZ7>kC?cK=rC?u~}m;bWS z^<6FtLVWk;UA*{QrIoj1R@EJ+PnUD=ZD`pTcSU@*_9QoNcg6F*N2V>;^x>U2hdJIH^tNsPyLwWWki#tPh-EDpKqT_m#+Sya#o=V{p^fnc)lx12qhk>QeXtImm z?f>#T`|h{ilm0P_OUdA(%Ea;&7IESVP1l5G)!qIn?5J|vxK*g%=~|W9@hvloa^|Gf zy-s1;cxB=Z)uQ&ZFXp9&%=&3*GV{1uKvVYn$P=tFIcv)?PQ^J?6fj< zmJr(<;TF#&8trYNk2W5%OnYWCv8u?cLM9>~#nXjt!Tg+eo;ml`Yv+#aWZQZ~&v(shlfYQ#hQ~iNnNsVQ{*(W8 zW@g8d@}x2wktcF{gNMcE9C}goCvy@Fn7+&-xv3`c)x9B zzdoVp-OGvqss6a)sIZfny92~cw@&o_(AjmtD#(Q6#0pdY`!4@mDszji6h4J%Jv2$` z`ri>DQ|Y#}e@1oS4=E><_{x=6qJbc$@dFO{<-I9f&DaG3lmFpDRoIK30yXWE8 zjD3O4Y+I&ozxT&RSo!z417Y9ZPL?s@)6dtfZM)n4Ud+RzS^cU_>{|W5s)xJX{xDQ6 zH|f#JyW(NFd7oK@*S2Ws^1}447XQShv~1HW7W!tqR?d!Wx!t;<_^d*XZ!@Qr$hMF)W7YZpGdd1Tbt>8U_xpwYzE}n4MKbfQFYpwhLmQu~A*7c1a+&^a@ zTg=V*{}x~KQ>Xi!G2FZX+1Gz8W_h|19 z(3^Xp*+kjsxNeT>fhQLQ&E-Td&4{?2#eRQ@Wam#??qi7}?AN=$X(-fjHnrNl3VrQv zo46#}%lV)~*zd(Nz8S2RTH;)~cH{M3nMN-E?o9j6p!3Gc{jR@!`Rh#=yUtCYU%EE! zM~zL%*Vb<4&+96bKb`bdPMOEjx9ix?ck|Z<%w{^jw%_2N_!4bHA9uxNjvWg+tsO#Z zYBXa74{Q~mUEi)Web3+9XDjno<}(*g;d?D4qjNEK<@^6FKYv#|eqqGXUFY}iIcwbm zN#Cno9+M3&E?#TPT)cGVrvm{gAEfp_UR@`=M{)m+P5)k%NO3%56k8j=d@zz(` zS-hSk=qBy9_H^x1CXvi-`7Cc|*scG#Px|xXV~gJPK3HRPLv~Ns8js6cPOM$BH9#-d zKFE~RIGT@Q<`y}CGj zb8VDOe{vy0`_t3Vy|+1K?Q~oE4qwO?e^j&W+*wtt7Yj}s_+Rc`-g@JF*sBTCxT-@h zs;$e8mYtQIYMq{Z_KnjFR+h=LrGL$ucUr~4`u2&7w+sV=*k9hWi?Thgyw78X|HKt1 z?=eegN!)$&M!s&Uh_2WqgX(E}KTo^gy!@oqrgyJZen(r@yuA7*D(VOGLgt>DYbMjU zR-ajy<@sIev4udcnA?}PcZ;v5Z|yyDI5Xh)ngtz3hFuO39Ea!KwKka|wGuk(4stdDhkl0DYzzSO){QM!SKjm-l+jK5mVB zPZwUBH}^@wBT*57FLP2FF80@Mv$ZyFrqJ zZ7YWhaf^*VC#LE=f7rZ0e)Goz zw^!$fJ<1e&xo5+PGtXstBqpwY85?^t_ff#<*O&5}Eho=SxKe5F6Y?hf)qXwIh93Wa zlbJslzp9zBanELZnVKNhBPG>;|9#+ZuG??@?vMWu_AmyHg7Od}P>Yqp6Lq4Gm86M2 z$fyWG^4^VG&$gXifhP5x29(;2A@|(_0a9xkiUE9BZe@{=(mMvSt!$I3O?Ck7L zojNsd-n_K5w33pNl`B_T_{*p>0i6Wi)^gU+7a#B(+#Q=j9*r(=d+H{{#zJniJa=Ch)UH-B7a0{`Vpt5nN zXY{ZcoboZN5;)B3U;gXz)f*kj7cD191ffAD@pkoC%44MdEMOk;_j*mvpOvW&ev*eUT&rqk+&$a;{CCPnGf^sb(N*m zho~EEGTWT!zG=g%JFib3JCI}k^^j=chE+AuOr1iEb7UH|2H}~)I8tEp>K0K zZMwG12e$I8dfg(+x`WkX?h)3;pX46s-3;9q`f--zIom(UyL-PZ^7JW-PBYl!zUhuSlaJxK0l#F zoQKUVFy(1jN(#TqX`6lHd|#;R z#92S@O6b>2XN|`RQ@B{XjFTkz))+`|tecVg|AA-UK1Cr@TLYn#>!oMEFm*Ry{5s?1 z?H}j+pGE~A=J`@vbgPfC1)w0U*&llgI;?y@4K=}DSG2c1-E~GS06@c z8J}2sWp8)R)7w7J_wEo3TIQ)1lw8sM;a_)N1#8Ud_V9b3Of{7%xpivs_?7l;|3t;l+?*^8 zSHkb|1{!khXZH2VT72?q#@v&C9Br;n6`2te`r7BgRToi<(ruCHO6${BF=!rTShwf7 zzLBUx>KE0*ul9-|&B6D5_pSbHzgL;t>#N#kk0)21Of9~iUDEM9bkQoorEHUxL=G-s z)O@Y<^z-?73=@pBor2S*c`$gq?0WIC+rp?k?9Bt;uU)YWPbSB==Sqog@4girm$vir zY|jXh?{2q>*BgAEbmG48{(zkMTc4k8-5DXm&h<9)5cm2c+S@+9+MaUek7B!RzM70^ zf|RbX=9Ra9EEeS0Zb+OSTp=*?)UN$}cTLVOG)v(-cK*|;GTp$)Z_0Z=7*`Zu*3m~cTA(+I!LRn6Ue{MT$fzD)O`W3`1KbJ_w{~WQn`Qn+l9+*j~5zV zn)kwg@}BE6Ix=E56~qZe{OR41SS&t4=%VW!eiQ58CAIC=JCFbG-prDf z-DUi@`{6aS-Nk>udjcpR;w{gcVmIJgSp;}WSzaS zpaF<_*X%q71_nWJA#SkX!~X{x5(EkkG$;gInBZWtGII_C1M@dX>HX$Lc++789@jug zTc6`^>Nf{ps%|nh=>0smD7n)_s%}D}L|ftv5$E%59_OsiUpRG1s%_)JgOhwhZd?++ zI$NT8j)&3%h3Hk&3R&{6^G7`9;J#{PF)3zBLvdh%^SmZnU5(~Ub3>(yS5h>WcNlbD)3*(#nmMAlUb(n zPI`(gM@ZvG2O%G^13sb!TOPfUuzB>dRB)0|bNiMbU*tB5-jVz?VfwyspF2uR>Mn#m z=62?p7gTO#G*4@h`8Dl6FHXfDb1hlI)n;9^b6Hn^fNO(}iqeCveAzM9&39UVMp?lYVG-p#oAUHg`m;$^D8 zTDWh`yRh<{O{1{$nin&_{ZFjirCw39ox_*^O4#fdZ9yu#mYm$RUT`R>e!D8a0 z+N2+o+_QdoTGR*}-fi?R=8m>!(*4TSlI$w(dtwbbUtg&@pxnMLKCv-&-`C>DkKN7{ zrO9p8zL?Xw^MH~3_b};x?e4OKI7?Yx*UpC(O&sN}FArVv)|cG0ZsvXOPtT{GyR(0i z$6u2#Gt@50=Ordz*zvIGLH7HQKcWvNY~$ygDRX((O7^Q)SDRJ@gdXpEdM+b(=8{uJ za!=;gKfUtF@o|ZrZSB(g#f-<#o8D;`y!qlYk8SJDy?LIaU zkxEsg>D_hq{1ZGYz8`qpa)SNbViW%}cU6UizL`B@Og=nm%-D;btpx5~I z@$&U%$tNsYy<6YuSAUy#{>7362Dt;vTNw-{37cuA`kj!9@h#M{D3GdXxOGUi;IPbLW{8zT4?>4qlTxf`nd?@h}Y73`!^G{_jegB zYd3=|A%~FH`t+yNTbI_`mo?Z!MBrp)vweHN{hT_`^7F2Go9&$@aH-OI`*XbpHFcnc z>czEorSj+eal>Iyf7r z=i78nb=23__YE?u>u@kJHP}&VzP#L`XQtzkV$dG3D+R_=7CPO_Gy2q|^|?pm`(ovv z>*e1U>oxW|RJPbJ-t0VkrPJ!&E_=_rZ9DEdVXjll1c$|&oM*3aT7ST`YjR9oyVstB zi~j%rzhZ{rx(z*V-#z_!RJmh{Zk+Y3HN; z8}^=e`*TS8_~J=>&%3SL=kn)}^qKS9r!I2Z3%hg%q7lxWw7_ZN(aE5#)6L+LULoQC z1c46?4i^lv7as_Cpz#0y|4$eHH~jx^m$;#z>wtjK?f>`w?+H1zNdEu-7k_6%8}u-0 z)Bpc}|Ns9FI!_6-(d_^K|9}3=gC*bow+7Q!{{I*F|G(q^{|^TWR)R!MyZ^6Db_Oo~GTM~BH zKi+HI#Bk>hV~pSdPE${Y3H+KIhd4PcmngAXC@IVJPnrM4Abk5oX}QdI(M3;EqdRsP zTef<;ceWZY`eqm!(q4V|iS*Ud(>s{%O=L8ztklrv=ej+Calz?Wmy4W|QevHl+LR{l zmKB+-d<(^M(+^=@Y-&bcEIAKwC+Zx+|x7T~m9W4G5)gpI|@!@I7 zNsAVFP4uo*Nk7BXaPqzVX=PW7c%>tu*Y--rNV~{{xC)t78c5jkJ~(`}sHyQoayvWY z#l7i*NgsB8p0)8KdrO7tB8}_&`2Rm|_T6op!r^gY-UOYhH$0vp>Fg>SciEl@zx!_H zdTy2Ni5fkRwTh)T*yo;o+ZNd;bL;nf?IoPjDHYbgtqPwm;*6>AW+#>_cYl5n@0x0$_lxh_J1yq2GxhSd?Vr9*Vmw~7^SQjm zoZZvD1}|3L@Nc75#Q%veEH^7}kX;b!+SZ@)_E&qi-}Y|?T<;!hB&f2=EwJoY6Kp`7o51&*_byfK zKk}x|@>JV`rKS@dxlj3=X#UD0zHov#)6uQV)-ByA=T-5eLh#X}RL%7|0b!^8WZFBm zH-~OHvbNVIx?SU}|A`M1Uj}V*s4ckLn(N#Pe$3D=HokmaWTAY*8@_hoxC!-=(Q|6oHOfX=NGE+hpZQGb z?HPtMyHW+qU+dpq*+0Lr?y^YXImOSbj?Zb5wn}HTw)w~PDN0> zab=sQhuoW)+K;ZfTzaWeqW1m6g^0h2i`j*YIepdcD(FvHoA1!@{)BHe2QSzt^Seusv1Z{Fvd;e%f{6FbMtw&cW1^wRL z+E#0( zo;hpI_FTQB#pQ&`>n-^u0trug4Gr$fx*M&W7j7zGIMI;%0DsT!rG}dl->k4}{kCDp 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%0A`%d1hFBk6J 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

N8pEhiT4QEm^K==}2J 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 VMA*+7jUN(WP`!B>Xcif84SkLJ4Rv$@u_gh(x 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

NflX%n69Y$=_A?WnCmdIo zVfi?zS>n)R1LKtA>M}eNW#37rwKvrm9C>YOb;sa`R(-Jn3!lCvPjLrNC107wiRo+~ zmC8;OHz>v&tq{BWk(b@srTxr<)icg7vflUbhoZ-M$Mc7I4}Y;b)5jpg^6{YJnUDEB z=1CH=j23eQ=J(57k~wUsa$H%#QT7qDOWBU3jP#4L_oqD;Ly%#Si6#UR-6Sx|&ld~~IZh_0DT|Ym3Q#1DI3rJADsIx_iuR~t* zSlX6LI$TWOQj9;IxOwomb$sjjM+G)^^N)J}m?SB5@<|WZ&ZKoKpGDRjc;0HcpkiKs zT2;NiOsV>j*%@MY1-Rb&EnhreTa5F(eaYH}9T#Np&tKm?u_E%nfXshE|M<$XrT~Ux z3d&gGD)Hp?W5uX~&`qaQ?yPW8Wtg{@t3@efWtVqy zX{^-L$xW>e`|PBcEZl{pv*#9<=0+@Cv1qm8y^A(NO6NSL&A3)tYhSX?bjA}d7Kd4^ zDZ*=gQm1OIkzQUoZ~4KiYVA`lxI3GzR!nD@TDkkSfBXI^7njAPNvvrz>2D3Vd&+3@ z-5QBs`|itIon{qX9ls>f!HiK~i2K-Ei}$umtlwBiOE3O-^RdG0uM>>d6es`fK6Clu zhWX!OV>N{4v+g*a;PJHM*ql5NMmZ>D-!=U5C6cXgl7BJSdb?5#)Vlr;?P*dd82P zW_g_!|?*-4Yx1UM$bamQI4@Zq+;Xw9vnyt4%DR+}DGt@jcN7(uX}sJd^EQy9 z>-F;8+jqY{7&q_rpD1IcB2lrx5@w@KZ*;H6IXfBk_VW6RxP9Yaxscr{{rmUtw;Xya zoXTdM?Km-2f00MY{uvvORq|T4y)=tGcGf|DO^{%uOy<_vE0t#D$cTi6Et0QVr1^U5 z8u6>MFIRRijyv>M^6il=Ww#kBN}QC!H5N&*r{1yNWV=Y}#lzCC&s1D=)t=5*;nBOF zReo{tbdi^n9|=wR(2>=nYBC|0rEU7xlYgH7ELPH%oZaQIhO>QR-uKhYE>?nqzc=j? z`Q9;KcH?59&okW11h1DqZ&&|xfA{px0Iwaj+V+;`C92aE`|r8`E^CxF7ilTnlhD0Y z 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

@u$q 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

y+cmt+8+Uh} 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

<%T9~48!F`H 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ℑct+!razGVKu0&PQ=GUuB-Y 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 z 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%0A|90HyY%~!dJFR$b=G#vnrGpL!4?c9h2BET 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

m`szC#j^Ix3yL_8@;vG}^IOEny#MN1g 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

M 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≫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

v}!O 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%0DKkOm=*w7*%%t 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

(sPmt$i_jwuWxnU*vm#=d=G^QBpox zn_MgV9tFMQ<)8lZhR0GPtra21CYZ;RO?lB{@c9SHr`%FGiJwk81FwJ$gZ$x#U!_rm!3RX<8Wok_bckk4Pi$_X6dY7v+ihQ z>}MuE2G+*&=Uz)s7C&?D%e+4hOaeEJ*je5^yLByg+x0T19mxfer7FzoEho;XO7At9 z>*}t3aPH%_gMVI`eTj&^9jnGuQJ_9eZ{J?AohfD8rl%S7ue0KDo_sLDKd0vRE~)I# zS8KU!1oVy>zqnrR$~RBzlc8K1pCXIzpVa*PI1P?%=Hbr{Ojn zJuwv`ETfwU?fT@Cgl*2Dj<=$`kzfAQdrkbm^e)F?Cw|e^!k*8o z7J5rZTvuurw~2gm+cx&dLZM?Vcb6wtFI%Yf>7vecC3o=?E>CLqt`AO`HlcUP_S!e1 zA-c=$Z_JLc-}mIng88`@+U5ysRf_+fQo!)FHpnRSaG;!|OhHvqk=V!IPi$UWcrHwO z!c`icbK70;qJP+W-ppI}L1z;$_G&OJ*!s58?dOwtICj)6$^rS<5cZoYKM(x^Kb_wT~w?RT-?_^xypY!+&Ddyyq784=APAPiII- zs&ekum)4xrs~T)1bXuiyMZQ+pdtayP_fz{$x>n>pShCZyQ!gWlA>sR$AJa}hU#{7; z)hKXh#|%XYW8aH>^E214ys={mi*V8O#T_17uVsl&l#tw_G;_~tmg#06beG?MUo3Sd z_gdE0NnI{nsx!CA9k`tPZRur}{M*^<>_W8O-*eOoGja2(dH(i+()In~VGH)ON7wMp zzkIb+)`^$1$o8VM=Ml}-EVs8w?b7pHcKgl+#=CbR|7@5D)IA3j-It_(T1 zZryAdJMks2lYU=Yzk>JX8|{`SYMFnzZktEM2>duRP0a1|b&*|d9S)Ok8F&^uMa`@D zw$o&DL*bo{Lm#GTFEd)a;m(`|cTT9UlJMK1-BoPR+Oe_cP*i(~#>(!>7Qk=bIV|QC%UUKNl!y@a#SC_l4 zNxc28X7ite%irzce<$~_^4tGKI|bhDjNkoyXS1?P;=8S)$*dAdpFVoc@nyXBLbmCXXb%(!yAO8t?^tQU?4oD=1(EI$3Hy&hX!*q6~( zSN~@xSC)d=ER*cU)h>TNRvllw#%7np+3z-gjy$aw{P}8i{=L8aO7$UbSMo#E4(Co@ zb#(8%&Mmi;+7{YWwQqWVi~FC{+3NTE%qvXt!x!ZLKk{bQ6=^$XrgA5@WX=BlMFsb{ ze?+VA|MAIt#);|8_SbwS+RZSVabl8&V7r;_%+rdS&-dGW_qzS0_2tW%@6#NgdW)QV z*!a>Ud*1D6!8h*m&(_K9s+za4mGzj|^d%=6F6sy`GBtcq^fWHt^^4q+AJ^Kodpsw% zUcI_>>sI;wKMN+*OUK%}e^FCid?&|Zuc)DdIB)C6Zw!`Cd)EGXE#2L1Fz2k#MBPQ= ziV8vU$0t>6$vSzvW0t%|k7eT*j_u_;9$4RA&CShZckWK~^Djzi7aO)+D^U8kV$F#S zZc8$D8@WrpJ+@mg)l;fSZRWWT6`tvh&$COLSYsy|Y6dBl{ZDYKWmCC$?s$8$;){tZ z4o-I2A*rMU*~cD-&Zj_`gE*=QiX*F)%tAp1`Pp2f=Yd{0Fjg*7^_-<-`G8Pe-< zx_G0K;Zr9S&i0%m+?B2uT&AfA91eB<-;plvYtzyy-Oj5Q(f)Fe(vFoUpK@pgU9Dzd zef8k!>-TaWnI+sO#kv5eS=9w24JX7lFF^XJc>H*enh_3KxyTD5!k?tT0AZQZ(cz+Nk=gpgU;J|@>`}S?wvSs!1h4W{0P3kD=s!wYy zji}1;E>3nVOti_5x6F$*FG#R1Pxq`X2yCs2>ub)N(O3yB+1VKx87o$-NKa3nKY#v`B}qs$M_pxxpMW+ zojXNI=G7S?jrlRp^oSF(^y&Uxz z85tivdX!&K5aMN6mg>gECnh2;QG{?DrQ7kgolUc z#9FE-D@jSqEnd9%`Sa%u4Gks+8oJu*j~_n{4-e0evyqjPlb4rQP*8vzjUX=%V#v!Y zbd)AG7sd5dCbyNuLj()r{k`qX-OLSxU96+M9Wo=mlY`w2l@v|YRqYLQ6cyxcbhY9F zT*^{{Tx@mngB(g?Jtozp#Rr>plz7{lDg-;rWM-t!m@#A8v}xt#<(Zk8H8nMpCr_@d zteiP>W>r@7yRKyd=GG{n_IOzI^$@pge=Y zWG;ivJO;H{X2~mjeSLrb2CeR3by~pdzVPeUuUTyyN=r*mpFDB&=urlfxxDTR&68Io zCMN#<`?oTJ*`EP+JCc-Ta`W8n2ToqzSR4d8LliQ!@xY61@(cb?KQC7vlLd=dHKl-Q z5HZbF>obT(#q!f3{FM+2OhU&}z-$PCA_6~c6mo|sSj9hYFojIK{Gamwf5WH$Twki5 z$DeRp29i@~2aynL0-^pt|G)O*%Kz8*JXrYu>i?Q=|3Cfz53%7JQ~{X!2wKeY>C>kL zBHbkn41(>D5t}oYu9i9*3b+Q^Kg)Q~cjnE%>@)c@ShROH8E@bUm=bz-ORPPQ^ZmZB zCi<)YOk4GGzRboAOaf*NH`gDp+I%*0qx2MqoL{q)C*1BYo;S_;s`f)%cSL)!`&`Ui@=?Q-snSc3i>M61je9bTU!)EEvUfJ%;@dhU*Bxpa4yYX6|^VJPm z@#cT?(s$lVO3QIqTwkB~J^9FIopi&$%KW=rth<~4%~jti_o&3?L^enDoaB-ah4qb3 ze%V`HS;GJJ2FISZ&D9V5#J>Af#@eg(9SLNx|K9Cu^!(I>X>JqNJj|;;@{Mb@nCH5_ zb-Vw(6%X>BZZzS&{?|_@XP-RXP&%Px#&h#$huaUUv`=1ezIp$zw3OG^jgPe#?}P=DX=7oW2~ zWiZA~5$X+5Tb?y*o%E`#U5i(>E!-V1zUgJkoc-6BZr+y9zZWdQrr;K-KDnCb73!4|#dQUiFBd3dr9I4QH z{jRAdbMDF2+ai72bfb21S$_NXv+#5K)a5}3O8nZY_x|HxyswdHIMFO;@e{*qi)YM= z>q_6u%%Kr)E>RQBUiEwNtZ^SNM>LxS-2RWB~CvA?s^MoMVU)GehoGTB#7 zJ=W2Ti;;1a<^A2<{=(a5^`$TGZpgH*#~XzPd|e>rCT2&2NsM zjuy4Gxq18c>s;nnXB0!_#hG=y6JLJHaJ$1auVu+Ro6`6ci=$g!PhWWBWX}1@UEaaV z`4m6z5I7PTqj&M^j-?d>%WTVHPH^bvU$^&2TV8GS#_vL;+|1)k8TgF9>(t9Dch2>? zu*KT$<+jLQ)0a+oufRQj`)%QAbMo`teAo*`&fMvqzW&UmPggay#2(IF62JYnI}5X+ z@29)+B8w!}dnlwXZMw6~_4C!)+x71~ndV*eYxlY8o7v%QPH*IYxb6PQdh+l2m61EP zpN&nlN#;{ejtk=9W%kbr*9?9%(JGCt|BJ^wnF%o$N`*}mthcOO{k3s>k@o5M9h)Za zD7AZ4zeW4>$Emq@zgWFLeC&Slx$3x!8{N{rSl3G{KVOj9C>}X2J%hhB_(T5m==C#9 zSFT)HdA~irW>v+zEK`#cFHBc9?fe?lkna1D`NyOk&X>LhR(!kp=VUSa$-LH@rR%De zxJk`dcwW#g#;$$3VtewV6^U$5$4>-kq^WF@0CSFCaR&8CV!PtKe>tFIIGfAzQBE#>TX5%#~{pIl*N z?)~giBg6SyN81Zk4$kgA^`w4T)@siD!*&07a(Wis;h8k$@Yw^Inv--Mr&&~JFI#o# zy?ZuCzS7<=pYp|?UA?hZ!O`;2g{4a$xo*EM*&-F5Jo&nN-B+%gwP*bM_v{i-W@vnu zQ1K!tNoc+kup6@^ZW<8Z28 zY0!NqFiv>-VUgb&o0YmJ+yB>>Jn>&GnTw?{?P&6jzdCaw_b?eGo%U$je%x2UQ+4%; zxw}7icNy*Ha4e9}+uva@NA+{vEWPf_F{k22UuwxxEG;~qD*O(9H=KK@{ClwlE>u=DBEtELAS-TC}t;$v?<5PA_iZ)2l| z<%HekCmiIStho9xfU#wx>WY6y41(Nd6)G`Gc^o$HE%kFzsJm4rHG#P@!gbl%Ab~DN zcaglCH@uc#K9*(lFo8esXhVLUq_ouy<|l@d>^wp?9W#DwYy61kUz-PxtN4<|D5udziFN042Ul6gEoY{&PKtVbq-es| z*a@j;8C6WyJlhlHy6S9_z^fSzT1*{Ulf))T2n2O6$mzYO(QtvO-)2)3|uGVK1=qwAkEk7y&j7u=1HDj5%Z@(ywN3aj^N8c&Jzu`?q)#- zT49aPW+;DJHB;HY|sMwVM`<4wYOAo2M^cp>U+iqR!f5p~vAVDvD16HZ|#p3#wW8vAj@om3wmaMcPw^ z^*8mu?wN7#Kz&N9k6VK9B3nl|sd%{sw4^!LTr!g5^3<`s=|c|#{Hd9g>T^YEoThGp4$@3-D| zlrPG1y~T6O=aCj8V@{BEa1cw3nwI7?rQ4q-FaH>!D5-vL&8_A4<`gIkEo*TRF-jG3 zDNI)tI^BFm`*RSBmfV+_tTQFtdRNX!$#@YlueI!S(aV>aGlQge?bFh%Ji2J&&yT0g z)AD|5eBZc`J3sebJ$s(jW&4tg*;{W|2ZT&g*_=A1aEZ~abGP(PB$?QmKj&_Ba@_u1 zUHn)7{=N5?p5w3m=B>QeGal+F zE{=qyEi+VBKAs+KrgkiEw#47%{aZ|(JLcH^?c)mnXm>NA{$I>}82F1eG@t8%t~spa($J9Tlf?DAji|I23cPf@E8 zVv{^o;a&6K#(lQ4s*^sQ?fo8lWv2i1{AVUIJFZ-+og{aPi|03!;i0#Vzf#J7M)@Ay z`*YXlYl+^sFMgXhdDeupza;ORG=6+OP4aDu|JRFVXVhX<%WR`Bzv)TJvobB2_wMNo zpKCVe$r2O94|DwM@jUT$-n)#3=t$lf^H;27dBS~l>yNA3rZMNT&$8N8?Kk&{ki&=P zstoh2D_1Swy_juZ@BgyawKM;np1IfjUsiPg7TL_k+Xb+EC8!YAF2_s^;KFqvfL{!&N7IPO1hY_)Xbs*Y9x zFOL-gGcP4RI$8XE-omV+U+HS6&sh1-Gn^-re>+Q&J4a^vU#m%1=GXnL^>4XeH(6ol z^m}h+&i>8#^J3q@l1Kaki+%3g3YXnEcli_+r?hqNxu5h+6u*6ChNr}ZGNWTh z|8DIMvy*}s|fzm`VnrRumzigPhf*%G2D`uy8nwf~Px@0w`Gx-p)S z*wbi`bv5Yax4X@60xjYVOIw7354>k(Ee@6USm9Yw;W4yCBycX}N? zb#2U%)Y~X;f!Xg8Ta3RyYgm&&HGb-0!|sJJaNgC+PO4CqAbjM zk{2_FrNcxPS;31Yz7s@FJ8~pxdY``4wop3F^16q{8w2x#kjTmWZ({=TPkoL%epTpj zY0tvi^OcufH-}#FT|DP}WtiAN=ro>lPP3JuMmQR?iE&cwK zZ2rByJDY>;%2WAQD&J9f9KC5m^T#PuR&T4BAvSB>+?nS%H-*2xH(^QM_Gc%Z@^%He zJ>D+R5_x8ayUPNGs^WW-zwEjFal(_<+}$2(!C3|J`q!VhNlpkp;Ieq~>BW-LZIW4^ z|LayqO`T=P7uaJUQ0~HUOu(eDXtvZeh8p*;2D;l$o|w`iup~Ilx41QDS(bR|-qxmu zx|gZDC!Jp;P%6!L@X*^JS(Vtc&a=W*r40T{|7^J#Z~uv{&-3_Kj-vK82c~r#KN7O} zo<-4-O?@(%S7x8&Y&)`y@phW1^T$m+%!{HbW}jN|=$que`|6coS}khg~fxYSxIjD-_7P(e#oq~ z^8db7E`pEQ6g&IgJdCuen6|iT!+Gar^0o=A+r%b4=HonktyLlMRZhv<55~>A+fJ|^ zHsX-JePr#?$H{yiRdMgws~?}?LY0B@HEXC8eD>bbdOMt$o3?7e3V4R@VwRqo(( z{;~f>W5b6igM%Wca{?Ut{-0+!5wkOCS4>DNv;R&{fxNOXImJV_zdDsQ@y6W0m(!ncq5FYa8I72ZA5WM|?kHM6Nv{SMQ@ zn$}cHpaSIfAT3O??z-dDG z?IxRuB^M8gIITT<-a`F)d|TA~(nH1}*N@0RM;E>dx*XOWl!hQpWqQ>;5oxTrt^3FN@V9!q0Bl|P1DG9J07kqv;&Y{D$fgvXJ zd8|6q%I$8=E`lHDKFzeNPu5p3nJyV2ReAYR$KR(_CS{bHJNV7_D^!wU$YfXeXtK^%YhGl0z`OOnB7*Txf6dNU+MBDF;5+w_`1J7m zd*xS_%io*x>)Dmt*Te1EcI|5DGb;Ub`LM(MwB^5!&weHUKG)>f>@>;#9_3Hc=^Ix* zHmg75h-Dy`>njlhxr}R}`xT#BnnKVyJ>6p(8fWzNUphNHGB<_@J~B5xqpfvOU+<}< z>2nXqr8t=Oe@8@egYu0$SMepufg9{6d-|g0!Q|4G1>an89 zzAMf3siodNri5wH#$tpcDfm* z`DM28kACYfg|06gEna(jyblg|6(8`*&HinG@2#?+^DRNAdx8(m2JOJSxUTHM?x|1b zH9c?6J+wIb=GL}rn`)0v2|BYn@7~V-tLSi@099pdq72byNt}f4zKR)@b|$1S1imP+FR^N zu-fII4LWaSX~U7etYZ^%uO&EryXgJ&K=bQk1%Gdt{<>uOY`@!w)A84~dhTBkdTy;R zd`;uYDQTA$fQ|uvxY-YM4Sj{_>v&VHn^}bn3=F;C&2o@ z`)2-Be|Y)-L065Qm`$s_e^u0eUT%}e*y$oE)XgB||3|Q2MM1MnVb(OY{kI=Jo3wFt zh?eN&rzcXDdhzVvm-Ob{zwMbe3)&7UpHH3Px$lE@)RY~a;xipro|))1O)?~VVYhMi zmC3vwkDXIbPd%;{q{!>JT6h1u5(y#36ZhwAmNJ$8s@Gxj~DA=KK?cKch4!$c+F zzAr}`KeFBA%AIuj)wKyH&+Khik+^p7l9JM%goxmTf?_d#$=UAb+L>mq5xLMijeCYRnEVQJZ{7Zc&)czc-HQCyZw}-_w%PuiI+`im)zGNd?`er_S}h&6Xd!a z3xqoka6XI|I(e9LWx_%JeF~3?RnlMc_QZ&>Jc&}ZdArfTXNB=5bIk%v)x_Bzt-`Ty zH%@*Z;@Gjwm*tgxy*ShEj+D|b0rC^>U3cMH$0w<@?7geA)z>dhpZj_@%9^|UTka~A zuwcD%@ZlrTY|gukZQ??*WO`ro*a;=BGWV$0}Jk5S1b5n zWl=<)Ti1@&s*AiP<$hFd{>Syw_osEgMug`M%d{_fsps`~UcY{Qd+>+qwMk!$bF-qSN%z2KmL;~VB{XOAy9n8O=8b$wSHqgPw`pTFg6!}3jL zIXyhpQlI4K_fPM#mg>2=EG}9uPDzc+JT7N>_x1_gbz3{_>PnH*`EL@_Rg&13T%YdX zuQ981%0}+4kgs`H0+~)Xs(C%jUu)ayvT9cAf{dM$QWRL;8vU81pS0ZSlBi1az9ldD zU1sH-y=jzG-BT`Ans}jMokMxatJ{S$4Q!X)o@c`1yIMK(0!!#Jn~5_QCuAmcHKtu! z5IpVp%*8K?W;Jbz&X{!NNl&~$kyX^q=EF9dtYXVN>wKOyYq_;wTkz5$aFW9R8SyDj z{3i~)^_HuxO*?8e~)!qSN7zNqgI}Ib7tJ;4tjFw_J&C;*W;WLgm#uD_#+o`{uiG(p;TPL$}rGt$^5S6+Z%m8-0`kZ{=Oq~;)+w9y|b=v@vydL+qWd* zF~dR+qqXryPQ~d$k?byx3sjC@(pa>t^wbXK8o9gOvg>?i#~jZOk`vLs&;88%6Vqy! zeaTP4mwvAmdFb4==lqHFUinkRBu_94%<^z~c74vhRcerf z``Q0Pt7`|l-0H61XDy44?OlRSdpu73KJoME%X-zF;#PXI0^}}8 zh-{p3fAL?5?)rA6MZL*FOHBW?9yzAK|Ni-|d5$fsB`1o_(h1+aDn@^WGK=e*`rF&P z-|k3c;5wWdP#DVbc^}Verx`QNQlr|_->l}@Jbx$G?c(FilTQ7Wb9ipQ$gI=HeR`p1 z3tQDb8(+Kne_y_CzP04eL8UtfSEOv6?7Zk)$=n#9O@6Nu-h7LedSSODIKO>P%IfW3 z=ZRl**v)X~<*jMS2R?f)`@OH7t;@Mn&;R-Z7sfY!n}TNvO-`M3L;3Ek%M0(!SJAvX zL8QGQNW(cP{!)_1thPgflB;((oJ(|jI$_Jx3CStP zr7!dU?bRjo1$)HP#rGKG1BOP(XPmr4;n}PzkTgCFz1zzo&4~^ zly=o~A9mi${b4iV%lDIAl1-AeCIzuquEbY$EKu_|(At?|C$BQ$(sODI(GT!9DnrD+=OU+{V(%ELS$zHKa@%q;JF|*rW*wpRIvv+wP zyLyBCqOGz1|63-^ix+kJ*Z!wg@t$)=)~B4dFWwp1nHIJk!0|Sd4q#gC<>h?xfMIM%bhZh#O1e^#DvM! zaqGi7G^hVs`&4H49kJrjKWS%5b$#PS|6iKPWbYalu|>saGZDC&x%hbJ%`MdnUVU`i->SxO|H6U9nEY;u z&i4__GG>+&le^mw`*T?2gj?O;dzABj%_Ij?sr?ImUaJ@U-tl4Q`#CA_7pgG*fJobsWT^mx)s*i+p%Oon<=_qXdW+jTL{-$L zPB&NmcKq;>6Ji%{$nP-NP|YN_`*D)sx!Hnc?GFx3)PJW6E2Bu_Uj?xMg} zpK7CdS6@$=aZoSwzzuEjdaHNuq|d2HRtf;tVAd4<<&8bv0hX2LY9<8&M%EzQy;&nC9x#P z`Q(h;YYU36%rCmTq{K`^MPEtLR#)Tnj9gbE9ZxeoHEEelKfB2Zo_$fS(~^B=ru)y$ z4q{{#^t3R}aJ6g*ap9EFU=~sEbFhB4qBO$ajZsQdTgOOHNtc0JvLY$i%*ez~T_!|F zKGsZg)vT$hc7}4g<`D+UEm;ZY&z}AN|NpM}le+wkA3uKFQ<5{cqjBr<#itG*ynplh zzrVlF?B4wA|Nku;H>_T{^6S^H@87@w`t#SvPoLhrdGqnZ2XhzS^19|HPoBPd_3GWb zcPV)#3=EuCE?@QtiFy0>-PYc!Nv;ZWqpVuHdNs@(_U+w!;^e9M3l>bN%w4*C#rKcz z9z1w(!5UEpd? zRNp(Pq{&7uvS;tJ|L;$z-I&F`VFlk0SXDO=G-QYavbyPiS;_yX|NsBjzxi)8>HmoX z*Z$Aj@&EtF&!1L#YfSTCVBnq)tA9hCSPXgC9`wAn51sRSzVN+*6)KEn-*-DmFXs*w z7x%sW_3)3J7rR$3yl<%gdfVfvhu7>?O}+f;!^*qmj_VZ;_vOpH_K~{PAwSdepS1L( z9epmbiZgerX(rlCczDd*DfH&Vmtjlnn7JyF#3wrK3+CZ^+nZx|X{W+p{=f5C+O^tM z<)pRV+Q_~R%vENyl~@yUw#ilfzJgcoriPOqr7}Ar{(7qy{6EBJx31U7K??mbeMn`0)Z z9?{Z~aO`qx@wc^4&d-0~Ay%wqFnMOt7juug-S-@i?0ooI@}xns&nFu%neL58(u|5H zt?1~S^k#B}WTa1)+2oGbuBwV}x|ck1eKOBH`u(39n_N84O-)hm?AZEz&aJ2GOK$yo zfBaBj!Z{UY&rLRS)xtB)`SbrdTy#6w#c@*2X-^Exxu37TuYaHXqw1UmQ=g&lsiU1U z{#4ZoJa7AUxa%@AkAhEO|sXW zbhT&WDFsWPNiysgd5`NwE_^;S_)7eGjT~8Z6;AH{;BVruI~)uqDV=9{yk&{N(r@_| z*99iJxLfIDJMu_8o3i$B>%0Ybw%vHdcu4nB%*WoHK|M+(Vt!md^{oZ2cQ+ZFHB@yv z*{{0suiL>3%TB7Wq#74b+T2*-DyQvabi|H>dy`kO-$ub^(;YgIhZ$0*zfL%_@&E0{ zA3u}3ZlotR?b-JFy7(1|$!TU=-qzhbpzr#Wwd}6=n$W#UkBg^%n9uY3;mKW&Z4D-s z*WZ25js7?>C0O-3(cmEUi_#Lv~F^{Hw@VnbZNA|3+Vc57w<kv{;{V~ucXtNJryHohkpMUTN^LTz~Hm~ zx64lvp^h~SPp(aM_{TV5XG6K^!^w3o=AV(y%=%Y&pV!$uLCJl>rR^*~nTwX35XgDB zNa9y*R^EXfEC25Mp46wPq}lK%`=wWfV$g?mYdVW>&UtZQM)xWu77GF0gv@u*^J*tA zSl0fxWs=XlynjwIWiG1M@BLW7zHQm&bDX;uWz1!HaOFl+Wnd=TM2*u^oIFZC+tz<`JRd*jL4d}WWeR2LYch^4ov7k`b@g=pc-@UNohNxk zM}=Sh+`?yEx+qHX(2TiWp>EIiG57zxeXsL-vC_;)56vTf8N$_#Yad%P7XEpZ@yCHp z_UpWoM-2Zn|Jyn&Se@yy;nAZ_dOz6wEj0Lqc1P<-TvSlG?5NRw{odu%pTfl71PBON zT#NWUJJ2rkk4pWet<%3&?M+tj$(kEcS!pn#K}J8}Q3FfoqSxPrdG9JMYhUW?tRXpL zZf?H%9gRCF4oX+Iy}9k&x3AcYMShm)=hozHk#B7Z(hX;}soc8Sz3y%M`HLC574LG{ zSblLm_=R)3PX46>XXbp&EQ~udZ{N$?{IA$;k4LMjSFf6Hk;Z=KTh$@YKUI@91ewa{ zpZ;kx_iD-RiIY8jtK5%0Vt&2a#N)<{c&oqZdv4}!k5RCEYnZY2Zt>lOzyB{ze7tsV z*6fGxt6gv3_&E1-t$e}p2YX*nc{kyY8e8@Yor~`z-$&=q)Jwm|_O!2FStH`jt3x?9 z|7*|rtK6TQ<;N*?*nz?B;J*Lca&ONPNi6(doO5aGM5Ar{8##>5thu_PK2-bKsbef| zzt|t#H(Dd%Vz`Xw~)V_TQrxY$iCzI{5b8^+g&L( zdMb~cb}jh9^=r#B>B3nC0#o~xjwqk>NDuHZeR6e5_=od+Mn_Xv91^+$RQ?6Zy>;E= zF218_U(DHbbLqLdI;GUiH z>@8%TGX1NtncLTxbpLbr_cgOzi|-hSG@MV(yKbDCwk%oFMvh&)xAOFYYf<`IT*V@3 zZS_$%AExBLD>tqeJKUXd>1zM=lIPp@s;sAm7Si=+D4^D8H{^r@U&`d`fE*T<#7Jo8m1tt?UFp72=dcc-hM!=9)8vv{lyHJz{K zj$f_#(X%V){q)!WqAdCuZn94K`S0@r4?Zr}mH@l_sV;g+5|iG09DY^UqZSjYG-;+b z`>QWqqU*&B6_04``@8Y}lI( z)1Kr$(IVl>&8vI+*KObCD$~VMm9ap)`R=k=U5ax*Rc1tdzZ&moyu@WbZ`gl_{JA&$ z7(Cbu8}7V4SbL{W$w$Vj%RuGY&)@BmZWePV@c4d^5<1S#)FiTVRo@MU#d}M)oI5{z z)i=Wf>rVbS^5lx$vh-t}+7Y{Jybn5866_1R&DW(~=D!EGb?L(zLF1KP&SHYU+Hmugt*DrDO8)husH2>Pv zTcw5zy0^%4wM=-}clG4f*lB9w+g-X|Cr?fCT(b5+%(G(#Uh&53;=U*q-8s^6_H1f; zWzmIikx56}O9Gd_P1xrF zQ-^x!lZbGKRS)vc7#=oQc)5AYc4>wdm#kT{KdoPJ>ima(?F#o6p^vZH?wZLI$XQ1G ze>|JpqVL+);tfxNj;~`Xz5Xfd(#xK0>x}MSyVi9jHnpdsGVgXtYD4c6He0Lxk2$aH zjH>xxoL(0Ci+$6-?E0;fPF_B|Or`q!dtI3yugjKi4*S>Tt0Hf+d&Ob>FB7u91csk} zZ*716SI^H$CZanHI~P9)Fx>fN?_IM7u4v2Wvub|tX{_0A*1~Ww{LnoJZoj6x4>SWm)_@IO)?Qp6p%3xOWi(uuSjylq&-&sk0tyY z7>ZSI=7zQeKF#O8t?wEp;;I&x7o79_q@}|7TN5t6(0lQ7@!5+Rx^I(Zj^+q?CE5DF z75OL{Xi_^<+%EFpC$7*NPrh0zL@AdL;aa^&wwTCY8+}br`eOhjRoPtbH?W zk8vO8`8ctor{x5Agu;d5Cmst7)>!&La&^;>15+1Oy=+s-xo?;j+;m8xP(34D@V$ki zc)P}u8GXy66csnWozi^7YLY>*TkdhNs_31tx2gN`;yk~V zO^odmRy%t|dHbI=_wL`V{}mE zMorBNS=dp(u%mu}1_o9OXs77%(MD%O9+m(}w`c!O z-{qZqsLR&w@AZa)Cj|;cc1Jp-dkvT9+Gc^}iWbBSgv61gN*nk#X=R32nB6&=@^C`opJ|SYtG3B3=4b;4aXA@5RU#Xb( z{m}uY8J!b4cZ*m4cr>Bt`>A5?b15CKr8iYc72Vi-Ym-X4eR4+{XfS z&Ew&k`JG#Hr+UBBw1*Q+ITYWml(RbWA^4v3;hbJ~ajmBcijp^?^H+VA7H~43?dW90 zH(kPD+3c0O&0k42ZR4H&r{tV1vs9bTA;n^epkn^8ue^~~C99Y3XrB}0bl__7x%bOo zoJ(CGaCFjIxgQT?KWLe#;!0= z-DhoV{EX7>?_2gBmtOYpSG&ceDTxPH?Cx2cx^O|ji6!YA8i~=<+mCHK^gN`dQS8HZ zVG+H94(@DD4C*OYHoIJY&ZjuFSUvjE0ma!Tmd|?NIB$a|=gdRXm1bzZSgE-~k10*V zMZ=bPTbPN*390!PTXeSnIg!z%*Qpqho6`NUiz!S~v5)E0=bv+`^VjWJ?{|Ivi`T6l zB99I{?D=GSzZgTs9oBvI#Y3zhUWDZxrKe1n9xI>y`hsX&pMWQF+7uF{zKCf(?evh z9I_02?4>xrI>AC~=9*Uu?VqdWKUJ(3jo7I#dBKgZZ$ym6Gio`|!avjLNTh!IiCD7~wwaCmKY1o<{x@=J~=OtOSyp5BZT zYiDt)7444WP%kR|G|`4<+7TxH=9A7(^c1I0@IH~-s>4|0WVvW*g|9P~+KRW0h}w$r zH?+3WP*+z21AAkAFpW;As;a_;Omwy3Y-JVIFc0~e6(Z>&lIrT}lZwUE)YQbJG@h*E z{eOz}|54U2yErc{5I5!>l@W7c>17 zcbhN=bAMZtY;T8rKc@^2dj~`97#GXpAm>~kM`trbNCoX_rUzj_$eD#SraoQH@Ggw>M0CJUqt_ z?SJ#;_0M0w3knMS{QSOs`*!~P`E*bF>gwtzPaeN`@nXxCEjlV(KGvKvd8t1b7#J3V z>vT0IGcKX@iEEC(`u}bB++fy|Np|Nk#L{NDvd9D}ps#Eqis3=CY;q3wmqt=n!nh`35mKd8udMEH*CxBvgY<~XV6 zw(rTPeQZ^IxA@)k|9_U}a!gXu{54(n`~;oj+)555EqVQKjqNWcI`HmRI>1XQmo*A&wapI!hP|eAFhbSuy#$``f>Q z$EV0{S=u>E0-N-j1Av;2VBsTopzsn&-`4 zEX`XxW$na|w^H|3`P?lmah&$`+{KF*i!=ATsOR&YGx~k=*X^2Dyi4`#=C^5`+%~!B z&ij4y*3M>s`oiXh#%lRh)=RXrFC;f4?!BDCtMp#P*7xxB3%8duZ`*Ejc?J6n*}ndY znx8obpC1bg>bY{#Kz}mlw$0bmYywjGi)Qt%$*Q|`_OqN?a;}PK<`wgUl?rOBPgnD8 zD*HCAz-;;E?;p>}>2kN_RZc!A@Wdd}yYHh|(?XAe)Y^RW>-VR-9$Xfb-1}RB|3>8P zuUohNwG+B)tHJ$PLwGd@|_j zSa5oBBKP;HDaAUUR4=5=<6ma3r*()gJ5oWsq4jxJS5M*T)og)5(<}~LEx)o>v55Qe z5}}KGJts!bP>8cMNoec##cWOe zdyZ>&-B!)rJC{GJV_9RNeeS9?DJHU~etP|%)t>)cWUr&|6!&UbN3~nCcwU#xdUfDO zO+)Xu^HIyEeo1|#d9B9VVArgLHnsM3&cDlie*|9KdLXOm;@h>IjX$|g{mecU5^+4+ z_ld2qrjxO1&~;!G`dYiBT?Twv(5Y+82ajF|eL znRmqOt-sji*58aumb$I>DXXC5toMb(H*W7|y(=X3c}xPS5F*2T>R7uJ-X@~XYq z_(#Ir-u{iK=jRuK5}URZpLd(El;`rvM<3_tFs5$bH(z~{y0Sk1UcWAx{4S|k9`SRY z$(?v~^W*)4FO?3e>UrOg^7!=M>0iW2{d=#IZG)6Mn0H)0d-L8Gj^fY?j`;)SaN>WjZ=@NCdPa0T6|;O^V?4E7?heXbSEu*zxP!p*VFkozAJbNc_eGHIrmv} zDSr$02y47@p2_+0RL}4wFLrG(HrJoDT;!rp$3}%i=l;k{(r+v><7V9Ue`V2KqnmZJ z(o3f@Eiy4K*6EO3(!sd#sl~Lp4o*u7OHXfH_O#}?K!)+@$Rk`*PDc96uYH=Gb?=?j zCAU{nP4lXxEi7$|r)^wi$!YoAK~GQ9iP<;>enW0wqoQeI@%NyJYn*y zGmZjDsrv+%6#i$w^z2oh;_}pwUoPC*u}M!$ z$z+kt7tb?iJxh&X`YU|#Wx|Q8!Y(PryM!0dzFnHWXChvqTA&|_S2KF(D|wKv7asooR{_p*uU%UF88ePMHZ2aCCeWbw$#5`cya67IJu-)M?O=h0FyO+ zd=t|qh@byL!a9 z7e`FH_{u7 z=frNwV`-tcA82Z|l#;YJHoi80mAhs~-TUueLC!ka?9D5R&m8=SR(wsWdu&@z@qE0c+{( zh?)yg`Sy!X-)*%Nd1W#GSa*0$ zRu=SpbMNki^fgn~`d$j!!o;&s&%nQBy=)xcbz#Tw$`+L=5$}JmeQ5cs-^=mGD#NT? zRgwG4&mRb#*Ti-{ZhPzV8`_B`d%2!$I-gN-TBlN^Nc2?T{dE-GAfRUTvC!I?CvS=`Qi-1a@Iu00J~7Fk zfqK^6Do?azGP8;`xI!OhIB(0g7o3!kohJ(t{W5$h@$Jcc2 zc379B-6_YS)?Sr;)2R7JoSsI8wtMW% zqq5s1H`@LP@z;_y1_p)(4rT@h zhUexNc^Md(K0>==|6c|CyJhW)*2 z@bzUQi2W`CN`8#__t5$OGj9<016c4w^uIgSO{H%CKSun29SjnG7xDjp^#5OBOM3jD zTnN5)ATUHvFVn+r>um3@kHY?cj`(mZa%q=mqLX#5k7JsvZK#n=u8-sY@6bgzGYW(M z{QC`A_b_isXsnf8OQLs8v>Uj={`dcvtN(w0C|YA)y56E-g>`;C$dIla-xC{Rv%SD$ zg-@3K-zo8bEyMr+|Eo6H=lVDn`iJ%xWt`gV-;$9GGUT}X|D_E7S1|nlaH3|jWA$do zwxsAh52xZlm)f}CX%)F3tA9NCzf=DIMuz`e`2YX^UlH#4`h4vDy$M&>CtsSEe{y=x zikes#Bc1<;%>Qp;_yVG{GW*wiJ^Z#D&ii)Ux zeV~<W1)jHeHepZJ6vf{AbX!oh{-m_ADa(o;Y=7;3^IIdou zv*L31w%e)xfl`$6yAlSTer+8zzcO&cP1-0NC*wQ=LEmc5Vr z3l@27z1==7*mXfqba0pMp+k%I_h;{{R2~-T&!dQvYqb3ziXl@$KIK|NsB| zpAJ=mOl|o8f7b5a{}nOzU{S^Y@4}Zpx}WhMbleeG1Wtg>g7f}gs@!>L|GfW?96vof zf93zo|NlR+#c~!iFbG6@x`2+YK690Q(j5hX*2J{6Z+SIdGhS+NKlpwB;=*r1Nmrs; zXT4{sFBN9F{q&`Gh|;;qHkW1f*FRG6FS-BOQ+2v|)Q5i(%pcE5p0w7T_|iG&SheLo zCGSs763U)&ryonL+LO1yM0tq;SMJ@=oA*ppC&fu0*sO4pqfpG=^t#FKUAHw>MK{|| z(ae~+FnzY4^*^Wv}>*`6aN@_Q&jP)_oE3c z-2wl8?aXA6JeXFooAb%*Z_?vfed>u>qDGCcmoma^U; zUm!^r;^|y6VI~$~&AUvHRit>w=8mHlNymAWmsLnPX?8W4h-^qzGJUskmHDlchb9}_28qd8<}T2A_wvX4ER&;$ zj%PgYNNG4>xz?9o^z4KCvv|7Ke5&!gKl}ezxiwLJAEb_5u43;0>-smXp3(o*uk60- z)0!3@ddPNg(&L1c3A=3F+RLkZ`1Fq^YHjqo^gtk4Eo|4FW%)O5nv^b$cyGPBWTS#5 z2TQ_?_7{({j(TuNDm?Dly?e{<-S+?6re5Aw{$IUMK6I%x!|K!-R#7V4x6hr@U^%dK zUaMGUZ(-tY29+%(b`6e($FnmgUOUS6c*d-Mlf;-D&iM9k=H2*D^zZd+-}ruAzkc`b zM1h4GMgG06%G~FhB);u?QsLYoIALw`;l+=2zbv18d9&bz&)f@d9hkKFwD$Bf{fZ0% zM(fN}r(f?fWZG0)TwPxOr6DA}zdt?0<+=YOf9a-=&!>B5S=llCFwX3768Jv#o&A2> zY9~{!Pj!DjO782|IC1@Q#+%nWq<>!jTKY%zVCtty`=stqWizQ?bKrWD$B7LumrjUT zc1hEQZ_>$UcAvkuK3*i{{zYWvGRI4*HD^_(=lq{^YgwYjk?U?EKV-JYti1M$_vVy0 zQ4bgn9dqb1Uwgjn_vXv4E3Wr{yTBu`Mxj1#-V+;(2aa2#)`qk_RWN@cuKw)ioNe=3 z3u{|y8h=++F1={Ltk>M^Dan7x>tlk-WS&UjIc~l)yOrD<99fo2JrUZt(_zEPz60XR zzvp~Ee(N*4%*h1;XYC5NH^!g)Z~5FtsOHz-@2{`tGdND!%bjFd#$`Uktw|<+S*;*f z#J{^ zocG`YZ_ewqy0~4EV?Vl!SS#7-vDp6bcQ}@N@8ibI`RCo2zn9f48jzYWd2{6iGN|5v@#e7JGV zQYNQq{i$w~H1qTQPf31#W2O6r?TgEMnVPDf%~Ng4VGwQZ zXZ`tDjRI@_z?CC2xDpD>V49M7&wu!L;&IIJ*mIs0ikX|s zZs{+ZV4f+lX7lCM5#ihKz7w9YEN-PE*SSA@Ob>(pc7-fc(VgHWuX1(m3BK9FmZB%J zD{dLbh0pZ4et1c4XQIUP+%p z{;F-L-v!$^YgWMVt-Vc=^><->@BA z&5NYCyrPO-xY`~}5ADC8>#>YO?)!Ne#>kQdiQ6`C>~)@YxJSG59IM5-dDoaH38Xx^ zcJCj@nFs#yW-T+8wX{9gv=e^t!+HHQrfJFwpEKE_QmX}{zqU!X)pa`@kbf6ELr#F3 zefiw?xyE+dg?mJP++4@$Q4{kjf02^*vqd*opX#W;&c5*SYHhQQPQhavyBuXC=eplp zJuTnu8GpLAhV=QKh<$}6I_+X7*&`-9@^0F7o%QCe3U0%Rv$pyssJ~Nae!*lY5iDbs zSNS7!@hS1cucA~uZd_FmzC4BB;e^rSX3b4=-$77&czh0 zvg(`GN4a$h37aloF^OEPVU;6$+;8W_gD+SWmp%IEQ~!SD)KvSrf1gCZJpJrm_o5&` zkaer;yt)HshXrS!4Oc$7v?@i?ck}V`JLPKb%{9TT>CTOpt)%VF)&IYAb@`b9$3=z? z-?f?L9QHLjzc?M1|MSP%+0{$R6XoVu?Mj}~9iO^n>JgdU!qNd|vv+;}`+ILlnT7Q! z)^uZK4RvOP<;NGMzu2Bq^w;9$-ji3hZ8)Cyo%N0Quea}CeVNny{)y>twRx^-XEVO} zxNAxBY6;}j?35NdpAcOwa<(P^@8gM&LShZ?^|7ZijoXNjw#mdrn88P>c|;-B^7 zTBI%O!8mEro1JY9^LEV$v{Exw2`hZVcgQYEfI)KeqA3>Mi&j2MUiRPg*DbHkj8~I< z3XQa_yp8H5Y@L2PbIn{T$ZBZ!GPdG(O&GgWdcOI;zaIXM3X4{@uJTUV-QVW;4JrjIdIz?~X;h*l19Hzb7J!EB6 z%i)!6GgL)pU;V{xmZ-XR-LKT5naidxd;b6Pi@v@l4NHfQt1sl4CcEx4KmEseLca)) zhl_F0ocETIdYyi8-ySSuobdDQhF+ijs^3>^>Amygy7E$mU)R=eD*UvzZ;s`jQ@MNA zggkU{5dHBe_3?4hk9@N%>rOMUKUwtq;jcF)nRjn}n6z!X-s^h#fAI=zHD}|C{#nS_ zsd+kb@7vF<@cTzdz@((wJ{~Ix#m2VXQOnG4r1d7HEuWk)wUvW6wm3@sL_4Fv*ktdpK97aK72KeO0&f&8n`% z#wC}tKDDbX&`|f7bYNw;zJ!a;%!{&H7FYd}^S+moQ1|An`sEV+ov(y)_AZ?D;C`!k zM~X{`i_F_22JIIa3Xe3p)yz;y*JQYPne)?a;l*qxdH7XyEW(0oLi9R{&uZSWJJQH> zOLSA)wt3f|ExzD-w98H)!pzy|=Ev0s#go=4h?_b-Ns6AcJ42->>KDV!oj!pR?&jKs z%=n!w;qksl-mL3jk%4+yMP+)$<5M|tb9Sc~NSJ=*J=~XTDbeOR*<0l3l+d`V_EA?| z72iyMR&>@(|MaSe2{$LEZks&&bgb%wh%G5iX>%1$ehRwlx^Jy<_1@n~R_?2}@w7a@ zIp@Y3k&241N*-)#`!1Y(`b=+D!n$nkyTLxoVpV>MxxHR9y@iASlKsUkfjr^!pUydO zDNlUDt+_RqU!IBGv#M0*)Zay4dkglaZO*f+@S9e9`uNwT8iRi^WrwC%SP0DZTi(%P zC#$kfh;8@Bw6ME*RNO^EOQ=)?(s`i(b7 zY>;X@^g;WB+K%13txYU+j!*j`RNl_3clXh|30_spXT|xi+t2#^LQnG3**o*%-{epJ zBjn^Z$I6v|JyY}a{J@8A9&Xo{pBGzNc|_BxPWuy2_`~uy$7Bws-2EV8mi5oxgJbCw zoh#eVnfIKwua~!BFlegg*FSGA{>Zv6^RvwUP2A^1%}bg%*8Eu2;xDhlQh#tu&TPw> z@AATfb&Je)wwYbBvFDhXJJV`kX~qVo>Sg8Y+TU^2ilsluY<7uUz|viD=JA{DbKYkK zsGfMZ5kRA(%wXG5lnyJuUsL9+TP9&PC8DP|UE!=jyjX(L zaaFbaI4*g)>7UO&TTotfPRHx&q(w9peH0;9G7ou@1hcIV$)a9sMj zxWiBBuoD5IlZDP~j@xxjHutQj>Zdt3oU@!uCv9@5S3deYW4udU0EueYB2aifizPpi$6lSWhQuDnjwSMm~^ zHs_suRl?yzZM}z$Gq~@)wk><^(`&P&aMRSNWnt$|{kBo^`jpey+J3*2k=fDd>7}}G z{Y@!Zdz_<|&MM~q*))6gr!A)r&+Iz$e5&d%r^6~<3lal&I^D4jcG%+_r5Wub;!-Je zG-zea^mgM=$0xg{r9N_);dD=0s6k-SyPI4}{Fzsa)+%Hl=q?I4Tj#OD)#x2p?)65+ z2TFDiCfGXdx?UpJuVyvz)-UGYl74mX5ATY&P~z5fIPpZT%%PX}u6DjL=H=Wz!{g7t z9RX`(Wd*CbmoX^$RAw8v&33K*S=&1gqjak)C$Drk zJX*l8z^;S0giX*^N{~A$u-&cUety&mxfh$P_8JHtUi8q`!NJ1k<(qfsR68^daWyhq zN+@5xzdK6smy1l0fRVww*nJ(pFWuO7Y>7(<3+L>Mi%*MXJ{7+wc$QsBL|}hr!tC^~ zMXo8HVcP-@9#Ldrkh}J8!RG3pN_SE=9=gL~t)dW>{Ofm&v$j$CcK;YckkVI{N$-6OIP$yn7n4~`g!vg&6qi7&fNLi zw(p!Uamw-)t5&UEci`Z`6)V?VzH(*4q$$f*tXi;e$>yHiHJ!Ozwro9d?$XiI7ml90 za_-8ti#Ki`*|YWV)|Km5EMGc%#*EIEj)uCiW1mU&kD8hio6mi*pKceH_;|ChX`;?Mn4GP*yTkS8+Df zw$xJdHrIDI(S>Xnx6{)|jSLPC4-X4R2dM#`i9vpO-VU)Lfe{fA5H+zOf#Kod$pKyw zVWEM6fv&Euj*gB#K0d)AA(4@hl@%44nVGh>wjLfH;o;%g-VO!ccJJT6|NsC0?_WQ2 zeH=m}B3G70OiA)tR~@~vJ~rLoJu$$4VP4R`M^paZDEM>E``??Lj~?F7^>+CG<;L$L z>c6%y{NBd!dnfb%pD$OgT={#i!0!W6zYoZqKYuRQ$1x-{EF&?x#LMi;)P%E>5-Yt7 z-@SVm=H|Pqt5`gBzewr<{rXYksSJmpkDpnJ-M!x5c_Ca*er`_c(JpHQEmu)RI0hbLxkX-hiLpK)m8k|UEc z`$`iJOvqSO5qaY5`3V!I99%JZvbIe({DgJ^CFjKamYGX7?m2S((~na-jF`Fl|35wu zu;xE9xQxs}u+L8^R(iM#%12!d3l+piJ^c6o>hb?Okd=r;Pu_9m=JBNs4vRwm|Nmn2 zSg{x({U#m6_5=}d`~}YX|Gy^W3+(@YIB@;?rRUCzSr{1jPeTSL*Id}j zctAmb!Qsx`oAno$^q-#kfzQveg)=qAV`;D9wVSr**44+c9+XtIIK=XAin8XV9lz#e z&kg1|D6ho3t?qG+qOJ z<5`D>5O?P7`~T;PomrC8uX2CA%C`3+UN#M!of$PdPd#VozkT^!g6FKnF1_cOMM3W_ zaN39`&2xRhwa4ept@AHfe1aI2QYB&=-{1F_(p_JA@Psp$relf>YqR9R_E$cFKbvd} zA17N@XgW9^J!I<eh_x0}aYwOjX>87j=;Xn&r(FeLhAZQ(ibN*6ib-8)xu zE?N<;FzLgo362q#@p7~NetRSNgtf9lX^M_S603*i+(3;QRfe2;iU0hUwH_bu`jF_- zJZV+8DVM6(6c*0cwUhrEj?3@iPsdKDIbzy>z*vxcvT}*(#6pw#P2r+rc>d zQh{Jt>8Vbh>WTgNYMnc}X3R_au4tSvi+h=|?03H-YJoF4yjwiK#vQ5WYVA|f3Q>_- zlc{;{Ye%lW2CwT|RY}F2+PsVWQVbUSSsqXl;r2~iPJ7AQYdP1yaNSuRa6{_JjWxl` zuWi5oH}gl<^)HudcNP4QTYlvE&7C#3)(Wf?VD_#aC1Bo|?{-kn=}2|NQ;Fn(w=K1I?cAi(WhBU$Df!V+=`$m!JFa`>FWkD-!#E z1>cDlSovFoMZSk+gR@Dc{igd1KRS9${d_~5bBU*tNK-%igB@9QGkqV*S+26a}4UzXC?LY9ogN|aW-4x{@pWbAGh4zE3LUHV@}M{#)x3wKbs|b zS1&r(uHq@?eo961)2+@r#AF=KJU1D>_7 z7slvZ-uB)>>v#E-mUa2FeWyKPy>#T|h7g8^3=X$>)Bmc~-P$+x(V8Va1wt2#Cgxn) zH~CsmME`G{KAHM2C)W9gd!F00^K(Fv@4tP%b2dyqp0iuEaPFE*``SPLw2%6pBmP68 z^45~mXXm9}-jn7fsaWRZ^i`oY@ssYo|I=rjiFUDA-R64hq+wM4f|TpaPOp(Ey3WNB ze4nQ}M%2WuF!Z_S&a7L0TI(N6i>6FpquFor>sy-Gf#7#4bs}~T{TP3xh4Q(!ZmriS z^uPM${A1>1udQi47M4zrlQgC$3)CIXO4)r%a6f;w<)!nrO>>=h>$G!iG<@|rt;%Ps zyrs#y(@V8iX)hDq_CHhX*!kjxyVRt$ypCP$Sk|;s-eQM`+1e7lSJNFP?k<^l{K(a7 z)-BF6y?tYsCDieX?7V7I#CN?x=-jpat^4-ua=gy6`F?YJcAZQ3(?YRR*I%r%Vd=J6 zw7N)K=TpPFQ@0Z)T9<_8HM!nfl>O;r?S>Px-~UrMDpw)RahRd+d|%pY-e(273RdOb zetYxBhw7}~@}lkcC6(`;Q~bjHck8dU*Y?@I&aY1VR`!e0WBKKmU#&`heQJ~BVN2Hj z(PSGx@87k+=YRRzq>CN=tmbnGaFm4Kn0+#5)dUnjmsECoGi7x zjMnsi)MO0RIH+;7LMg7~)|va=#SY(092yp`6o~jb|LdkKf0^IR1@?zeJdMA8cklP= zt=B%-JV~3Ptu)8SgV|E&@q=4G3+-r}v3SlcI@ zxT$yO#f=|Fo?Lly<;$5jcMkq}_E$+NUcyku%`4O4XJE#%1dA7zq8fD*|LIL{?cC&P zVZOPdK(MugXW{ppDVL<4x=ZLx>#^lJ&N8dRKyKp3`#$!UyV*q-c6cmHXmM)^i_lr* z<)!VlvTWk#%V`3S+xb)use1JC^gNl(sHw(uO#4AWFHfe3;Ka@oPB(edUj6x}w0T7> zJFAh#j)!|2c$RxOa0G1&DcZGcfqH_rmq_0I%IEiE4V*2_uSY()u~9-rRw}WLyY-Ht zRl)rRAI0z!Td(uaeeft^$=$_4Yp+VDSwG!*PU)kZlF-yCB8Pc6GkSgpIz*-JV04%^ z@q+d)C2qB}l|jbS>myc1uTG0zrT1?7TyI~&w&@y4N*MxKB_=t4y_qK5s^h4B^6c6k zo9c{{Usr_h-;s1X`)>T2h^=N*U-~I2&HgCXvg!S|&^;#~U6j~alX&N>bH+@X$kbj#7t|_Rljmyms8|;oPoJz1^(R^X9Bp%9`CGu<5HN zqade;sL&B#Ll)ji`8l@PvBt#gm( zMDCl!u&~{^`lrLRRTd{IbtgGY6nJr?_pN=bMK4Zx%fAj_wMyRhoKi+1m{tKWIKX$+v3K)2w#SOZsf>Doi^ky;G0x zIrweC&b{6)tL$$aRGRr4%e}5*hxvt)l;mH3 zouM&nil3ot@{tSOGV)hh`rW4_N6DpZx^{27q4f9n_it~D?OPGnL z;kmERm*rdwtLF&#$=In=^0uB`U~;mp!h@Kv{ILST6WIkVt1p%~IIjG)_>teWmCmuU z*YsBkt1&O-Qwn&L>h`rW#z|c}Xl3a1{o8NEIBc(3?`E|pPX0oi=?BKR_mj>4Et7Lve28mna$$3Tq11VHtF?m2-A@BVI&+jDREhc%mjmm2&yWvq2bY~TGDX`L)=97Yu*XLYYHM^pHRG3^E zBXsV4T=dvaMT}KRqHyBJOfH`o=^!1gQjcp#TwZX*GP)*prf3U0mxvZl^wQ3+3OtlN zEhxz~uEkAec29A~G%>~K%BqcFXTNbR?Z^xAW9d+d=$j_27+raJ^Xy)!{VMw1U;36^ z{E`t|TO;VQxkJq*$oIm2^~k6HpXkTgpWnJ=*#gI9=NWo>W^I}Leg4fC8oHh)b_L;U zbF;G4a!#DdUa7Qj{!OLpU7z}vH70iM`dxOtms$PtbR(mbV)=5}osI3W-?!RGnjcM% z+jn5fJ&!GCeSf}-Ha{o3ugUVy;}plXq?hdT9Foq-9Xc%cCg|qFN}t_NrgvR&yL4sF z{^HM1rmn6CieC;Ak{a(0-rrI1c-yX>k;az4wwG?ckSoJ>py23n8?S3AJjc%% zq;0$YOQLO&uB`QOm1~BRf4pNn=T%bK{?)VVG3R-?;8!l6)HSxppIKGE{*_pK-5KLo zg@>nG_r|tPoqBUp(th@w$upNfJap=m^VZ(&?=Li#vgV7q?5n&p;nvjHnZElk^L;IN z)~U1YboT3@z{`IVLeE$1R`_)KD&vYSuTW2!*=J9mPH}WOnfp%5ZIDS>1ti90p@~~1l?^OLsOR6TPXr7#B#QJN7`|MOnfkkGEjQIrw zMVz9=JRcp=JiWgB%vJ84_e;)S*>GQKj&LVemf~q8nNxg;@(X_4wstn}V7t(9b9E+% z+YVFZh$VY&J!kJ}>x&tU`QJ6}(TT~u0=CQ+5V;^vhGHzqY<&1aoYc8g9F zns;RCsdc{@m=7n+=yJ%J$t>kmuqk3gNBCJwUD?1luItWrZ{h#PX)Z0r*67G0@i@s< z}v$mxkPff#Cusi?naC4OSw&iG-?V{?l zf|`#HD26^Pjpvx}zemMt&hBo(E-vxFJuh#rxqPE5`KLh8j^S-h&8OvZG_e&xM z0~rgUs})0?Y|YIrEG;bUZ0#NF9i1GVoSd8->>W%@OpT3A%4008EUoP9?42B)ot<3V zT-_~AjGUaD>>L~|EiFw=%`7b}ZLDofj7`+l)m2qh6_u2fm6g@h)bw<;4fG9ERaF%f z6*VD)*ZrCmimFr0qx^T52%mwxVoTdOH1PXlJIl0^N&u+ z?nw0A(V22^LgwDy^iwl(_xESy`Z(_EOTRd`;P9lZZ7V%Cm6Rqo1G7#+z}r?EL@#zu^D>Du4d{`@gmav;ytlpa1_)z5MjQ@c;jbkn_2% zG(jUhFK_$@DV|-I`1OD1Dv$^qLl(*X|Np=I|Kz{_4F3Q3xbXk~zm&EA|Nq}`=)u80 z1_sWZp5O&)d#1FCEivG6buY*)%x-@F|No=5l3jW~WW^uMn||Gn?_Y#Ykz9;%yW&AM|T*=&Ms_{ zZ4$Pg^*Ki7hGX;oC7TmZ7k*xJ#7bw5R+HMRC7FR&vt6VV8E>uAIyGgb^2BCO7Z&aA zJ+GoBEb71B!O$=zNg~C5+g&05L*H4y{N1o6hR5x|W-d*}1mEySXNsGvm|990Y6CR% zgV!-fWhMl&ePp)OZ6D*80d`GHtGeFX{SUYx_(h06gzbX=);Lp@ zO}%GwU#(U=OM?e4+SbuHAGUHME^`z;$NjF@WgNO zL7PUS-`Sc|EWf2JcT_M=GfR2iy{F}gKbK^3=1GI~#~2kZ&Weq?w<9E!lOgk4GG|AU za`J?<>t+lor~M_B?kzlJ++g%qEHF&^j(p2Gf7!i?>UDEBx}^2Zwkf`>^4{X*hVZSC zZ>q}YKMS90t9Y?%slP#Wi0f3<50lnR$rm|ybCT$h-C+~uQx45fTXXr#XW2(ixhh)^ z{Qa~*m$&2mt33*jx$Ec3S){bznZH_MU*0q3ogeit3H`rwk=f{y%!Zf$6=mDs%ro75 zCr_rG>BGzSmCdR5&aMnfzt$)IM8|s5(g*{l!v-R4lcwCOKOMSCjIqpJRX~5L=C$B{*lty zv~!yKtSK`daI&mU5?1?k+)B=1oj_{L5zjZzj~h&6&(^ujT)lS!bX)npJ(U9b=15Px&E~O*{ps(-lkIWL(O+L zRXt0wAPWN>H-R56@Alrhck|}G+HZwvEIkTy0+ud~U<-C-O5PBYl3!k3US9pX^aAI5 zHq}>AXO@0Y2sJ&Sv?1il!*8>Cp@hMOC*G2JatmXr9tL z-0W-F@h0StpVH#Bn*>;rotFyuEH+!e^3z;}CFi7%>f6o?+u?oK<<4z$S>-h=E!r2= zSk2~*J~C~7iv8KN&nIGLa&)N|Jp5L>vs!D@Zwrr>fWk(Xum4Ic=J;~!v^F2R`LE!{ z?S6y3LJudGe3abq{Yy)`;>*xmvE34ebNKydxOQ=|hn#Oy|MIN&Q|FuyA6^D$+cCKY z)IKwu!>9eOB0zL*C(m=sB9}Gdw@yz_%fuez#WDQ_LyQ-Bf5k zG2=>HzgFPy%Ui@fkG6C_`Le)V_Sv<)8LKK%R3jL3j)X6{c4$h_#ATr~I#UhSb+swh z{tdjR7C!y#{W2@zNxu(C>F=rB@IO*T^SE2Y1EF0cyfbkK6kqz?*pTetOI zNRkYaUSxW8mc;j&kKWz0?(T7LJz`XHS;Qyc;HqV%A#=A%*>il_z-1bE>C@B0CXWv< ze*F0H;=_fR)7+Oe7H;U6{pw)VPv?$T&pynV^y;ejk+<@#OR7#fyndS95_0xrkBR8T zOY)N2zsbZfwDW$;iAdUVp-t!h`Jkzi1;3dduH|GSfaPipdZ zKXCA5j?{}O?mA3f9~DktJ$tM95MS3O)=;~)?w_Fov%4k38gCwwC@m?NoT0Nd-)RnC zazd@}5@zQd!6`Pg?x)o2_3m){T*oyhD(;5$0Y1Op7S{B`Hwz}dTockA&9>|6Sq3vP zSGUZ>{f-h^%QnwjdU3X|x651C5LM0}5=!6y#hG{}XT6tM_T*rV+1uE2$81(jD4k_+ zj$L3!@3{xj=lT5Fx8ybjUjCnHHGl4(8T|ZGOKu!my!3QKG$a51uQ>_59kvpo9wwFM z?>=pE>bNyY=IPAkE5!?5?_7FhPO(}}htu*q8mWdpRuYWcEd{G??$~7QBp%7akZ(*Du-to6>*FU--b#n=-}RRrLIY;)sN~`<8`u zKDlrt?&^KBFM3O6s??vHFxiPIc}}rd%)ZWog%U-T2PpV;`GnBaVUf{@<3B_UaB z(kC)^-uvRAsrf#LZ}EDm^}*qWQ#U5EsPXl39bKd>Bkhtb;I`2%ZpSp~rUU=`rfG>J zI5p_3ZJANdabdzVTkUH;mi&L_Za-}=+!KFj6B8J7M6z0XfBBbu zS@`DPM4A5!zGNIvVR(97-C|dOW3SxPmXN^oY7gmE8Tr*7%&S)H{cDizsQUM=m{F#a z>f8Tu9=t0RO_#K7SrA%xA%^cKlYQi}UXSY+&9Joig@lM`@iTpaw)jh9eEnUWlicm| z{hT0e=u{WCa34g=8~McZ99VPQ*VQ@6%PG&tG2PuR(a}2F+o3AdeQItr)*7ww*ww%jrLlS56huj3Wly#Myir|NQc%t<}am+{`Z`fO$H z%F3uFFR#;%**|p~F6R`?EeZc(Tzfmd_(*%!MDM_R4#htl>OYy)JPIs(>0WtZcK%z3 zs@D#cdmU15I23GePd+g%XF^8c&aTuM1)+x)Wwo05R#~_onUbwKrKNVb zC)37M)6+~Z+uznfU(3x{XH9Kvh^^6v`nZD=Kzoef2e==ZoCRUe$qZOp6tcfRSQi%;R~J`X zJ3D7{?zBFYRg>hmPf%VrtH61BKtZqaN*fPTBOg5m28J|C?;hDL zNoJX{>}r;LZk~eCabhJUG85ZGmp04K&zEk~;4lOKt{J{i{opl* z-)GrgwJR=kad8P1PnxQ_X{qM1x$1jns%`6#-ShV3=U>%CO2sQ)lAvS17#Ua;xB^q<|HsMw?^9XjXIbOn5ED@n_KAUk z;Sade#VN1r6{(FpHAQITO&-9Oh;{zTgU|C=8D|Ns9pC`z#z z|L^~Q&^_!)pFy3s8UL@JZ~XrtbSk>a=LiABR;0Jj{v$a5m;Lu$|NsC0iCg~vhb>b8 zY5M#3|MlxPK7IQ1>C0;CDGdw^ycZ!|z&F>9CW0<%zu1xatoF_Rs}mBF#U%Y%!`H0u z@9&@25)vhy-FxlS&)+5$qDe}}6C1+L7Z`8y*_YR@lrk&!Y+vid-k8^Y|5UpI zQ$(hI(_9#^N_bL$&b1d30elPhI4@?Kwp6w$!1dLBgIuw6$3C|0CtI@Gj?WNixSQaaULK&9^XGuzr5+jM)Wk20F)$FQ$8bS$OK~o(Dhq{~i|q@1H8 zwCB?E3v3FD_RLC{`NLtK%wnz9pqW=*?OOJ7*R>3ui4E$P*%K>VGq-hQUM-b1U8Vij zk69}0ZIgPi4zCIO+OACLxn5iEmGwML%@CR1Qq?qbWmAK6x9#K`eYxdxqRtxiMC}i3 zaG4?=k#|eM=h{(?$wo&P7~S#T5*XmHXpU!*jj`{9rl1VHnYBCtYu9FKsBkV_kebZG z$n~@|Q@7<|gzS>Nyv-bynN!(=lUNf)TQk4O+*%~ZR&ayY_5h>q?s<<2_9)bd6>ar8`h@3l#X zYl2*%^~~NKwQK_O?#D!gFP*#Usn{Z)X=UG^$v&Fc!lZm6NpGgkso#eli2vTKFI3o= zQkiJBUTJUK=9L~V8(wX2opbR3$EC1GFMhnRxc>FD@^Q{dCzY4XE#aA-{PMwjA_e;*%ZY_(=NnPbuVh+5}weCJ|hzjR1TC<{pJtSEf>@1umb z)}K7l&jtLlPlfnpGIuL1E3SCecqUljFc;gh+1Bs=e|)5~`C)Sb!zX8+zKq^~2Ikk# z{bRnVDj*@R^0qN1F3$6y9OHx&eJ`|4t>194JZtWAVf)GGuxTdmdZUmOzN#bqXEOSq z{FS@;@AO3&d24x5Iy|Op(-v*D3zl}-?V@4m7Maw3QzeAyKizF@072Zu;>Zz z#D$ih+AJ1p_b9B5zie4FWm;%L@a30}d<)s^<)4HzJlvLgMPBJ%%G^z}^Tt+=&N&hz2{zve#wEk_UUPq^+3XT+6s{&VGSZ`$PVo_7~^>=`Fs~;xCajMbtSo z^x_JimlC{;uPfg(J2k!+4RY1n8XQ) zDe31V>~$BuWxi2)gZHc2*;7-LlIBQ7DH(iDcl@+UbKV2Kx!hi#@3=lGs#3jV)PFvM zA>q2z*SQ7_2@D*J85*-@c%R`oFxA9vU6w`Y-TnDbeZC&rSFG`3mWG+#@s*hmXWyUe z_>KM5>^BJ+hgrVm7UOx)eG&py5NYU$xTmzIr3g_(6O&Ei}5Qs?*)wYlX&S7od+^yYOZU0l&; zI{$0$)t84gulMAN{hoPSM}|+le|!70<0|PJW+vrl?YVLFo4bLE&gOl}DW|h`r7<5~ zdh_W~xvtHXoGrSJC%?Y0kz-;BTIR@By5O^54TH8ni`BJl*KW_vJowXX)`YpUxjiH2 z>GsLivC729qqIa`;q=+9vTw@1|GJcTzfwe~c=ORmMoS~+==w># z+`y;wqg+kq^%ri3mH*E4q%mu}uYCAo%deK2ncwDb;6Lp2=}6MVO*2mTdAA38urFg3 z`fOz%C{$zr;EyUpYsy@yw^dD3CHKeITw5!BceaU=-H#0|Jx&V^bRQjVFXU=1?NP0f z-NFS4LC(cvdrMDmdROxPhLy|zCWg=Z__B=4<(f^G zu5(&^Ph<8nFE{x$zu&Lh+T?H}I(n|(^4j&)^;_viVBOg zL{(kg>CQqyV`|_`K?rTZgV`*PvmohjSYnwRx^ z{n?d)n;tz$d3@~hySKBqea&e~RiAa1Gc0Ydc7EEP7KI}Vk8?UGT;#slc)P%FT}RT% zHM5tBu&mTbe}C|}t>sRq!vd32r%lz&`S7;VF4(A~Wg$DG=G7G{!gZTlP9Bv`Tb#pi zL%whC^H=|#-&4%KnX9kP?W@%&*)mz0w|Lbejkd%oB1?nJq)XL~^9Vh@u|vbb;6|MI z`L}aLmz(6VT5=w`ps!+=I;)qh^uxLOFZG*q)DAm2-A=O8ceK~8kZ!oVn|~s+{@*!w z7WUrS7H>N9p%If}VwtGZ{*x(k%lNH53Zxfq+vI+Em({KB8GcsR?v{V6ozZ*z@yY)h zEvd84KHGen-$swU=F^{#cmM8YdGhYotz)-rXHAaYzON$v{=w^;XKy~unbt95sd@gr z6!z9V3v~?lsyzO*Mtvo;MIJdcW9)eL`&exwrcY zp2l@Q)iT<2eebV#X}p^gn-d$}{ol23;m5zrl01ZO2gLvX`q$i4+KeIT^xyaUR6od= zT0J?H`dH{O|D3&tnPRVqvZNjV_ICOL-h_-iFYY;GjZz9k9CD|>)V+u^I~4AKe%9%6thnE#GJoV!wxef1|C^+nJ2S(y;WXD zPH4h~+kdaFW8VER{&QH{=C?^}Y%FZzqJOXB{yy#8@kBnWHL}voMR!_WeE7N4;evt0 z)}3c2xHV)*&I*Y5zpBhZ%T zpf{=QVSz{AH%-Gxl|>GZlqRmxsI9e7*{VK?^9KXx=L)aTt0Ct3UqkwrT>ks=%l0j+ z-vs6!zSk0Sl~-`S2;Wf?X0fwdO~ssN&6;)l$fG-p-UJw(T<4=U`Hjeou+X=SLH)+} zo|WvsS1uN%@}yc;sXu_Xb31 zY!0(#&+77DFTI|pvgWTqvfF}(D|YCle7UUDG5M%T$Bn5MWMg+9iw>2Y^eS~v@at$P zjSJiFOi7rSt7W-Y18*BDziptoU9owAkFnLM3PIg<#1BqCtI2CQjI|pC- z7|py{?(kskwK&tIW!sHp-p`eN>Hq!o_cfwSKYx8F%6|N-q2SG*1%`g#+xA(NzgvB` zsczxTxQwR~eaxN9_wN1MlqxHr;(E8FBl*WA>+|nw;@>xy+f{@IxkPP>uE_k(c&;K} z;@FPI52t<)TK7X#@!JHa=`Md?Oij1@>+t@uY^jD%dqU3Vf-l#Y8P&K$LQKu;^(xKdE-fER2cH$j@3SIny7vq>^ zzAilF@J#75cenS=n0>iZcKvY)l21)k31K`@!b;`j4iKmYjYtOsS7qe-;dwtW-Gyi@V$A4?x=Hl@w z(q`+WpS>D4-gG>F`2B#6IE61`(~*`yi-^=aYbd~5gmsGIXeY1*K zD<6H56AGboc>z(w=_WS-@X3&KXr@u`~CU*{pshWymM6) zt}{q|ywBoMbR9Ia$l&Sf=d#Wzp{b#RA+>{nflGpjp&`b{(4nDRFKfu8Y_5-Ewx<i@v?=81iLyG1~|7Sd2eU}9e`aK=DwgTYFAfkV~kgKTHv(2&~0tWtLkDWW(LhE zj96S5GdVA)G~C(KOfSaOJix|?V@?ECl_M0pV)oz@|BC1uiSPqyLkCZ@v1HeJ9uL|M9YRXD=#O7o#||xm)o**>)CUc zF0ZYLnVIgts4#R>WBkR-S8fEmU0J`jV%pIQmo6V%Hfzt;Eh{S`m#ah=-yRBvaenz)bz569HFI7bJN8Xqt3 z^J_~VZFIf9KH>1{$<3AJ?>DJ@+AO`Ixp?ow$@?c29GceU=-_mw95nNNu2b5Pfq`Km zcqBx@A)z5aVEy_3`{x%JyuS~cbOsF=pkRa73djF@HO%^-U=`N?-@)Midx8J=LHigI z3TFP_fB%1fgTw#-{r|s!Gvx|X&-5EMuaV0d# zRgs6~!ULWH=kNP(ecP;;vf$e}wnr0Z&z}8v&UZySk9+Aq)$FEqsYl6Qf9clKbUl;* zd6cl!y~TG=Gg@ldnH*kdvd?zviXU5ErcPh|$lL4Q6~3COY7bBIa=-hL9H^5SxuPj4 zu=I+}2EX-pE9ab7Ip}7b>))%TI@u;MtYtxCLdQ*p*2+X#3$09pvWveQBd&BFW$}G( zcH}^ybkc?I|G&MRzpvrdJjvY$CJD1KTlnq0sr8V1rop_#JJ;{le*gE}@pr-W>-RbT zIZT;<^!kLNn)SJXqJ^f1OVzX6S(Z%7Z{DOR)X?+j4ad%!GdCO^uR9dJ+Hu^#z*FPg z@mK2WdCZpnar|U^`@@g+Df?I#Uol{9SD9uLwSUnR7fG8Zlbr1ql}P!1=#W<1znWVx zl_N>RD^;<_Ng}M6Bh!&3ES+PbqSR_#mk@=p-SY$j7fx^xTg|U%v_xTImvaI4rG;;~ zoIRFvzTE0zs<=eg(JVxB-==>~aTcd{7nnpoRF*2*(DysE#PFT#e&)7~-}h>&wlzf0 zf6XT1v^8Yi>!a;F-kb;TT;Z>m*D~Mw$f<2{p`@bL_LjcrW4eELOgLE*=HxN`wnU4- zPS;+}nf}YWjhqcyB8s9*PE?r8?fch0;b_Qqp_*&bikIeJ5IB{q%W?6+wA7Rn6~7yJowZv3>$$kY3N?!#PmBA}_+ay2r)A#??i#=0-qn2f@L~}~-S66x1#@pT1?+ur zCvS)IvEa)eI}dGLOz;Eq~(1 z)3E%`V{YTAGjAuSMdaiy^xK}8_N8U!Ov|4ur`pC9980#e+kg7|fx16?Cz@z`zb>kd zxi?2<{prWgVt>9o@Oz*2_W1jOA6F{<+yC(Ev`38Rlem>C7qJw$f9&`r{C5GHNyt5c z)`nkPl0h}cU7kF$$1>0Yj)Yl`Fq@PReSB) z@qS?u$C>8NAB&cU{NdJ1+TBpR!}0ZI0|z0Ob$743{8JQjnPhZtR~kc-!lyQm^;-)b z3K#sIo;_)$$BrdSp2RyT{nuQn^pLmnukuOzXIhmNr zlP0Eos1+4XY-eUndr7UCmwa!c#!+<3M#;=JrKzEzp;teo>V!$bOlpOwQBKKZL3UK@F*bY3@|8#uAd zwIznBpU?X6>OUcK=A0>hrZl&3Vwj21ljIUjr3DHvWwew^U3XQd+`4@|-tI!fTKl(W ztAbmqZMSjduU#c2@n$jS31=b0r<-~mv;D-jMX&LbTPEXtJx8x@G7o!?}rnL7EGQQx5`@J zt;e#o=MS1IrZFvD9{=}Tx68Bhoe>id?*H{|?{7cW*sZQ6Wm#>RQ8 zzRWad>aN)uH9b(ftt;WA6}ueIOuG_6wY z$4zEl_KdpdiBCn{ZNfC&5^`&6lY=!j**xTl7D-I5X1{SSMXAiTAmvDMZTrT9lSDrj zsD-w3FUUQ4|LV%MZ&f-3`gTp_Jg$6s^1F{(yxUIiJuS|BO9Yb7mjPhIuU zb9&`O-^26c%M|*q`8aBrx@An~KHHXf|JT2k$C^fO7#n%QPpqD`L%7Rrt>n>WuXFBg z{uB4|d?ImdV6I{B@3y$jB4b-$w`A!nfsOi)Qs&<%=M^v9VbA?0aNa$I!ibjToobudzrVJ7 zs-fJ`aoFAHM(G+8mFi{1tN$~;F#c>Ua9~F?Xf6n?fhcm9hz26lYiI*8*1e&Qb+0K%GSOCAJzsju@}T_W__)yYV9#71$6^=DQb)5qFMG4j z+9WgGq)5L451R@*<9ttB|DtsH^@}4@qbh9-b9|i?*DUZU%MQs-D0H*T_IJtib%?P+MuV`Oi`tq9C3v&t%PRKknGjB>>aJ-|{hUTPmv+|Ej$u0?S zsfqO1-IKPzKjYZ6oKw?tTN8Z@XY?$nh}_YcvZgWq@T9C61z{Dz?qcf}v29yb=;ti6 zdcMo_?$+{b)A^H+Psv)D68XqG)?Vg%|MirMYl9sW2;%EknK^LpEAfId> zr)m$oH8CEu;(b3kntgIK`|N1;!QOO1K|({I{p>XV`B?$EK8^{NI^kKxY2m@wu3kN| zVfnp#_e#=|-aDGb$0x=mBt@p>`eu~a#$*+@_1(XJ|Np6X_Vw#mFJCNLyV)b9=vJCb z=2XTNRi8O`{^!@vPaZ#h{pstr=^g1+&9;$g4ZV}!JDP3Yy}u*aG9<6cJ~ZAVCe_?8 zGAy?uB(KWQE6g=2Mb|YjB(G}Uq^twrdD*?aX`y*l`zK~zE(r0>uHH8(Yj1ysS7ybm zmb`P5Q}_0!Z|_JxGBG_QugW?qW5&|e3#Q0hF)%Rv1UHnQf4=wsI;c@PfcP6WyL}z2 z_Y`d72%KqoPU8Rn|FiyU{Qv*|`~Tu3gyJnw=D+{{RiRAyq+#3d|3Cl#|MwQuaKBTx z^30WQ8ubO_ZEVS!C=RQ8)r(QPauDR}X%niDgcPh!2dEuwyaeHgO?-OR35unhm z{=E0%!K71d_8Q+qJOY{yUJ-j_`jt;G2LxFAGP9>452{{}F z`*aqo<;Z8o>sdAjDo!ZQ+^hO#%2&r#GHxvg!cyae%X+umT&df`*0@$uoeu+X`C7%>p7{=OoAy!%H2Yx zDDKlj0RivTob9ewI;=d+PeNaEw!7_H^T|=*!Rw5|mZW2e3@ob_wtLFHS=97TVA;2c z1w9(?SYPup8eZl*uK8kS!#)AEtbS$JePV0WS&qDUAmASF`Mr0A(xZ$(osjdrYo59H zJ}$L57yeh_Pp^GqyWjKEqSBwTS!)&QG`{!>+ zRDZW4=4+!yW{&vrub-!{zrXMQf$+_4U2+1;$^`2_X5Hh@EY4>5_w=^xhqo)gPpey9 zEu40Y(eHrDniD}QdD#C(Bq=wYSj(|@(cRsD^WSr-sP(YydHs?rvexFgZT`JIRic(&1PPt)Z&@rR$>+OL@O=iM_G!S1v2O&VV9z7ZFX{HYh- zxI>v`xy$hloN0EACst;h`H|lhaktQVz0Nd2VfL;YFI|PWyS?wfKGHGon2nv4c9*Bn zjvTSiSClsHKD~V3^%&Exj+?iYg+6-y;GE&5K2uSHZ<5iukYnnxY4bFaPOMwwwtuFM z(8nmj8CRce+bJl&v-Y5Ypvtv569SK=^!gv>N#yss(LAqm^3w9yBi+6No^xXN&z?J1 zL+Iq)-`*UW%q_k`)`L;CZ2Gw z?5zIY(!2K6G>%{CyTkO~SV+IL)2!JZmywsF`Dby^wDq5lJ#8_wwsU!xZ+F5^mjv`tGW$51yvK{#vv>=%#p+Ky6kC_forR7ME!T8e6oc=1DSp1h??4Zu+|Y^JCYf z?sj(%mvWaSPiNXZYkF6F%p`Bu_^mfQzq_v3vOnyl(zjwovECD5cOB22eR%S2l0@f* znRn{KudMkww^mR<@11>D@-C&$Bd>ND8uohpsmh!^#pOZY1<_11&I`hYOCzQgKdVxj zv%JYgz)3V{l1JwCepz#tV_h!Or-d(STj{dl(MFD!;!6ZidMH0~sowce@TRBnCXaBz zoga=`Onh_k;o}*B%e(gLbyuvN#KCl{wXP>;!<7z>qj_JFT{cWUuH-wvPE`NctG_eK zR#rUz@^SV0>#-TjRR!neE>>7+!a7}|Pt(Ap_;%$_|uV&c~vR_`_E>Mr}%?_BBP*S@tbs3|%ec>d>0Cj$QmZ>mU_>&kK*l_=6q>Dc*>eJ7@hf_J+r|Z13l zLHj-vU$^I@Kl7904)I=WKD+qMlw8hkeNi|6KVi%F>Rx{LX8J4D>64d7&RP~JS0w$l zDz`lPXx`em`)qS=uIi|<)S6_mb>AL=tHL`Azecbaw+5}*zcV~!^YvS^vTdsWeQ{NL zT>0_K)9#QBv3jDRQ%>Ffe2y*gpork(6&~LXemcCF({`fv_6Z#=x*U^u8`2MP%`@G` z_(Obs+}^66pHzSSW}RF1Y2k)0f&Om|?s=h$(~cP|^Rcn%kScNMxgQ&LPyJ3^U(yd1 zb`gtdZm*}E+f%3d$x6A-Ym)=(Y?tc+g5B#n41Y)XeE4N+;(A1C{^FS%H~i>cetuq+ zMDO948(o@8+t*3BpFScwjSgHG2Foa-O?(*kg@?6;_er|IKb?`0A|H zw?FZ!QzLax$JygSJz}@qZ&;?DRhW2s^D)DXyY`7(eZRSG>ATHQ91Z+i9U07d7POyh z{QR!*+cWdWa(lJgTGn+0X)B#kc0P2z)t&QWkCfE+sISs)D|}oy@2$}PbX2v}{Jfh( z%v;CYEn0`S+-i2@j(yiCcFTXW^2V$PLE$~?PE2k1*|h8E+ochuF&o}~`e%^3lW*du zI<~`Cl%DVZmG|Z1?tL{=u8KRdata0d+gm$OgOFk-A39 zQhH@|?ISy0buX}bu+5V-O>%~e%(}#;hL9BAg>4U?%*r}5rSqa*R8+KVN{_aS^60VTRb-O&4y7XL33nSKU{l<&d=EbM?dRmp2|vJ)f>j4(pr#@QPZ^tZlzplMcJZGa;$KcnL=zyG!T@+s$|l%5&hH$2=VbNmH!#&j#csmK0y zc%(l)`N~~NNnTUw)Pq&;uf48*ow4D<I>q6fY{@E^l)= zvSYq&MeW;9qHlQ)CjQ=j`k9SY(akb@M&3L(ed)?C?@rEr8OU#b*Qwqj;maebV|)d2 zEjAA-^12U-{@6O(f4(pK=__COpB&Od)o)xmp*tB4=@$Dbp>~ntn zI`)Qrp6#4@JNDHG>=gh0p{Mw`eZyzvY=#*R466QqP?ng)+WOqm?}>%o8jm84ABPPN zZ)fy5(Dmm)Pe z=3UAhwJY|?h0H#OQ{q{--Munx!Q-7Zo3G}T@7i0pf7%W$?%OGfhA+OiFZSDgH|tq( zp;XY3b0&)}hF_GJA((JY*Xdxe`g8k>v;OEG)te%1e#oNXdElut1~m)LvD7}v+HmJE z`wQbc4hOB4pSjaEM6Kvq>7y1P%(E{+u7+rJg)@EP5u=+7(C##dLl}}|pi99%wmAOV+ty8c$>PpCx zy=!KNb~YN%dgdi?<|C6&tHU{?UB9XwPU!dB{?0kida5DgQ_Ip_e3!Rf~!qNsqO#kvnv?l?;mmTg_AkF+COOyp^^@gMFInX$ZRQm z-P|nC7W*N)WA2=3XQhuMK57d7C?mSO!P7t2M)5FTVmj}>*O#hR%=+5PZ~rHoU7T&3 zvy%CPw?fKhZv#%0oH1A}wEE4u3OBR=|8kH1z2nOf%PDKUb7M(q z%uTo|u~2oU^u?EA2fy7|ab`+PT(scH(+?kJc--0h{=)6w9a)`^U!+-Y>fF*7%XY*| z_d?eaoy*;e9&eeJ>d`fQ{e6Yc9b2}Sb2t^7T=G%S-m~0T%|*|5f;xkgw!iwLCmTJP zwf7k)8MA#l+51Y_-lllF`|P7`obz^l=RD0H8mfEMUsk26a-Wm-qS^b7ygQ%4!y(DR zBKK$M2|L3(g*yzT_MW=^soTfHaQ4QW_(iu=kFV}nc+FxBXXLv7x6ZmTHF7ku2y@n} zI_7N zdrw~E&~%B~!uF6QOIDfk-7Mdr_?xd@b8eP>jl~@?uGriP4-O9#EyeG9S%W4TcE^d& zxtJyM#+#X4O{jO0dFadQ2if#gI$R3hR~JjZIlK7WL9N$zJB+THe-Ehm`i)QF!j1o` z6-@7{KLji(mMy3`DW{m(=iusL%Muv#)S1ci%Z-xMdpj4buwj4lX}6rqox6gW!Y)RW zE}T;cd35)?*rXe_+xIoc3LTuvaeTj(s^`Rv#KF#%;Tob8mm) zoR|rH9XG`Cdff8vwypalE*0M7>G{cTY0!ZO2QvGZRhCAZGi>_3dRuLihaPXf9K+7d z744I=%Rjrt&kvkemi8;>$JxERuUEuxs#yE*+oxZ@c5O+&%Uj*~hkf>Amb}cjPi?V` zatf~?W|Z?Ubd)n7Wn$l~m9bHA&b}erj+_d~E}L258=PAioL4nr$-2^xiRz}d=I;I) z77opmXYD$9VeOv7C$8V`U%DYYzk0@+Z9zE|LAjM7c~!x=RleyZD#lh8?*3G7+#i#jHS~KI!7c;UcRwm>io`m zD`HC|CAu_J9~ck2HBjKh<%j!n%zIW6bHjO=}V>FXQf7gt1O zdV;oWr@GlBI9iqa*)1ptxjMh_;Dn5owXu1=j`^NerJ*ht<`mRMySFCzX8C!YnVA=2 zZxm~5wz)NFVvKvCr?Hv3ilc#+r}I|U9ji>G1mVF*-E{&wKo0#e~4{Sv+Skn zsGiiIZ@C)(53+;MNtXWy*=MHtf!H9$V8Mgz%d_l)g4=cdPC5mwD~N0s_PG}rGQGxK z(#3DNWzc@J$cv3JCH8?^t32c?JXGAHcj?DGQAz!;ne=1-3UBR%4+<&&rPKavCjAcz zUu>H2)I04eckF+~r2lHkAVDkt?JEP!T!L0BnXj#C+WX|%p|b~e8M|#v%02Y%^T)q` z-t^BpZyI@H?dHpm9z8sL?zU?3|9|w0x7Q^dgkwjGx4-Sh13{O}5D| zG?V_nj1nkqs_tZ9VE7Ln_Y{e?l$8$SC^+%|*3?-mwk({xWWlEY|L;!v@PF%(eY+1H zJ$Lr>e}j7W+EpMa z$Z#jradI5R^(EmS2K9;eaoX5bx553Xl&E>02j|@bP z72dhKaK{qwTEANtE)-V(cfZBF#CccI)phUd*?zC9+j`~yzay7s=De$Zy7YKfLzxTGii!1yg)g!!vDWgseLCMOxFV*lhon2p#d& zrg^Ksrdh}5g`HYwFCk#$rCu6(s%4G>ujwuIHI02omxisr9430F@b>xdzOI=e=LL-P zR31xATCbQ9uw2{sI`8F8{*lv)o1Zg$zi=^tmBrhoiH~ujNCyMMtEv|p3~JKZ=Qk}| zd$nx&=JyX*PE=57lumV7B#^Q~yI1+}*M70hdN=v3S$?JNo_Rk1qF`fBvUQOPmmt@< zgGG)nai~d zyqZQWM`}w>39;n!9&~UoNC=bIY{{x8!*=w&%#LN(R6OqNeljse(KJ+;hi}TG$3kgU zR;{0po!j2Ep-IWv>tp^^fkiDme2uR?``Eo6?pgTwTzO-6Q@i>nM#*E%J@yLc^-WSf zFzl;}sVLZTp-|tFLGik=liXtqt|wfEaj_R)%NolH7Qd^RJKyYb3ZK=IMH2$wM29+* zeR(^n?#mwbiHUoDKTMN2{=ir7hfj6o+U=aqj5}`gUUyqt+Ap`D{O(nEHic#V3zjJ< zSik(e-$~V9klpCXzs~k!?RD~eQsK)^oG}aCuGA>+79Am@W_{>GfVf&<{|7Bomz-xm z``bL8u|0lrJk-S8b=moEGtQhixMYTXbJL7HTl_**Xq{z0VCQm2mJp!mql> z`|+HcYs-%p+!KCyLHOZeJN?|?t^5W&?1Bn{%)u_(zipi3rPj>YnVi=(L;jU<$Xezz zI>BE(RHVct&riLs?i2&VzbZ+}Ngwab z>Fqq?FR*d$WxJjhab*M7N0VkV?JAwI@+jYfg#)&OiSD?9cWuw-rQzqy4F!AqX2)f=UpZUqR)8%_- z!?qc}EkpTMF7~*3V$ns8*sW`YmDcX{+IdIaY0HVNQ#lq)3axv`wW_^%_O`(LuXH|N zPbuBE`tsVQYjJ@_Oy&Aa6UAoQI6jGBK5xA0xTovw3%BO4&TgAK#k+UPT~~?qT>8Z! ztEUyZz7p@bJ2&Jcq(!>iw zk5|~mazx(Fnz~ENP{!rPWf!l!mc=Wkx?R5JdVTVQPuE<$ZuXxkdfIJP8gt!Ul`&fI zz?sEPuFBD#U#+kIxq9bbnfUyDH9tQkAD*r+9=&;Q-z)iQC)cHgt7?}O{P}VG``NFK zED|eco8*43pK^WctlM4^Y!8YL70M>R&suHJtT{*Zv$CZ78bRaipW8m47Er5Q`ayPH zq~3*^&UX^O9N6Z3x=Tj?Sl5Ts9YO^L>=G*^tyWL{ zDLqL?;P-_uZWkF~!aMa-p-ryH z{cmBDit;!tqFj=1ExO3Jg-wAe;Kj;gk0b6F{cD=|ckwqq6HOk4rVJ5&W6$sZ_q2DO z*=W6X@opamj>9ajk3JkX{MJ(6qqJ+1@Vq-SFN#!MSCBsHsJ3&G_@(vEwO4M3E!*IC zR-^P>flg)Df(JjomoDN6s(F+9{?Ot-l^F*8=`&NdS6q1i?9TD~uj(vVj-Q^)ecPZ! zxisWy#nOiU;}Msa{J1W}x;y>WP4ifeIB%a9(L9T0rzCHWe*LWZ&YG!QN6#<05ng`V zOoY84WmWb2eM{HZzN~t4Z@2#3Zy%%ET|PA^o#;@|4QM?%Wy*Hh%J*;fe)roKp?Gnj zo=S?xzx1k4eEZ!ZuzSt!80{qo^GpQPnU}4el+euXIfrG#%*vyRE;`v? zKl@iz*Zu#t^xH#O87VnAsh#XDBFo;N-7tRw8_VmPizDnL*M_-2_SmW>_4)XuEF-BM zH+Qd4R8abN?!)@yzg!O6T{kJ zk(;c@>-FP(a&7$HD@-$I&D$~iqa*8+)%)hB1-0`$jGGkly0d%DS;w8S;nHU|d8c}4 z&7AxC??=&_hK7dvlf0I--%{xR{w;U@M^Eb`YmZ(P2`av=P?eYvn<>r3@iP9$iskN2 zPsE--pFVB+^mjpR6X*Eaf3@lVr!1**->_x1LJI5IuXcAsavYmKugo&=q&Uf0eGj7(A;3;j9k(rymzhrEw`SMXF>q+PJ@;9=-Gd}OzYWv&u+nY!) z)ozb-pU*G8)dM}>dtaWb!0Wpb>vg{;>LBeHX!BAg@?+&FTaWOR=m8z z*4?-xSL*CX)5jN8BztY2{wS)}@q4tFi?e(wG4yY^h0GplgPi5%gg#>4G_ z%Cdf?CF{f;cBBhS7QLBr;w1C&@9!#-7qr&daPWanSI=gFEdSBN~G`gitG+ohsh_HTe_EKU-w$JE_vw{ zj+7Ikj61I=rZk!eAG&qo?W*9O(z&bb&nQcWq^WIB>=3?F{d&PI+ji;AQ7x?}Qx3!-XJ+v-DKyuRVJC&RBR1Nwx^*aM~ z*w<=?FS&V;ZEFsb(QG-BbnBL!Srex%(cy2C?m48~+3AHD59 z+s-L+rn0Hi4*b|Q^?AUftfv->RX)COxY)|q%eukf8{g`x)g)TkpdoSw1gH`XYnGcNsHy?gdy zwj=^1leg?b+|>VK8tn#szvuo5w(&dv zPRio`_j#I&F^|xLpI$%M5}WqwKA+v!Z`&UgXjA_CLrvIwCLiIq(-by7f22`&Z;Qaf zDOHVnk8&!X?!U41-Wr#Sr#|0q5`9%(d9$F~H1+jorKrke*1IjLTUajp&*~Je*wV6L zio$lw<-0?ayyLfRU+()le0xFRwBmEZF8?2v&e?Tb?bsHU#AB6u9_vdsYV%if<=v9! zX+M1N@~iT7TNEZ0tFd_3#&>=(nb_yf=rTjV=y?yz*+cv1rL(?$7~r+-^ORq6x!*P{ znd2RJVACb$3(HscuVhm75fRawv>t>;=_9z1)dDFFfw`rvHCE zabM$cjp>irbdH{w-^1H6CtlXaB;!!t&Mslm*SkfWAH0#S=!j1IlwX*-P}!Wv^Hp9B$?_ReXLiqr#)ln6KN{eYgIk? zp-pIK&=k*wJqt_RB~EOSKDP0~;-J)N9}D*O>B|%}9bh~heCYAUMVd1LK7=;~n`(!0 zuZ)jw@Yoo6|C>rV)A@%Sd!lzqDouIEvE1uuVqIpLN|W*3&!*4UJy&{j_0**8-T@kK z_sTj)v!~jvxM6nof+~s?vHnaII6-gOE}kqx*-l7=$0*;LUrI z-?_qR@1l%X%DnO2GkO~y{*4z7e7V2*p4OtbUwQql`^5ira`5UN;@cj^T5*Ht(8H_$ zg(ep4xF;y*clCpm?I%%BbEZ#glr0z@d}KSg+kI#E9S_cre}CP2$QFF|^Bz|%-{|8? zvsW{@Dky!=3aQQe_#=m}_Muz9!GX(vT=Pn@9=S)Co^+U?{dN1w>sweK{?=A$YxLe* z?XJfnocXu(m3eX6j@`+Il6!3!^3T??>K(fwhGoD`h>es1J4FnjASb7&s3rzmSGD{U_$9w_c%ZXD}inc`-f?d?$H z?_3__Ca*28%AyK7o#Gh-!(#@9w+xK87`4|+ShuJI#Te)LI#q|d=lVD%I$1OPXAr0t zP-jr*>*r(m%wRWDIXS|**3Glt##>QIk*|}VXDW}BvlO4Pn0BOMk-Kw)u5YQmTZFB- zoPnGwhpITUe6)eJ8oQdZkg}AglxUnN&nzC6%Pc}gLQOGV;)2o{9`-`zLL!+W?AzJH z3XE6}vdS?jyDJ*29T(wVz|FCSlXDrTe6N`PHmQ!}fIYow7v~k8ot?j`GHPmiz<~*w z@=HV(mPQ?&0y>H1#Pr;ajq%&tQw~nbo|6;2sxJP}l>Fl}3XV)KIyS5P_?*fU^J-2m zsK30p`o@Z;(~Fy@6vuDsD>=KYZQt~Yxy=Rl7gnZ*`uRFJo?Fp%Yhz!mzxVmoeHl?< z7uQY9ONhF^bLQoZQ%lkkdTNWWY?*m&``pI|7B8RKRGE{Wo{@ZG*P;Oe6*rrtZU;lc4O4^M4>bY|C+^ZTwI*mh>e<{L-%?C!~VcKN6j8%vS3PL-R* z!tB7OYkOXApZW37itlH({k(kW-^~-+ZeFUZsV*r)#iPri9ydFFZPsmH~~ z1~EwkYXIT z_tdNe_oJQh2PdZOEAXk#J2Ew`c_Jj8)Vu6lxoN){=-Otm(K=36i`GOQe_cJPIrsmi|Nme8 z|Nr;@pa1`p{`|dp+WNu&pM{@3efo5jLBx`Qffsth<&g`_d<>2Z&KEb<{@=Y$bp7u~ zZuY9irz|*xpE!6ZY%AB`T)JIAZQ&2GB$X+ZGD&NT>mJV8+AsgGNFZsK5xHuR2?x>A z=-?$$E3V2P-4qlZ8-0I)*=Ej#Q~Cp~RvpQ?rLpY4sc_qp{*qaT1bmP0zbiCLY0-n6 zbw>i?BWw3ueYb`4y24_kr%9(wc+FKVz3l5Mk^NuhAI=i8?eoR5vNH2;-}oymvW#CX zeae}sy#4n9hQGO`(dKKKbEX_V{AIFVdcV8EnQ5V0CN_WEz;`7#cH+Ym3_CxWt>J54 zrI5Hx+HA3n)Uq>rOV75f{`Oo$LL;$-Iuo3tja&hz(H*>g_rS@EGKPG%pOOLdlL zK3b%Fvf%IeXNxnZPxrqy#hxK`Ugj<>0|m}lU%`{7x)c&5*Uj9O^e0h6JGwn-)_%>d zeH=FX_Hn*A9LRsjpkAY_;L@B^yYJa`=`|f$D;y%Q%sc0dJWu(*)t142u07h5a_8MW zS2e5tn||61{iOQGFV_~88TSMpX?1rz@kP%d-sktvrxTg(tWXkaP&jbL;FP$_n=h&} z8Z{OzKd8L-FVDJsqm;lyhL99)~LIYd*3cm ze7P_C-4pg>Es-fTlHaWK=PW2*s6Xk<{x`jIzg-daT*C3tyU-ziZ{F8sd---Ni3uFu z_$uIR$4lKhgREk{c4MbB7bgx$4u*zzGcsp?QdLw*J(beH^JI52ZF6{_@qH#S} z>u#^ve0E)Pi>C{3NgM4Bwde{y(&SXB#&;sdR_aOY%ywn=#U6^2CK?N+q}{MF-BJGa zA9H4aTvw`|V#~z%D!r!7dV4LqF02-+{{Qjua-n_8JJL__vtKV@{K6O>euTkTFL=%w zL%Dm;`{nP~|NL-nvCWx-*Df#j4?o}D*4@DWvWuth{5(JF-&F?ZXVm@v@b_=Oy#4+7 zshK~R)?3Z~T2r_cLTW?$AH^!R$azWoyZ`!;6|zghp&)#d!hy<)SJ zHq;jzDZl#^^k(9H`T8IKYW94{_`x)P&YdR<89)CI&br>8nH?x|puX~-)@NRiXHK)r z-o1-@KV{NH&LCxhKLuJKpaq(T6Y9*3a5DKhA#nRr{+4UY?uAuY9I& z;_BG!+q!+-^TdxVJg&bp>fM}mtHU!aFP8mXFt5*SHdD9Rt2uvem2v+M`O>eL;={wS zb{gmV7aR09_^7I%wO9YO!_}@)e?Xo$aZ_%|p>uOOgywl?M!yPAlE8-O# z`=5M`E!nyD`}?5xGVg&AlO^`La%g`M*y*vBt4(o^C{Q{4ev}Mh3{lxZ5=I%Rr zMGM)oyAAF;W>kHX*}55@7iJ8s_j2p{x#)s?kwYq zj@_Lf?U0aZvCHKe`NsF-E++Cfn-?(LKeoKsf;i9M9xw|KZvP*6G zJGXp(f2Hf(g~CcYMo$B{1HQBhJ=iZTa_=PH#@^-Z@^&(IF4{$}x3SDSD0_YGoRb%x zmsrf%qyOOhuaitmdAd51G}?j+>Rk5w8w6G`+T~SC$9>&xRaf`&t-{oM_xDQ+Y*#4x zTz;HcQUB)p$-!PeiacE%(u~{zQzCrSJ}aBDKV5e_)uHT7gLl8(rRv}Bzue2Y|K)SK zL$r142Md{boeQ3byGj&D@VU=G#R(U38Xe$88Mo)|ww!Y-uWK?5QSDRF|P^ zyQSB>ZFcTv$D)rj6>Ay)dvlal9DZeHy84+=rEK7V1NjFg25-I@qqo+_UzoGiLh{Lv z#>CxnQv2L*%w|#O3l*3#{bdA`%*`aT+2?{?IGOjKTz=|ik)X=Fh#9?|oJ>#G*Yfku zzb3%-GhNh$sa+?%_<_c>t3It-t8|V8d5UGHPFQhs%OdZ(mJ8E=uMe$yv$8|r(TuQ5 zt7hp=JH0h&uaoHdNRDNbG_RF-8j0n3otdzD$(6(Di*ny~Pu17E#<}q&$MMUNQ!TQd z`m`#gMV!c&%0D$LY;~iGWcQ0n(;o#NOkGtMxq)rldo~%%{t3$&6pu$l^exNMvM|a0 z=G(0GETUtn;d)&G&y6zvuBl3#o{x%?ugknVm=JzooBgMP7Z%MN=UuH79u}x@{hn;G zrS;XEbrDybb&HKla}ym`ubf$9BQ^1G%Il8DeRnD~cCogbv!L7w z{guvrF2O%pw=TPy_FVeGg081WpFT~!Yjin+aZ%V6uhuDgjep-cdtBe9{Uo|e;EhbA zQ$`QlEY3&5s#bnia;*o~kq3Nuzh_uR~6Ir_{3w#41(!2;4B$xptnRdxk>O z@%wXTSj6MtejM3OpGCy+Glw)^Jd9jw6O`ULZ<}Pi86cP89w8!t&>v$hMaSq;) zti-wYr?Q?JG zwOV`6H9GHIHYdjFnHirDE1L?}b(uNKUMTeN%SRqanzlhPQ0|zizKN z)%h*EdjIoxcJ+Msl{t?}2w2#aup8W~&kDL%|BFFHLd3{gVWm;$q=Jp>HqMrBRk}0B zcbdI@(cbb2ezIke`Vvc*y0fu2PGNAm#$I~h`M*CuFN;s|pYM=7%|tQq=HZWXc5_Dl zfB$}U(ndF{2RsL3_HCN?cth>k+R!u1hh*gU*Z#S5W_$j92PP3E#mT{10-ic2%N1Lq z|M%OnY`buW>wt7)F<%pja*l)B74b(8eTp4=p_lPP@Re2m=BCMPB89|ph=b@I@@ zj*~X~){8NT2?V$9y*Sx2rcmj{^fQP4skBC)_}O}(&^a!A{)vT7aedN3DYZ)<1vFn-gmY`}uGRa#gvMvB+}n2Lr=;ywubF4Vy+psA$k`BTdi0Q7r|z~@Wr^$a z6t_=^K2cv>c2L@!$DPsUzVWUjv*yb#UtRHo_1GTH#;40&&~q;}#)D_^Fv;LxU+&-UQPLD*RPCQ^>d>X^>LUXRW z_hj~lWfsv*A^Wd8+x>PH5)I;KERC7Wkddo->lRx@fIi1(IhO#BL*hbwOo^`=7@Zov z)f^9hbTC9{Lr52EbI6hHe2I6Kx>))!{4`z}?!U~3k>iG+LdP19AC6zHu2Q(7mz?!) znlhLBr>$q1HwV3PP1|`;;bE?W&UD6vJEBV-oXO137FIa)lt;ObW(t9}DtnE7PdV)%tG9vgBgf9?0S4iF8@s-| zTvZ;OQ^8vKGblVmQjTdx^6V)cBFj(A=Fkqdx?Coqdp@oBs{FQyHIA#cX03QVFQMm_ znDNZ1iyY!sHtl-#(rEVQHy?T@@`F^YirU)y?Y2az?B{u>JFH5&!jf%m`6WdQn84FO&fl^aiQP3IlC(1S$4*NOQAIbh0iEbe>ldk?Co_ zqci39veK!!A@L4YRT1v{`ZCVU%sVzUyCK%=$mFb(({qzuZ1(qOEUSt+H#>h#ecZu` znR|NDx>Ec$w^rl+f@;A*TBVrLxVVm>=7aA`4Un`VEc!<0nt zJa79VFWWpf^Jr7e?8uPm^<@j@%-+3lYHEO2aA<^qdr(4c_y7O@S2g66G6^76sVVyP@7QG zl~CKAP}h@C+kNlez1z2MgSfTb3ANp)PMtb@`0)A-8+Yy6<(F3I9GQIb%-P$wZizd+ zie+G6XaFxE63}q+iOFHHo_*%Y|Nm=Vf8Tyfp$h9kBjA2MMa1#{{~LD}&i(&C;QD8f zLD#QezrImEbPEFmr>ZCT(u+4&t|q!F@~}Nb_g6Uk81rseEBSuY>ua{X4g8(j zUrnNGX3SkF{_V$s?%f%3ymKPdR2O&# zBvs$iF!ubAG0o!uBU9g%oc4~HQn_qOM&*)cemq>kq39RL&1*PMN`vFpadVeFs;W+t zq{@xd_dE@ldqTaw!#dvY-P(AgjL^GJXN7&fkSEf9=)<>FFVh7S#3r=tdT~Ve@%Q?* zzS9ez_)PpXf6}~~oprVa^`J1t&tVPgnH0T_ZLASk?92LSThITR#g<0S64Uw*?K#WRG3(O4%pJmuCc7lP zZ1LpRpSb7uXZKl0%I^#4Y=5>OV%^f-h6DVcibDjZ9}YMvx2I&OV`!bw2TeN;kD!a9 zvyxs;3_J9@Iqd2i+*u9Xs(%B%(vg; zb_mCwv?~WhOxt!{DRi81`I4nqiGYer*ta`aOoURR5pmL8eGU$x_j(u_=7fgbtA z?EzC4MksK;@;S({oZoU${;WwwH78wXFT3t9*!p&X%cHJ10S>354)gC6pE#a5Yr&Hn z#}zN06+d1y!T%ALTB7f3_H@C+{#v(e^iLPDc6{BLUbZ!ITBVtl(urvKj;je#d0S?R zeoQem&6_6e%eirVj^M4l<4?ni7uz0PH+y%&+>~X$UA^-5K z=Tlv~+`F&Xb(@@b^w48+{8y$KYAOG)U?00?t-{a4;^k9p8>jF+abDn>@NQ9>#`4?g z#`&sK&mVd7Zd!`*+#~Dtw9Wlk&OONV^i$e0?^&VL)NfA(lcr_PTi#{MuwasJx2D6)a*8{IRMqT4bpLk$mu*sEF{T$O=&Yd^fGJH&nuO)42YZUu= z_v)S~qn9nZ)hh)PR!{NfZn*PCnxpBSNXW0$yViC)O@tUet$yv+qV%arBGr76&#$dq zv&`#Rn)a;pdbIq-clOKTuK9ew@10J1*|~n-Pur5|?Agyu_vWtOFVlbh`tirpYhVB6 zyTv3T$g*(WZ{JIDedSgj_2=DUqDvOXH zM#FQ$^RNHjWUgzkxN*tMW2s9Ei~7Fo_|vK_%|PHD4cctZ11s3sfm(d3zm30&RKmg|M_gCiR(R z^twQo(^C(g()yTxp!vKo1J_c2W7cg|39YA!LpLP;6?Ho$(&*v7*Z;iuo(mIgIszA& zTE2ESD3v*=usJ@CyE;l`^-+bKLpz z{`X-=$*{N5m_+`&Cj8%?B^NdEc7TN6`@QP<8~P2>dkmd7v)tOaTsm7OB{;{5 zM|M-?*BHr#F$=G3+!ws;)er0N{r_Vf$`&jBIhv4}ndul8eK~LYtq*A%UhKAaX!`fN zM~315@pGR}WpV5EMP{sBr&C_{<*9hh_UCi$Hmcf1M@PrU^K&jOIc)5@hqt2GxTXL4 zlki$|-h9zcd6s=s64p27i3HzzJzME-s2BU;ci9b|Gmk11T>h}bDa)d%iK;yLCTtR?>|0NXuV39J55VKdilU z!pL#eq~c|g{+b(}R<2F&|HsH`Hj(3Ts_Ukn9=rACFJ|*g%gp?9jNeY$lUK>5h3ycR zSnz`l@3&4luE?seIzmNg!=_Un>KsyXS%0lw2wY&$+GD7-_CRC!^Cj;+`KN~Nu@q(8 zl=Ca{!keBy-wpVf9yBi4!gSK@{^wuow`nZc)b-qrW#Wm2HTR#Gybe@7A>71M=yv0y zUZ~8!ORoZt?h~A-6eL%qvH1J!3XVl9S4|R4ixTy85_JpXE(;2++9|O7bN3vOO1B^F(7e75oNxu3uFzIBvH=UHyL z@_Avk`AXk_FvfGIPWgFWo_p|V*QKcQkH7uBNxj_PeG*kJzr$dP~7)6$JS z8*k1P+1ZkQ@*Usi|4TEg*yC>qYg(pvyfc`4vU5o}|MuyZGR$O+S)QwJJF$~lkV!Vb zXWrdongx}dMh-TeT!$C0nYCQBQ=uqXZBO<5B^@cdPxJQA*&*_ieR4s4LdTk(iR}BT z?{?2ndze-nCbkoDg7R+Iw^O#eEjy8`G1P zTzwJRXA{#g=U&Wz=KlS*AD@+YK8~rL-r3&Hx!(4<-VV85pr!x$K6c2BZ7ACZ(GJfG@Q0{Gk@AG;@^Q@fbxLuy zjd!rh^L4C?@tBYi7-MId?d5P}a`xrO&GFucCT7-!yC*nXt*(u2Px3u5A!BAi z*s`jaPmm#*jLYndoUowAXp|5qBzjs8<;nSLm6jX*#JPNZZRHOT%>X zky_`HB^#v;7ag0Ba~IMkQAV`Bb_X$?&amS~tx=2M-eZaU@E z)YRj>iKlyFd*{!|+IVcr?1>ttlbf=uF3(O{Kc!-Se};<5^z7J%hl}I3)r7B0u{$^+ zgHvZkXF#B&&U9O+-nPoZ0~0bdOeg=yXI&8M_&<+fK@CWxX5!Qh4RKzcT^gp7BLZ7@ zcBbs_&j@!aRyUpezntNJKEu)Jc~eS~)|LeO-1Gq5Jn zaX5#1jN>~d{{O#2+%fL|!3`i&L;fX$sQ+1y{{8>o+X7;L{`dd?&;J@u|9}7gUHC@*=pGu~3Ni#6;vO&9ASC1yL8uGAQh%`E8Jzw&7zR~uWrZ~@s*Bf+? z?XUlT#x(aj|GAw9+h=@m4Vo{1>V*2{pNEdB+C^^HsySKpSjg_I+4~=DKO6inzWq5b zGA}__r0&GQZ`x-k%1=vFo9h-9!N1{QWcKEkM&Z|MmAB00RxiBue@5Y==3G0iIVS%% zE^fHz|HxyaXvq@OR-=$Jn$M;3s!-s?iu7wM z)LaraychU9d-I}YhKY+l&kEJMe*139^c|<_Z7yZW{ag7fM&ke5z2A2+oeBt;*0Hi9 zXrpp$`AyrHt>y3U{$0L*MZV{X#vuE*#osl4PO^DE=ZTBe%tbSP2-d`grAG9L3yBne z^?dvI^ctSe%CpaP1Wnu97V_z8s>P0&ps*0%^X@mF^nY~Nx0i+e=rWPmvl3p7X39mk zDxS}Y*W0KQB6uR}nDC4fhT*xB-ajsyk>fd4XYu*O6IC;PW8V6`ojoJ^ST14%9v-zsqw=MRpCi{SNX?og zuFLo_X%g?uN&DBQUO!W?W$vZ}2bS&#xqJ3`oywv=HM|OE`nSwo&!J~0yDxF8)oH`< z(A<4J$2Qz7auqlJQIb%+Xi1S;vEYd-Uw$ZXERMUZsx7SK%r;qPYR8uoXLRPs-e1FU z*!7vh#0;m_MZymiia!e+`q^5TCAUdqu6|phf)KloTES^H2eD}h@#e?%_MOq~GW9l< z%vdPF;d<$mWtU>(oqf#gySn?gZxE0^vL({`euUUk51u=lB8^|%tZ!F~ZFFAy=&|m> ztrjzR`>3gMOf%Qd+9f1da9qC`wx#m;s|AUu5JNGPb&2yG;`lLC}D8kr2Fs4K_ zP`af>VfDg$0<1^fO-mLmv(TII$o#?ot)2YaS#9t3*2%dYb1a;8-G29`?DBz+ z|NUn2H264rY&s$JrhCSte@7fbGcM7+lhaF@vKIA50jdbO0bou?^G?Z>yx1uLop+5L>yp8B_L z`NdZ}SLTSgIhb6}C+4znw?YM21PMfeLy|nGY1W%LPuz zhSa|Qc}$Y^=U09CmdNSu)6&WKAQcs_q_x#v1E6bYKaX+^0E`1W}uFvW)tzg2>m;HJ7 z-PbuPD6Y-ly<))})sUjIY3m$(GTOA&Zm%s1DyjAA)(@`up2h!YSF@Ui49ng3mnI9D zNfdOuimyo2th0V)y zj|nSZnC*!T?pU1B+WvY~a^$h3hYKI3aBO*>M-i}$ZI~J_Wn4bE`fbai@i<{l&&9gPDcyx>Lj*|TyhpE$6 z+?JpC#d2G&-wLBbnbWcLpZ@&3d|cGmtYb+MC-cwR8-4K{+;gsW`$v=rwy>-@y}G-5 znsm{bi_*yje{!IoZms`N+E6iHvVrdE~$4vw3XfdHAB*{?>BAaHj1qPI=@O zx|tfqzS5n1VXA`f$(SSVogb9t=7uyKUa^S5O(i0$z)4ES+2&W?p#^zvrfhi+?%MRN zV>#U&=X3qMc5G1P9Ov-BH@}{*ZhYtDum5L{U!Pb`ddra;m9qRi>9=ccTCLAB-w<8Y z!Z}Ux`=@6%J>l!)_d8|UmMxx|DBZYr!j3yHOPOwEe)p;<3|ZQBwzZ}unQdRi=Wlm^ z^XJ?2E$!F4bpQFU8Kwshv@uS*oBcjPVeP#m+tMCzCkOd>%>HUuv$ejUpkT*;uGIb= zwgqjA#8gG=6PMn4XIkDa@-|FAT%@Asu+XZVE;rsDk*oQ;t-7S-!#C4Cn+tBv-oi3> zg6kZYdvWWY-&(tGmh9$-dDd)s6LikDmL16FbNpre>A|P%4>-52+s!6-=+w4g@2Qhc zW|hU>nr7&6STO60hxL2y{}-h{eEt3I;zPq4=I_ULcqJEI{ruM_QizSK%$Mi%V~N~n zwXfuNzOPVVcfVV{KJLKG!e3q6Z>-`tp?kLYq+Ykh1iOPq+44^w{LL;p%BydtQSynk zVLjtU73Qs8vpbmIGF{;Od~|jB-NoykUlpAaocy$6%IlX?WbWR);&?H|vaP1E_0kE? z?;lQ_R^I&h-fttd+3PfuZv2waGg!6ay7Z;;eeY*}`LUt;(=*l@gMYGO$(xs!wqA)c z(Ggt1t7jqmWY+g*hc7-npj2Jx@Q?59&!DSZ>rdR;S-bd!-txK>-)Dzz&ti{DvXzNw zkuiBPnYXg`&6g*O4(?ueCVSSg@Ab)&Ta8=~Ipj)RF?jvlc*=vv=_XG6vutbs{qS76 zVc(7G|1C^ct8Py;;F>Nu?_hr5KJCe;N@9K7Qq_WIEKUjjyea%N&q<>_;i9?6u2wP6 zs+)c=|IOm$AAeum+ZlfFf#iL^kA*WL_qseeuK!Z`{369Sxo;FteVVDj!@?x6Pw@bQ zqQr#Mzy}g7_Df8iUcY(z|NNoGH7iyraW6D}xQcm6!0Zzz1q5EsW(b(?##=w}+KFvz zKJil`W7(ydA!bbX4GzS}i3XiaQmXq?p&`~K_x<#nw6OJGKC_pH)%I(0 zH2m3hDePD9i42yz4rzJa?X0=(>-SA}d@DOQw!wlsI)=}1_4mi?%ir&sx#p92=OUNg zR@GH^_f2}1(AE3N^2d4QNxlo~d?Yj87qeTp-D+6DweR%mTd)3F*%(=U`)Cv&#_685 zUvah9o`|B@@;%peQ%ihip0H5YJ+Csu_#(@_lufm(%4;UnR9P)t@#$OA-jc{&HpWJu zLl>1B|Gd6_QP;;OYpy-~CS)U+)D$#LTv$jz+E}UO8?f?P&xJ#<&3ruh7Dy>n{GvWF@&CNthn-~M9hk?@zgGZR1B z|6i)bX*2ua=RW@<-6zum{H^%De&{}vTzgH;y5sHU_L%GC`yQ{C@;(3R>i!klM)?bj zICajrarLlk2mPI3H@k0g@1w6bMZejxsB?4r&OW|lBFDUf9&@pt2v4CaZb}t(ahJPR zZJI6{c6G-A?M*9Qe%`T>gEz-4>8ao`Ue_1XX8WFu+h~`}CNf7S^P5ecniKPGp1Egg zf(32*(}UwS-iwJ`*?H%|*8@|YDQ%l%x*Xm+r?z-``R4Ge7$)gR;9gL&2X< zM~@vncfD+q_@29-=YoAcH5t9pOxw6h(rm@svUA(sTAsPNE%$!jmG9G@U*G<+{%!oT zM174e$)dRj9a~e{TIvq)NwI|YN}4iU=~}REAES55&-ec_r5?W&a4+#l3ocIOK5+Hg zwryLtmTPRf6dCAPzN74Kw8ye5SMDk&vAYDYtPQ{Ps`_7NDIiZCz>N^7aPSh`TcX(#B$#bLoR9~-I)(o7I^WQUCnA`X+F4@Xt zwfb{u`S-n>94r;iUj3~g?_|)T$@B9~L(l&3?F@5n+`6~%$D**7cWk_Qon}UVV}C1D zzJF%Wvi42W8YSzLovqu~+->Xo(!Zy}L`t+JpkT3wSNJ!pu1#E`@ex#^Db zEX7js903*&?wkn|E^?H4TspJc#yaIHQ|8*;3v|xyS~=m~bmk>?W*+x;^B5VuNuFH5 zpmbVxvOIHX)saF0&b+BU6IzZmS){e)=6rLiN>zRJihHi(dd0P&I}IF{?0J%-t{~}| zzyHQ_k8Xy7+`XqZ-*%oLer4ajcj=~6^>QX$+`duL&*9mlV?x3?r^UC-Q2bi)RY|Uc zDPL}urkY3KBMC{#Z%LCsFWD;{6+KI7zC@6tBg?ZJZEjq?eW|85j-{2n7wcD)4UFo2 zFUqL2DMxFj!ov6Ilal6~GBoo&-E5m>WYT4`^78ACF}AO*nXcV@=5dX!w(G*Nwl%XI z7p%*z{!k*Jcu)6&?EClYOxSNeGMDW=mzQgO^P1bdx6!lIp1BuTyIt=4S=Mf!6#kca zjZ^<@(e6YUY-1_+h!{&@W`K^RWFrlLpbU)oAVyB`i_cj)KhM`G$;Bqm*D=P?0+L$*)dK{mYv!FOU-Oc9g%)GrlX@@6g$2(dbotm?+FMWT1 z#@hP0OY;g3PR#7j3|w9jQQ+?!qN|YVWOiag{Emj;NF&unlX{);lM6zPWR1 z$Kr_r>QXiFp_k8`_zzyk`~Cm_ZL602`2F|u_n+T>{+ZEI8*Q%BniYTk_@P%%9^Jor z<@tkK-#>m#v@yJ}Z{6{2E4R+?Ik0xl_5Euu?OZaUB5&`iS=WzjIktK6zSXmLub6&j z*Xk<=HmvNa+qrb=;q~)2&T3yfrEz9g>&+vZK7IMNa^|FCdv`y3_U!zj9s4&fn?Gav z?5R_i&!2N(&CKLP?%ut7uit-o_Ug_14<9~$`m|)u%$}B}b@Qgqn9%q5@uLS1 z9=v|_>i+%vZ{NQC_UC_VeciQ77w=y=^W^sBZMA+MKYaNA_1pOk(|32o9h+0x1G@$cH3zmGotefs(DmfL?$ zJo)wP^WRKAyHn48-&|a(ATDL5p|bV<-`)5Ac$n($x%Yebz2BFgeBJ)=-}y7|jz0Z$ z`M~qL*WR99d4GAsuC*3B_qJU;v+>cH?N9f2TwY?dZMFH%6*fE9M;|)XcVS2F$yLpT ztKIjk_Sm!9eb0RPbth-t*k5^iaYgd(jcfPkpS*qQ`LyELNtezP9^c<^`bh1m!{sLr z-hA==&*v{&?%vEjwy*B;@t%vP4&S>y_v(c(eWk3!ySJ}ie(v$ZZ-4$hc<`X|{?V)q$aI6=b_1BE55 z)%x!J-#Z&*|K|Vy|F8J}f5nRb|NpJ|_kXcb{*RAeZz&vDwd?HZ|D_i;&ANB>|NjeU zOY<-MJNbXjYOf{BpY{HFocZ7A)Bk_}zk-kY{R=*%;_rX=nQz^*x-!*fMUvH*oHtsNuJBBs*Bo|avdz!HEmlDrpST5Pdz_sj zvA9v^6x+!}rPYg^g+de^l=If{D_VUlIwg=Iq%Qi%=9`TEd>3cCrPK5IubCB|K5#X+E3;LWHS#DOnVYB2q5MzwxGP&=y@5<=^<#^p8v~yy3Hh+C z%`7*2UnX|&alYx2`^ilOhVOL4UtcZR{6am)V%?o)j|=_3XTQzc`fu5Gd6gcaPz?{; z((O9mcE9}9esz;|5A(gl4U@`d=p8y-w&hpqwYy&ryHAezbneXYlP_y_#QZO`yrbqm zFSz7auNp^Qe5N7)yO4<%UHR|#7M+@QMW12L;zbz;-evRnOi{Aak>LKJGCMFRclYnD z_brxuKk{Ur-`}%;@2^}~pmNCdy!J8U*H?mdyx!ff&NQ2ML*U30*G{Jym8X^-P%m#c z*)m0_r9`bdaORc?-Sy>b)$iLJ_HovIdh-zX$ET}TSN(mKssT+EIt6vktbaCr#p~*`hZL?%5{c4!Igul8Q=RRJJw}a-syugz zOp%|L;t-v*)Mj=?_Bq23^$V(G+qtxlUs@F!u=tTs?YXJ<#aI^_v>f>tsd05{#FT`L z?O|;v0(cWl{@L_@I;>QD_R=nqq)#P_LYkL()@--*+r809;Z)%f0ZIFWmrljmwt9ib zHSF!>T8=IBn6fSEZC_rPV&;0@U3a8?Ea8=?s-SeCr(JXE%S!I+Vlt|BV7a zZ;GAAqTF5Q3M{^qpZEA-WWwZlqxj?5y>{+KA`J`v$}apXyIY~-%kzKd8ruUdKWSFE z_4nucs=CEhf67lZzw(S*wfl$KG-dZvCMJGEk810i{I+$rLTfH)q=nmXIe4Vz6n9)L zuDQR8O{Pn4--@{*X)go>%#TWDF*wQGT&Vi$qV|^cOahsIuO_qvuxTtYn)Bw2jX?Wp$Os0fol~&6aY!pK>qcKC&!q+2iBRspag@w$ENsAz&ll z@%EWLJ|0)H{vQ#vWw^Mv@p`w*%%(b&^>3nT)ujSn!19%?P_f|*6zdq4^5rCtiQD@0K;9X%e}yf6@;P+pXRFz+k5feQ6}uj*oLX}G$GuK$O->6tE!dnO zvd+fkF7K=j&UfcVuBZ-Q_extoAbr#BM$M0V3O)bYsXLy3IPbsm_NvmlUF8W^y}~j# zZ!-QBp0JcTt-{!Vj4ZgTa z&C_xv4Wj-3*JZ7JnRWl0WB!@=XQn}mmkM3Ib?cOoSN4*W-+e3+iZ^?)1&K!r@1&Tu{*t* zkuyoqlU2aAc8PmzF@6T)J?tG+7qw$3j8 zxqH8_|M@-HLXwdd9x4h87=KQXusk68{LP)3vxiEW1$aeQTB`KiXz5FuZLA_}o4jYw zzNk6zR;iV#&;BV*vo=yuaag^0!M?63ZS%zx1E#DwdtN_0B-!Zhf=ajAtel>&Ny)`i zdVSrd98)+ft8n`Et$FsTm6^Zl_&v@&*n31m@LArw898}U)!w%Zix!j=msh{+dHa&> z?4qX+BIe7a3GdsOS@q>w@Y!Z9_RT_)>^v)reYY-Ck`u*{=bY)`YT z*NlB!CmNN`8~$(0a8lQ)+RJ6JEg`!g>$U;dhdlELHaq7`vIIgA-DX1cpO z!nc`+GPxg5pYz6lyY-gD-okgRJwKlPt<&61-O#Sw>3bl3g+RU1?J$MWaz^?!HDt^V<;(t_vH4ju2Xy+y?@4DZ(t9~~&YuD8S#<9%no~+sZ|Neu_ zf{Y!@(^FDXO5RkP6gTdUG&D3U30s)+x{YJXv~-u3Q+1^7bp0=E*edVXR=uzGr;>ul zjC_^ra*QnVf__Z;xK!BX;*a$cWSS=26^>i}nydFO!x{xTZJYncX;&&*b2V3Vttpl?Tx8Jn`8Dbr!^cWSP!4kdKRMi_}gvm z?mz#!swSpJ8m&C~rs71^fvbx&rgQgs?Ys4Ak7%;Y+qpJrYdrpMzxaKj^EnpLC+-%#?!foW9nqWl&)ktW zv{7As^unQ^uOnx4wLP60I;GXrE?C>6^^m8*2A!$%I-@0CoL{IBRs1GzleZG<4xLFS zW-UpqP322XP4+DJxW!yzscK<(r%0je+MAmtRd41f&0O?i($b@?l`J=-@;Iy_?lx-J zoIG;D-DkqRd;eA%DBR|Yi~m~gS^M`EQ`4Du4jme=_<{pH%=cZtGwb{Nd+qmT#qQp> zsxsF1(uT&W%?9czt1LD%+lH>VGJokb_p-$f0&TV2b5A{#*<5_-l*HQ$_dbeEE#q#6Epn!-j;kEq^m(;n z&WQstYX2TCsCc&gqwR8Y^Z0$$-)mkU?G|6zey>cQ&#PTU(e*^X+}6pjPrqeavxec# z+kDRnQ!dJ6%$lTPpVU*(?J(_n7pF|r|Cp_84Jz7SfBn05?f82BWyL3DcFOwt2A$~F znWU01D`?`LGp>QXX?GlE-()CVe)Zn%$!Bk#y(VzQze!~Jocp3D?*})$=>1f5=3&)3 z-5sy5ha0G@P;1nXZVFF{yR|D!$<=Dbi6u-+;>~rRa2%3POkkdF(NH?$fZ^gr3ntfP z$gHuRVALdHvbWq|u7#W2j{d$H#fXxahjX|s0*lX_Tk4Uf(m(0XtO_kpwJqyzEQ`(G zUemq#KzYpZjb)R0EPXRhxY#s%P7*Tisd)2^<)!}RrF{wtIp#fm{fjrhRGBbWP0LIX)$wQJrT9?wvb|9?fuV-9v=|gF#E3H zEiazDlS@6$I;Lme5iXM{QqwW-IJYXLgDJ&*w?}wyU-0f-UZ2nWoBMj!n%5eW>htr~ zt*_*F%wvpMuz}l>BljtmVIEOcB8GXGHbIAZHg4QFckbMI^X9Ezzkb=WWqbDQ*|%@s zmMvTM?%lg~?b>C_mhIiUcmDkO+qP}nwQJY@{re9dJb3iz(Y<^39zJ|{&z?Qow{Ks% zY}uhhhxUNMs#U9I&z`+^@7{g;_U+ucbMfNE$BrFayLRpI<0np>IC1LKsne%VpE-N> z;K74?!QkA5i&w7SxODaE_U+p@Y*@c$_3D)?mT%dzW%usg=PzA>xMcqPc|EPoRRwu@ z$?-{{L1FGrK@Mh~7Dlcn`c8&=?q-I*R>ncjc2Pba#TltB)s?fROt#fhHIxxERg$q% zQ*hMRT(M-)_1ky4y1FVWD_dJzXY_Y@m>YI2=H{lPq!bhsxS1O0NeY*h zmCczmr?j-RzrVk?r>86@bNck@d-v|`?(WWvjhr}fVn#-WwkUskdU{q?){-Sl7A{

Q?Ja8Z(A;HYd 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

}a?7 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

XHlNc4<`l7P4Ys^pBesm$f>1P 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

BnI~AbEQBd%$zz=^)5T$0 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�@$J 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

1?P| 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öT1}*E&4-+Z*wK) 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
Xj>8>tD2_D~K@8pX_Oyb<$s)F|IK{*gvRG z-*PYyUGM68>bH$lcH9hla<_Hnd%sAnxJsyvu4Y>KAxMl#~ZAI*IiI3AHzTEoz@4&Ca4%nuqFJ^e;{?U?3}2Kd-m2ug5C; z%g;Rf{PWFvR;GN*tx=KlLQgZToo%R|Z?Jh*zCg|G*bP(f=IyuXdC%0h_^rjj*@ zuNchn=v|U=Ci08LcG>$p#b*VBKU=QLsggOpT>S=j*P9n9mMW1VH)AyII!-aASgKrK z_%wDkC!gR>BR*S>Mtk`W0zW=8@-bS-8wfDCe@Hv}|M*U=%D%}uU9Q(sLZ5^t7s!OS ze3Cr$;)w;%;saf3|4wViO1SedGm6|T3yG2labLi;S=Xk!FPgi!XSL*hu78J=Tla60 zS$*R4`Myomgyq7w%^V*{I=YnFQq;1c)aYfc=>>DynjC5(TiQTo!2>0X8-@&lJ(lo4!KuDvQC&p z3$$16krl656(N^@@c(u5=aqFE_io>xURF?1QZwoD%bS)~3!FBVe6p66m!0x`(l`EK zj+14DGcSwo)my-{>P}4TzcBHhJI8}h=$a?>JU_Z>Yt_?U&dd<;^Pk`6T4yUAIp}ag zXjSsssNH6=`C6{mOAYv*%edX6Uw^>hn-e{eB^jU4rox^%!-}T<8wFsVaUi!t!>*pLHHo>U3sj`0=-}!0m zua=K2TUq1AS;^H|)7#H09Q0dIndMtvdWIF(gND6R-|YOp7a z4q{1^IMO`(Ve#ca3)zm8>nHU-y|3TXFSw}XoUca4rRv~_0w4Ar_5b7kCCpcJ`M=`l zmJdpg1%AE%qCMfDq|=3sEGPcRI`Fvbd@)j(e6PFd;R~+4A|B;+#%HXiF$jK+`|B8V z@cSkf4v$}R6PE^P@Vx#pSC5%#(!1YDd*f>E&t9A?DWI#??79BBtj~mvA{-*+>XSR$ zrZNBQEt?>l!hX}SOknRFH_a!9b7uD1tF`6NrY<5Z5g#9CsH+q*_zPtC&y?yynk@lA6 z;1=}mO$qAXFR%Y~XAh|DeE-1C#eKi;?zyyczOSpp7jT>U*PT6UX0-gix9{ui-M{bc zTXuE(qdR*Tb}ayn40F%ZI}WYDBi!6VQ#bh^cI#y;DO?OOC%Teu`Fz5nBT&(dr{T?jSNSiZFz=$OMEuZ z_;qIw!@k7~`kP9P5ZYN+JgSIRya30E+sjc;oJtu5{sym%$K7f=J>nmJ&H~ohUBWrH^3Rz+yxbzLzf|tCDU%BtNDZ1hvv>iPIy2OHE z`Xi||AO2s~ynEc|^I1#r1-Bs!Ef{9Kf;6R@xAy$MXb4(jG5wSGiroxTe}}AI4{1u< ze7wuZz`*bq+?3{UOV*ix`rZHLBC-GfgEk?pwAj4?Jc|4mHjMoLx7L4$|AGJi7fG$% zRMB?p|9?Z!hQxpW*_%MESI{bp%bp)^|!tAUmL z`@dA-`>%h0KK_63|NkVgP`mK;|NsAQ_#f5L+AtN=jBfb<7ji%6s;mEx{NC~(HlY0f zf7VN|4hR8hN-x^F9@khhmZ4;b&d-ph^#7+@H5H3jFfg#~fwrYD9W7!u{lMXzjx3RePe=W-{-) zTKCTIG+XJBd5KZ^?mpHFwad6Ql0OprqZ!< z**sJ4e~Jbks()pcOn$v|q3VCDhWd@KuDq_e@P(fXO4i3J55kJ+47t!A&XQ}Atb*XeLsyiw67D*KVgY!($| zO)p7lS>uUzhacOpFBO(qJUP^3`pV1=2~B<$8nY#@O=V`76lkS*=G9B?g0L=j!Dr7* zb9Qqpb!@O`J!Hl-N#Rb=)V5<&&U6@T?m1+_$M=8b$BU}GtPdwm{G^g&a>q8G^^Zz` zmD-fre|8sEEmVlP)D>jU75!K4m16>nS44JQbp(%fx~cIJ<6AaUq94Cqc&>q`(*5WC zSW`tYmkpErs$b05af?U7&ENn0uU~HU;qm`}wZH2UNfG{+yuCeFQpMwI8SAd844qr& zE|qNg<+@(I!V3XLNCr}R#A=z@ z^p-rs&Ac=8bwppCbxKHY`NsS2gVeIjcf2NvZ`3oxs~x6DxfT6pZ+CY;(i;@Jxa|M* zNQa{1?CQ(YpS!#7v0ufV)aawMLQY&H-e!IOzxDL#)2mmXUb4n`QdLZW z`f~N_Z`XRPoPB%u@Al(Im%rE|opDz8!Va6`pHIK;R_+a{p1pGI+OsJ}k%Ad-KWS}O zK0mQs^vZLGqifVBfBbak?q{3L=Km{}w*TR1(qMS}p2afszKUPiNwsS?w&mUqmk#Y; z9jd?o=X&mVM!ywt^_}u1?5$D79;>hFW^O&7_4oc!;jM=cTuL;Vc{E~;SzuZF<)pac z$hdls_S=t3XD*$&N9N6p+DCsH7qm3w>prP2|NQ+SXKT%-mPGYOhaX$>-0oZ9uO^yv z^xw+E=PwDmw=2A3mT%h6U&HawZi%zf^Y;tt!&c{??BDphpxQ}M)wtI1#=|{ft4$}S zhdn4iCQ{^;rq=Li)rn;xC#IUqK6P5RBxRjw#-Sg5 zbKdYRVlr7Jv}^H#f==xPM)P(rUd6P_V4w3u9*zgAe(=4CS6z2O_J_VxNQ(ZX)mO7l z^l7mlTJ!0hQn>cj*Iz{zC2R5|2^Cpo-8}BL`DV`6&y`;6-%>gBlF-W7ScHb|T6{BC=(NzKg9kW--mThXJ*#~VT^ah0 z+w*v!Vfgy+#V=YmC7gd^_|3}u%PuY_kHZh<%yw&Dp}}?h?C0b^$s3N&i{@RlAR#}> zELF?nhw9T@XNzu*!{>}&mIqpDrP}hGH1`SLd3>IJwZW>y^C}!mr+r}2G1{LT_{*42 z)_LaBw(9H6(=+<_K6YHA?&V<_Z)z)UuOO`)#{|G%fy!zBerV}pKQ)IOpc>Xr;dlSL9#8$5~I~=`SyGLT=tSROhO(DrdL;-`1;4tDvXKIFlSrs{<|_t$)*z&-ag#G zJ44i|&aC=`+@|(7iq#xz%z|5Z!e+hHF{okYj}Y9IzBp z^nUZxt8y@}HNW0x3=zE1ZL@EF(5^W?`xk^BSrT`D*OZehGA^&Hy0g9i$^O|7cTd~5 zAmquxrI4c#Zf|LQuzTA61tDiAr#v|@{lV_3J2MR*?49#q_tb+`ZpT_f9`Bp>WdEdx zyQhH;R@hjxe?jPj-Bb532z`I9^TLWnyW0=mTEFbq)d{Kc{}ZMDr^^3Nko_Ma`N2p0 zc5~2?RQdl|3jgiI4jKxt)Z*G8!?1gG$Gn%v=A?p_5HB_nU1KJ?UV&*-g5Am#`TxoC ze+>mT=g8n47`gx7R!iRwQdps&FjvWIs$xQu z!lH8deV}#4YbC!d5c#=S`rT|H`1tWcC97`57DxjaK7_nfTyU9`5O@e#=>IP9ziXwQ zrGo~KZ^wWJgOLZ1|L+n9EkBOYxf`$Z2)x+%T8Q5N9b#XnDqIiIdzz+qJ5J~S9x=!$ z^6faCj}zq|MH{@$(no6pf5-=h ze6GgLpUu3pvTBa}yMHVHWKH`~=X1tK)4Won?upgG!f8V7io*GVhW!p*&Fu5)_&jI+ zP!Y0EVk+=cJR+V{yrjcj?MCYT@8ycucU@wBG|eGAan6#OWF1@Q3oH$sxgU8~p8oU2 z$a$MvxoA=LvVzNug7;^7mY+$?-*IDC%9XZ5?~hu?9-g-PYS!MHOSeRAEo3qJbkFec zAN755GoH3BvS^sUW$~>On{(%dZYcYmb9>w0t<}@Zx9?pUSM*t0|9`PTF%zfk+>DL4 za=vZ*HYv-I!7tA2X!*CF-65t28YhK@iCop(eJ5sq;p{luTBrOkeEcUDR@Bz**I&SP z&}5;3SK|Kb^5UE>`)5vN7F3;m-M^OIxI{tmqzT8xtGstO<)m7S7TVgL;BflF^+$TL zt+M7ty9X=fAG1x0c3v5)Cekut&Av4%jRzIau`cvXS>Jz6+2GE*b$*qd4oXW1Z7qh6Tecm#qi>>5zBTw+x-?xOsj_6xC&T3ckWb#uCf$4 zvM{t?waG=%k!!W1|KEpCEx30ZpOHD@&4p#1`l6U)IL@b)5zI4!RGQCndO}6+6#7nUfj~{GOv59%YxIPKaS3xySe4E=!N@N zzxqz=Ub1!d=iANG&&ZU2|L|U}?t|a;7re}l46W&}FK8ZK$rPJqY;3$(f?xdH3PGJ8 zm+#-2bnnm-r=`X>19sLh{{Q{y-|fIXzRQC}F0t6G4BAn&RBBzAX6@=L-ub=z`_fj2 zYF^A}ULGveDtq*PU*6`c+JU>6uGj~<&s?7T!9`GMgZxwrrx)Lq|4s1fuCzCJvSj+! zK3Ug0{NGN``Z+UDFwQ+WV*O^D$XCtnON?jw>^_zsa=7o=ilD{j=av*WUr0HXZ8kUg zc+#;?PlRgLT&pqbzPat=^^LJ-%yiDbJK!I^C%H|wPJ1{33nh&|3P)-960$ahh@>Dv|knYv=^2m3yXvfRG-_UM}pmU8`HWWT64PcxBi zU#X(qrL_99Wi9*NlL|%)Us#-)l_$}*u73K5G9QIImo0WVUz`#juX^L47N_93<5y(6 z7K&6_A7fc$Gc&B?@Wl%vOIB{n{a6qt(CahDLHW%O-ia~o?YG;`e><6MTdK;@{QkdH z&fMI>+j0iJY^>gk)%uG4q>a{^JeudTM%C0lUQ_i(e{n%Y$(&;+U*6o&Y`E#a?0+G5 z_TRyLmMoLzEH6|na#Qp9_vz7}=^6??nnfNfWf(WkVGCQewZ>NJ(uyO`JO4WMpH(=L z(#6nVan7Vv#p>11oP`N)-y+-?dfv_abf>-UQY%BmHseFv80ywMezPixjp38r;^1$3 z)xIbGsBxa3`j6#h71QJIA@>Dkm=js6Cx1_Tf5ztK8$&^+3zPOO;k-0mx1oro*8KtF z+Y9rAstv!1d_E~4vds9WwB4&2Ngw}a6t|bXpQc>>@Te`9F9%0=P1l3Tstx+vgU%kc zwhEtmpgSz-{#KV8-fR0?6gn22-P!a0wkx9rlgrZSFDzbb@3#5AZ1r9JZmd-UEW&D`_zf@(CDJXiVO*6($^RCcA_d!vbbhj)Ze z?q1e;{eArz`+^h7@|TzOR8*~#-qH*hHbec@GC(6{Q2##I;V*r()9P2cR9`fGqFr@_k`FJdMV;gr=L!C-X|9~{lww# zI}$naj&^T3_}N_=TZ?x;F=M|kpku#x=Hxd>`zY@nH9qr@N;-+B5wrSpDUVH4pbpySsbppS{zb?wNLU&$M|5XEv>$ ze||5hsm!o*K4?();BtnY^I12}a9=;+)t+e}k$p>;R`xM2Xl0q#%)g{#`j%eEFt7EB zZiWL(K?)YMu`Ft5*tdjbQM-Fp3B&3M5H{n^dCUvjSavVkysNotb3en;RS$MgbzRv5 z(z1W)qixOat280a+WQBW|DGlEdJ5aC3Cu61@G+cP`)##!cy5koO(|qtSAO9H(9kYy zaYR6IK~`KsepGBxL^OEuuoPtRFl1;qIzBxiDkU^EJ2W*Lv^WCXzI_AUNq08^G`hPm z(S2Eh>-kV4^g-QF-Tynp{_ht1JVoISc-!6WSWx5kcAU(*B&S^)X5JL$>a} zG&!`kuJf`>@$+^WFF61Ik^yAFu<5FYp!O$tGo9jrf1r`x%ewzBDr;^34%tbkvF#f- z(n1MU@HRS?&0iHZd=dd~ql2_^^>_aSwQ|Ahgc+tkl3WcM-Ti&h8nRY`ZSHgJ9p5Du z++vvgPh;CRL0EH_dG<4lB_}{Dho^sntQk&Sw?t^}J$PF;$;Jh=$^Qqqq08Z(tUc?= z_v6j~iONu`S|1iv;Y5NK+V+u|EGf* zn;Sq&C8AoV{{MZx4Klv_|NsB}SO5S2{r~^Fiy(y?|Ns9#Hw(027{mi(a1$5A+OmG$ zF%bQKFPH=qpl0m<*I*_J@%cY^5yj{KcOe74XSc2@3)f>{VC#dna<8~fV=?4lxG=@q z$J0pUZQghL_}$;_az5Qp?$>^Ps!-Vtitw@tyL|t;?2f%ANW|JmR~l)4I;y zxb-v5oNjZi_|2z3`JryF+m^eWx||JWHnV#>&Ub9n`QY)#U8(x)bDnoBLLVQwyJzfw z+TOfL|CHdzNhfAs47&OJ@S1lf`>h3&#rO0c4q!Nb-=U^w;%(2zYYTFNo`sj6IdkUB zm#^o2L#E3t%>I8Q`r-T|OC~A2_|U(0DVwC4sg+~<1V^bq47znZldBRh98Nc?3rhUy zFxkUItar9r_KSDhnm8}0%=B7rd^1Nc?-_G$?gC%N%QKa91Fej*8tqORUJKOfHJ;+v zU^Y2;#<9X{iHk3L#>#fgIJb!}kF8{et6J<6#nj@@3+^0B^5xjRg=f{$0D(hmbQ*#@ zQ+`OSG+nzbg(tV>T0x2HVcx_`Gk*zL39(HL+ZYvO?V}NEytd)e%F|14T0GP&xf@a? z;E~w-g{|JkB>frZW7(i8=N-H{(^l9zJW|_O`ZptZ^YfxVA1?@TOPYGNKK;njeDLhq z{SW0Aen?v+AC(|Cd*gBEm(z~>$CTukHI>}f*syVr5wC#Sx?N5RHxG$$z1dLD;BY`` zos(7`$Fc(#zfIpU$tIvIAVo;4=I#+!rj#hR>FS5SR(l-X@bS3)oki)JJCs;gJpFxI zZT<1rU(2F*w;lAZS-W3x2Fu31f13|GKUz|<{p8*Mu40aFGXDQ~lJNb*1^vI_lTVs- zPAWRYg^mUiGd7 z$2HFjU`E9s~9tkY6=yv$=-Rr|@*ude%^EMmDPdvZOWxc#$j^Yn$k{j8a(v@fFYYGBvVm_HHU zDkE=%u6(pA^!4gKx3#aFg!wFFSCoCQGbr}i+HB7jZ1g^4?Zp62YZ0+Co_mCyd__%s^#w~m z2t{OCy$o1=ta|m;tnyc-fB61MtT7N}myKF|`)%#(>#uLfif%Zj>1P#X&laz`L-vpK z4U2G@(gl;Qap$!kYLLydkeWSfh1DyEU4Ji@7?tIl)iYQ7r0z2?beDZCki7H2#y>gp z*KE4YcF5qC?N;v>VzW%A-M((%d&1bLYZc?nnIE?n^Za66T$H@$VN9*vb*7`r#X`@% zy!oTlcRKw20_URA+TxGycjnF0vH0v1FlD#JJ9)YJ_kMfs*|Yz*vYf#zXA^yum8=IM zx|x?>nt9}Uf`^&tyyI`L$~{+bVHa?eIGw+1QphjE8y`&z=NgqbIJ0CI^@nC}y&j^- zF>{*kMxU0twU6&^pTei`=54d)gSk7+Il@}k_z9WH9D8nXe8EHGo~yD25{s5q@!yN9 zN_?r^udLV-aV9mX?~kf~hnT}%#(4?<;||E#l((K&PUTp(%eG$feL(bbdpr47rIHhS z1@9EQH}Acayof{bipV;S2V9e@^1GIJJuPUrk$;eBw`u(hk)Jlf)$typ!mBLjbPLRh zmQsyy%2*}#cE_6L>$21TX5_E1*=*pt;vu);8ZH@jgY8L@5{fw{(ND{^IRE-{C|W6v zKki5clcKD2oEl5{%(oV1tM}*a=P$8|Eqz_A|IDuLzwr6iyUhaUTy%Q8e{EeKzOc_x z_K*K}`!CKMg7%B;ILcxwW&bza=aLj%B%94CY16vSJKI+A@2%hb7yC?Gw!F%}1)@&` zPl}u-vLIPjaZO!hp156&#unp(`Rf#2g4WB#rW;*%f4nOqzhlM~^{r8>?}=w~H%_Um zS2}XbscydW3B@M@MI4qb9bYefbXs1RH%a!tKi_{}i90nK8;?#&g&qeX^UhKHh>`FrEv_w!OnWRvcl0GUf{%k(VkWvi z!gy|q{Qp$>f64NH^!PR>YD_l~SsNz(%t`oCn*4uPiBq6EdF8(?t1P*>Ec)2g)IEJU zpjF25{}bi^e_kN+W*X0($=d&C3Vog>{CWykjNJdXvn3&`eP<{|^edLND^4txKbR-~ z@ZVa=pNpkF%@JnWW=pl#DFbmLmYU)FKD4ctPcEuh?_Aw4`cM-WWts!q#6BR zDe-HTJao-(j=@`Sv-TahS^GA};7vSq6WpJb#?aLZ=fFop+;aGL(f0pkXXMojAF_3S zrz-qU;QA9Qg}izJzW(<+Z0SPq>_a*`e(3J}319!Ke(2A$v%dc?D}v96K&<~Y-uB}E zC5@cD`ykC)$kGMjQ(Kb3 zL$=$&;{X5uhYr`i0XJvYyMTskt)Idq!8E8r>+>J$ss+g4ESC1{e^7h&GkE#$)3aNz zdzP0lFtDA1wq>um&U$UY!;sJ#$ZEaB{9?B48Jq9+Q8WLf>gRu&e?aW;xeODjUYq;; zW`6|kbUjk>-K^vNc@azb9~pg-2d7wagA0@oFdsMMEIi>k_e?>?D;ov&n=(g4EtZt9 zJX&@*JY!APbJay#vTpVLYg|()qVmo9N~pW-$NGoAJT5M~lH}Rev0ipsdsxS=mpAX2 zgg?7h{EhEw3Rmgv;`{erO79Y%|0Z%=~ow5rlcjy{ghmyvcvo{|68YJ$yHC9qiT-&C|cUIoV59L zvAg25kAmCMt*<)t_w4gzSDD+qe$}$KH$L$>71?kwJUATS|L27Gl4Bk@u@2|ka+7S0 zH{N6Xs(jmS>HUwa*7xo0?e{;w^2fHZXZ>O0qI%yRTMbVk7DkD4o8R_D+%D_OEzZ4t ztvmkQl{?oKRXLZM-WUEeG150ds`_`;Z+5m7OLpyA{!-zvk0lM7oihw(`8@mA zn09)y`hpX`|5&^@{7F+J;$m94#azAZ$8R&gvZ?*~?(yd3e`ISfxXb$0H|&UU)R+|@ zkvp-${=kk!%|~B3xXkV>H89j@b5t>7Z!P%9qA}g)qk!HlwyQ=O9Eu;8{5pEaUfCxk zw{yLK(8oL4g-1jATN1wuo|DaBpStOUw@sb;{PygMCC3+4DfIN7J9#$X&OO0WeWnzS z_fu{#w+fXPB$#}63W((PQkjtKer;lWzqWyygY1%@$Atq9bbY^2H7DfJr@jy3ODAJqR1*-SA=FeawaUB1q`^m6;~vlTps1qcoSZis@1BtF5Y5ZJ z@Zyo~+B2DHs-M)2I-Qyo%uH=B-;Y0Z;_vb2m+$u+cys5^AD{C2|1-YqS5p*`x<323 z&B7@ge@*gQDLbK8=ZU1;eV+FTV$!c1R({hsa z?p@rucmIr7XBIoQu^MT!ANNw}cA*5vf{e_KcR$bHY0TOD#=zLvc#ZCvjjB86EZ*G|zTo!5lE%tB z{>j&$r*pB?&f9JOd+p=>*Ix@hQ2p>^Va_VCB<}1lKHUMg*D6bOyO?MxarhTz-Q232 zSZrrCDP#f@|4RAN6*Kxw>|8SBXSE0%v0Kur@a-ed&zGBD{n30BS^LH1Y{Z8*1;>;o z_E=0^_Mo$()-K+lXF9LF^`@H}cFZ}y_`vcS#?=uTcdbtyO*+`Z^%eA9xq)S zXS|TJN^6?6)OkL`ybFu3q?TWaT5wu-xAO9aeO-6@qU3lcY+KX!eEq9z&$lZ=A9DUx zJL-}~7`p=(xykp0i7CFY7G5`Kdx3IRAEc|ny#e{j^uD*xQzUl4G zee|ck_^)>iqf}F;nC1jc1`nA4ox7Iq%Z~f)4BGO#%-*s+OCyNeQG$^rf2&8DP2ZfD zy?HzWEsYKz(nN)egjAaX7T+wo8@9Re0)OQc z&gItYm2vH2Si80D_=}5Sy-~k4qUCxvM`{LpQf=V;YRHg?P++5Jn^HRh+ zwpxDg??wAEd~SFCeYk7w9oc8gI1;>U6qmFL_&OP~Jn-9S|9GOL#@x%Zjz>Dp|0QUd z?z@1)Rzj&RI;!}W->(LNA7|ZfE8mvZQ1*ZAt+%*n``gC>PflJveuLv&%=zM(Rb|_j z+m`8HF_^yYdQoIe{I*MzY_wUl?#yv3P z7wnyMe&_DEcRSZVsd0U>y6Vk$`Kznv%AKLH%CH|aZfi8R9=c|CNhibhxr|$8v232H zFb6bN%d@DJd12f7iCJfQ(^6-Y=}&9j-=DdwufTdv-JRZKiPh6Sv?{-!!FhYK-v60G zFQ@Rno6dfJirTRWQ4FWnJfFn(be4K#Cg}7B=f+BzWt0D{k^H_$;>#S)xRkW4xP*ep zn7pW1_!#d0ZIW>*>HoKjK}K@pqoKpNkOLqf8{F>2Yh8=eTa@SyItBuK2E>nrvj2C9 z!MC|R1Rn!&Ctl}zh~C$!uw&7}K`R?>$Lai@FLyOW_v1u)_%RS43k=@pK@LZgfSio> zB|{mqQUTKT{gAEqK3n%~jsa-BLbb_<3M0^xg@dO5&)WSxWBGr(CUju;yxp4|L-@i4 z#n0R2G5cim!U^DgaG>E`ogF{)wtp1_kL~L3{`CO7h++D^UdX^M z{D?I0COEhM;1vw2;Ne|ZJNPX(Y#*HRrZ1{nzJf-0rz0A{4AUR|zpSOb{u$fc=i&=) zgN{oBw}ZjMyRRV&d6{NE0d0!|ui|Bz{WNCnsK z-Z0DGD*O2Bv`JV0e>?hr?#6hFcmI_^M*aJ|^v93?f1dqc0^SAp|9{VPP`h+P`K3R} zt&Nla|GjtM3G$H;pv4RS7yN&D6Qp^g+yDQQf4)7B(jo>mi2wh`*CPIpZHyP(CI&UZ z;rrrVtPDQGz`%9@+AhB0dg!$S2SdWEL)v@(OkOCrSns=i+}+z>H=GoYd>o)P)oW?D z*VZumm8J*6*51t8>K`?CU8=@bzI`v6rdsX$oi5*==_~c)Y>Hpr=frz+wEkUq=U5Q? z$1SG$!M}R8 zv9>Mz371n}yH!v6n^eAqUvE_$%X>BBLU-43kIAhUw+Q(!Gdw?Mh2CTx?`hhL6%}Xk zZ0+z9T#;4uYrW!*Te|pDB^O-OS{tpPbu#F^nLwOy=TDgv-A~01tqy#Wv|hP( zBQy7Jmo}rQSKXEo5$aVc+w?Zcv^O&Fgnv7HhH5Rsx1=x+OQIq{nVh z?m5EKIX(Qqj%Qk}0Vi+C%m{OK^*CN7+!J*~@0N1P!5q(Ofu>K9oiW=DCiEF}%%5^% zE3ZMOy0ZNH8XeIW&09Wyet!Ps`uP1~w)wwax9@)}%ki+W=jlB= z?@4pzoV~b3e;oY9F6&HuH%T>QC9m=RO)j&-(?vsH+$`O! zbC8{xIg-_A<6*ZsvFS0{n`iAXI`a3H?Vguk{H*TYxSQ&{?j8T4LrN=T)BM%X)NZtzA+%XWqPdb7kX8ye{p#_uc-NL?q;oq;Xw?CI&*!7&Zv^~XDYwD>J zCr=)gW@^m1sVr0z$);O-2Z{;vy^O-s;bf3Ep$r?N|)u>s(G`woOg)6Fi(1_x^>U z(C@w!rH2m>$f{O{ubXmH#_MtA<=uR)7hd~rp6)sGfrEot`_%KI3l`5fUl^bya!Pbg zmLY$&wEnZzqI_8`UYvIq-Y9*tvowUKg=>FZiTlK8_ouoGQ+AZNH~X)cs&_juQ%Gvh zHBYM#o4M{i`p$YWP*b=;esaym8*QHh7FbEyIITbSPUq9xtmT)FmNtkmo@iXVt$6Rh z1OtgaF4hwEv!9saCcC<)Tgdq@n|yLfyv73SSuK+LOLrt2$mRIBvF5PvS$pZ%g&BtB zB@2@cWM52_-F!{d^2y1syv=3hR&os=Uwr$<_VArt+4Mrcck&r`s;w_<5e|{$WFC-S$Wmcw6 zO-@bCt!=hqnjM|JIzAz_GP5x8P>n28EZc^^Qr1a3e(pV)QJ(%gn`?I}|oERpVa4+Fx zxNZ2REa%BYHHO!=vxRC5zb$pqODXeQq}8+aTx51vP{Mb=pL|wqi+HNVznv2ieS1>< z=8@?6uVx;P>zH!<*^wWH59cRqhH~#~-g9Kj#_wCy-}}`ZW|nSpN`HL(io3Dyy?y`_|ZE&Tb~zN9^-np_R9-8@Qb{GM|Z7uCfmGK86LKfJrn z{q5;1pMSS~Uti&=_&xHuVT*O;i7qAM@ZIJ2XUpW|#l_kF`Cj+t=U?_cUvDb6?zm@o zXvcxeM-QegfBduS&+Y2pef0|k{>z1*_c^}5?D;H)BnA$q1@(sdkArHfg$|uLb0vR< z+rb}?%ocboV(5=mZn6K?(ekVRTa|<0ai6<;^RbxMDDY~P^Cm}`t zzn<`7Gtu>0JbPT^=feksjRdzu$-FfaUGFP-Ee(7^gsI4e4Eb-l_J#f$lT+pYhwAn~ z&IVTFI5<1SraRL4ZL!XmxttfD3j|+I<$p1m@6H6-l}gIS)ujd(}G{+X)F@q zUm-03ISc}HOd5El19&B`_EGSe!N*{SL0pT_{J%pCww_n_QMx{4N$>R#J;;#|FVaEl zc_E8=pQP$NO3{0t3u+v{O*j0%64W?`G>d=FmwT6E@H`!KVDN`bEy%IKkOR^nCkMlZ zhppfTr2XHg`z1>Yvhd+^mNw+@;GYo+plxj%z6*oTNQ3Nbvz>LJWci{mXKj$z_G)ea z25TAre16ska(*y;VXxNq@7!BJhX=z~^>S?bkK8PF+#V+53_l@)*TExIGi?5YFGs5X zn@ND$!g-)J=#>BeL1V+`KqsU9P_YPg|F!P?rim3T|8F<^|IcayY72vuff~jj`ojPJ z{|~u-{(D0|S>nm-89V;}mj@jjeD$8)`~MoRK<&?^zkmGy^!fj<|C2)h|NQ#*E_gLX zmdMS|S2p~KYOS08A9RB7B#>DUyy5i!-@9L4g>e2)&ii}{wBTV0l>h$) zt?l#wTc8F$$e7nVt|o0_U|`z|Z3$1iTGnD9;84i1MEd3g&0vr1djJ17&R%o7_(HeM zePcNt5O~9}*ka?6%=2=QaUw^8ri9Md3iQ-pQT2Jn3)4z}InL5A@{_0ByX-x8%9V@t zMe|-TpIG(ZtJFa5x47VUu{ozo->V+72;SP3e!tn)yDOVNOIPZE`1!And6y5};^Sf1 z_bozh&P{*Q3^T8p+rQtlnNeg^+U)!H;MeEVzn}Eu`xr3yQBRh`1)oJfzlASnXLkCg zlzY8s9mBI53Qv++=-Q86|8)(^8t+)}uqOP_HJ*HW%8^7i?K7P*X=!O` zdHVa7t$Vc2_J!7c&VPbur5RQEHYqTibNd(?ZpbXFSLDQ!7v%VJMO{GYf&N?WHe0M? z6cYC`O?sHD`M&!x>xn;&4hkAew`}?G#@=blyVKQA6{|Tn6|^{CjIf#bW!9RtiVL1h z_1?9)kN>>mM5h>?xhJ1}YE2Tp@cGcwUmt#1R<1pyx==a#m_+)Im}-tyOBV|l##(f% zTJGDuJW7^BQ7`V8i++eRzfi$Topl%Pv0rKZ<;h{_P#>t|!KazL^`Jn2sGCxeTgSU} zhhR_6ms&PjCwVW$2}p{cUg7nF$GJ4WO+Zs~igAkVk0saBmsXZ?_I0Okj+iL_ZIWZd zwW*4#hB0AQZhJ0q+)ZKBa+@f1ed@Gr?Z?l?rPlnr=vD4`;#S~NOTX*H;8APlQ&V0cxFh6AV z`mpQ#Qrt~S{4;&l>NWFw*o|cbi$*M2kWc=9r!5^nG&F?W?jb+IKI$#g)ar_3hWaueL|F_@{qbJ+nSe zqpZSE)^7hY2ZJRVGCOVDl0P#1eD(P9Qss{V96xwDZa6$!zSU6Yxa!rylOo>pH)P(L zx1%Iw(@PU?>50sd^Y%%{^aGn-7XVK5o!q+2|)K zmOa5P>78P^O5g8khK+iSXT&(z9`6*9o4rZhgZ=cf9&Pr&B7Z_wCVdQjcunzBsBqDO z2mLL6*6_ZY^kf z6>&?^)ZwhWxAhYH1*J7e=>{kEudCPmkll8YPPG+|4 z`|5UhY4Z$U^FM6KubFE@s+V__OqlTSGhg!R4XJT;RkhXse}oifOy4IprDLH6!~g&L znf+~UnpSL<7EoUkv`o6{{f$E$($TCv%6P! zTe!u+O6DEk(>Rfcwq-w_{d@QQ(8Fjij>>FRrKP1Bd;SDyJexG3{OJ|R$NviS?;oGQ zwQNc2octN0!K*Ue*UeaeRjYIFoi|G><2RP1dNO$aOKoDflIwna9rK?#kEcefu{%79 zyQKJX?~3n^vlMpER;khFSj;j{f62?8OJwCw$?!LQh^xOLA_-oF0o2i1mm)o1H29o(Y)E;seg5&N>n2p5qf18RtEZIA!>9(!D+ZPu58}U+FiRy?M>ekK&)a zCrsyXJYJ~4-Ll}Z#)Lxa(?NZY9jZ2`+CR16bLqXke%mA^t3D>qw7F^fPe{BL-||>O z;LMt>r^LB_hE^}@;|_eBxBl+C(&Mi(1bp&s-f5PWoH+lSZKq@21nDPifyd8EDK5VF zr9;y8p2R+;`t{p5IC@lfU}*+(Gm+8^UK?-j>tKba4criJ=VYW~t*0GfXD~C_rZN!H z^tGFnYMbY6vM}9tMGo|;Hb?__c8X1+i{boKo9T%*b5d;lE%kI%HD;&S%u2SIlWH?7 z)pmXos0}kXQabc#V-7Dfu8TKz>nb*v`s9kGP3B#`W%zG9y zF6&|1FpY0s6X?+2^-~%4En(iXh+)lS-uW$y5-k=a+s#g~*&JmEI>KT9(%C6CpC(KH zSS)a{P4@p}v9EJQ-_GFuI)~%MWIl$IYhKM1jm*sQsVsJ{E4Od0R-Mx$y<+N@g(7)T zu_?*P!A1Ed{Y{{@?pmq;Tf`wF!tUjz39%{9@-+XikwhLE{=ZY~1?1E-@WS3B@#fG` z;8^Hkz>rbkUyEfhj|2v-hKSR-83S6|`#Q@2vS00Oy3v2|6&Y_*4WVm$!RsL2q#Ht( z_kK%Lcohp>2k~nO{3KwT|L0BqZ-pKP{C}VBuQb{JXB|FgY5#+)>Wx7h2JF1-61<^X zw{9wU{1g+h59V z`J=WKw8&Rr=^O5aFF6;yaNK%ZWchoQ&0iobUWOTuy?5Qv+w~K&t&L&&BZg^@{$JLF zFZdN*`V2H8Jn6s2wr>oxK*Pb1v0(V-HrPRFzf;#OfwY8~XFt8XTS*w+4Ce4m(}4^K zua^A(|37Fvc*_6(|Nd_Woe%u)|MUOdqWuS-5DXd*egR$`@qeQuXu0pVU{I44h9M)vTVQK_|NjTs2ayCX z_Qf$03{vqEv`FIrfB4?E|66kc8M_!5*bYLQ!IxZ{4jb^W2AIm27C9JiJ9Xx}ef-Sb z+s!K5wmvuDjh_ zmlyNTiDD08`}Ut;c@X=3J6Ch+QaM4RkZZjEGsT^L+>bbZDL9Tdu>Qcb$hNLT(~>%6 z^~at+?dO#p*v^ojVd8AERXF_ob6))e+m()T8%y=@BpyD*dp2dy6|dDV`G2L^B?)ev zd@>@;OHuKa^~|Zl+Uei^tUtK>K^#ZF^u|vCjpcKn#C6=*Xp?(jzr@KI-irC#SbvCL z$O$q3l*lgiZJO-qcGirD=%1U|M6Z_1vR^1vf{h2Ce*JJ}TAEo~%J$%`M1NDs!6vDwVmJpWy~zkui10u$`un!Bcq#Nepf$cUvx2oYu~Q> z)0W=2(vTa<=*S;7opa_9<1gEK?x#*;C|q$bAfJ!*rsgv5Fos~oS(m58CjD@*WI6LY zw|s}b_7ii%mkb}y?)km%`nP4~U!}Ls?mcsMk96LxyVhCnU%ldLx_0m0_6doX`8zs{ z4$97-vn+FVSV@QD=7yUJJ2rprK7ILG$oupwFB~KiR!M%|v1`|k9eXTt-+sNl%kAvF z|B`#dG!C0Jmt0vfW%fhGq$}TVgN|=FzC5Kf@RyuP_xq<$B6t5d?`^BPLyUz{Vx6(} zuG=%7XW#D1y}j*iN~3T|&4rZ@q7U9*@r!4A+4t(F=kKq-|L^aQpP&EL-TXXf>*M_% zDni}QR0;|&*|WU-`RV)X@0AmL_}oSQyLx*W?rLuL+UxIJ6PTG=UbKyGBH!hO<{yk_ zRoGS~nXUONuD{-SNp<>035^Je8%7a7Z@%GUEPLH_IkmKV>LS+u>racKGJhnT&fm+i zT>HVbT&t!qFRmLLvFn^miri;tvDC}^rJQ*Co>{QzMS+r&-secc?*~6c_FmiRz;b@u z+Y4u(UlUs>wxKPdd!t0JTfE45xw~aI-Ue0~E_P&Wf5f>aMalJ<>-2Lf!s;iOx?|*) zPtaVpUG}KcKNi)5$w$jOJlqYPtu$UX_AaV<-B-gG5t?^5FpOdMn_TNpg%1uK$-6bt zoN0Qv_&bLhL8tl4L(inFN-sMi@gQu`p6;x*aqE{K?ckfH+w^ZkYu4I}Ia_bd&GYJf zf8u!qzwq)GE6l6+*6qIkp8uKZjXsMH!ADxGqxN1qwTI>Q#Ouus+nrzaU0c!mP9c8k z{**I|qw>E;N$-7UVSH>xh=YXid>>06kK<}f3}+|V6!?W@PdywUQTtzAvV8mDH-{$r zbWJ|B#agj#cg$lKtsA>yf9_v*>v>=NGw;dk@9+EnA`6Yb*)(F}EtJ}Nt zmbo~Suh5Kl$!Qi+HvE$QY0KujFhqn~s3+GMsHuuXXC8Yx!Eb|Aw2_==k!pVz-K ziDs$VyWVI)-Tg1FfmiRfD?X93T2uTahU1*!`t~hfl$N~iEB2jkjdayd;EUO z&5hrbUU;;v>G@`({%{`O>t+5a?i?q4B1IEJpXGC1`r4az{OEVZxznR&R^*#C@0}vG zyH>&}(W6K)gjuo3h-H?F$dgN9yOXPr|5QB9yY2hcx$}};+ZlE{daO0qT_u)bUh2!3 z5&Jgx&30?1^}oKoIVOFT?d(xIj+Da=>`-S4KXpn!%VEsT^E z6uiv>lob^8)YZJKOl=MIBAjjD*K>kotxOAoyJ6d~M8IT&)U% zy)xZ$O7vDl%DhgI`wKeFSN4s+)NOB>Vm!R_~S@%x7&VwY-+5ynnUxfxADnaZY(^TH(82sB~_W!J% z=C*Hfiw<;8oIGPv$Bh&5C9_s(Zu@4s{q^Z1$&2^Yx$L|zyY8dd%J)2rUe+F1$2RXd z^X#XJ8$Jsyd)>HY()&{$PAhh6EIJ#tcFolfn+zBj7_z{7ucEi#_&?u4z(Aq$|NQ^| z|L=eQ{=d!t{{;;<*N681|E~oS`!CQBYReq||MI=d{PX`){x4}LQ272|;Qasp{~_mG zfmj{=_t!@>{NLXVQtPnl{D08F0_Xo5{Quvu9&}=t92c)Y0|SdKwBd8@detKXfwqSS zrzuZoy=ZN5=;hw;_kRD4Kc|%_bYPmL(PP~`n#*g>>oc~k1Oa=mV+J?HFVAZHa^{Qn zgoDAen|qBaU&)?mFu9?l#jI%%F@^Js%(7%=%jqw7WX|XLRQFd<@#dTp%)0Xm&t|j+ zF$CpJY@O;N|59ezvmy@F*`kZ)+xQo1^i9bH`Rc zInu%Qlh=@8fu>T_7WU@;<)wntme+ad-dez&S@4MOa-)B$;i|Kl=a;^4ir;(rZ3#=( z7FmUdGiD?{le=v!05y5P0fPF?9&a8+*pd|rP=&r#LXO4Z|>);y<6jm>I4hld^) ziYivn{kLmM(A!2cv&(NdrnTjqU4BjR`Lwp&-wt_kr5e`Wi_02sHH8#RH0e(d{>JK^ zD9slTH8rD9Go^Z7g}{|)uFMH~M%wjX+{_~dTg4`PRPBnnVY~26@hiuG55}jA>Nuyb zWOv*v%k%Pr-Bg_u9Sr&>`rZCru9LMC{uRJ`(0cb>fsNlzPuRh{(s=jYho5T&^XCim zEc)?)*vSl}|HZRs@811Wf8lliV~?EB`-bVuC(Mo(y;A-3 zi0p@NB9GtxU0OON=J@gV-(E#o7b$ccD%g89Xvv9*i8E&I+?sXr%ZJm|yi29FM{U!( zIR9R7`o4#+&39SGKb1OI7`V6W)z8Z-uH9Sx>uA0E;&)Y_djp;_%lJNDEY`ll!oua` zK}9b%R;Cca!3v@_|y;NE@Z&FaTD%-8gK>2=U> z(H5ro6F073xhZ~SyBPkP3y_Z%I6R0|aH-S@j% zsy4qYK5^yxMYSi&jm!f6?)~*n&-NS*%K3W9Fk1ibtp^7gZl+~!pSL$>|Jm8%EPN#a zjRnWw{BWEwnbWzrsJ!O5#{JW~ISeQM4NmzZ^XFdT^9dGPG`cohKl0f3d^eBbH`mV1 z&il%5N~&yG&y{@e;68&(dk>#eSbk!YQt`dU*d66}7!NLQ7XSCV=J?5Z)*qI%R9}}B znCx)6Tj+E3{-=H7yC+=c>nMHEXMJz2&V=fB7upXjm1?wrT6s9k1aReD?`!@ecr)9N5w zo|zYSK(<0N?gbrX`L0&&TDL?`vdyb${I90*Kbj;gy!+V9Of#d2EwW1|{a-8fb&=?Y zIfDP!N~NTvJWc_vP}`8;uprUnaJ>230^R57dXJJpf^X~9AE)Sk?pM4Wr}HvXA6}vS zn5y!jLg(K~>9;usKbBeiKWq2@w9Ws+#+uu{wM?GXJ#q5+c~Q%@)!VOopt-UC@q zD|Tx>Ffd_YV8{noD;jf-{Vx!B9pPXAst*1;{4Z$uzvjUE|Iv5<|NkFx|NsC00uKNG z_tz|%d%aXa;r;IZ|Nj&I|2KtD{|nR_j{l#3CiMCL{|^86FZ^E(G6Yng{BHn};OYn@ z1jP-jAKkyrz`* zo4QG3G5EGuD^vmT8tyA5`?0cRt;pA=E!c(cM`NCQkU%Yzt>zm@~ zJ9qBgySIDJ+@{vbm}r8<~H9!j^NI*W_@*qRJ#E`GmMrux0CUcpxK1DD#_yUx$kA3DF{c9QvjJ5OQJIcw2J z2b63$_PeJ~xS_iJ=MP@?z3$()wJXd@(0XruV(*MRg$GHR7mhf-^E4OmoqTPI#U@*= z{rqLzg41tQ+N^(aEpS2m`^tRhC&x^^L*MO}F0!%OsV+Mq$aYfb>Q(-$&RAVIY5TH4 zrKa-0$JKjTSMFR~&rx2&`>^kw;{Q7r`Ijj6ty7FREBn`B)hvr$Z3&eniGRX9zYAF<~+m`&+H4{WPIfb3zk~Dt85-7sGwq(i=Z!A@TfC~}*4<^|9>~E5c|AZL+3o-l` zVEC`Z^k0bKuMo?BL58-nB9NdE!+${rkOF>&|9lMpIT(^sGIM?Gs*0*lX^A`&W#6n~ zn3SB9>*JW^XPcUwoR$!m5+9qI7@zCoxYl0F$-^@-*u6?${jdagi<8;Et$hC(82;-p z9i69L5#*HY2;889?PfPue2NeFF z7gf{LO-WAP+^5uDVEpy0`rq49|4v9;S*({GteTRX{Qrv}w^Y!a8nwsk)$;sJQj$`W z{y*kRQNNfZ4chORrSLyX;eCFn%%6i23C1g3 z#4cKj>i_=+`=|YyJ0%kS9uxU)@@KYseG=zLNlErdE=f&GOG!zY=I!EDSdsz;iHV8H$;m0n z$;lZx{|^iN+s_&o7Z(*7xo3ULeTMuz6DE`E?v3m?B>j+D_5;rw{G3$ zEi2ZnS-N`N!WEmAu3UATi$4WqMAFigt3e9Zu35Hv&GOZ27Oz~pYTbsd3mT@)U)<2x zSWsA$l9D`O@%h=ycCTGCZ|l0=gBz>f?bTnha?SEps~0a{d1+h1+VyLfty;Zo)#?W~ zkFDRd;pEY6vlgudxiBRqDJco$_!%=dZCah(wA#O56W9kSt{H2slQy(WUTu}I)-HKn zaPbD8yp4`&8&Yf6IArXssH(C~T9+6fotl;w6CM5YLfpGc4fjv9+bF91o*|9>5_ z%;e<1|6Bk6?|i<0{=fhK4=rDH=Kufy+x|y)fE4||_viorU;l;8|Nr}cEa(67Rrh4K zeSdwW*TcN_-{1c~K+9SF|BwD(_g`i9gYWbH|95#l_3Fj{cRb$b{NM2Zf93y_{{L-( zFaA$lZw@x?|Ed4~|DXK-|96{p1up{w4y!T5V5W(1eU_N0%#}Q0kU%Q#$%=`)b9;j|&vXinj~&+Sedj0xKVDPh33I*H)Jxkf(my)Sm3i5|;Xs|w5vxG|?`BV#rimo+ z1Y7va$jzHOKmI_?sf80e%2vi@W--RDydKVDolyV!*|&H9zCC;saGihRI(wOuB)uA-MxSR-pc8HqB2;Z{`ch|Gpum@5hvX zOPr_vznsK(XJSsE$iDM+SI<8?b7arr4auuF9qY^8np>W8`&Vm7N`Bw_ z4HC;UO)PinTeUDNs>v&KeL1KYcI%Fs498oKEfx;;PH+A5d0dXyxGuOQWZS`0aDKrm zX{JiA`a(kvxg7IH8TBdx9HA2#1y(k$Z@-;#o!zP0r0qgV!~Cb4Ue7lwIURMp>4d_a zCI2%_W~KE1kV|X(<(0|6JeR{IFS5sNwT_Xj%B2Ti^Kehjm zTvpqsf1lf>cn+kr&C%Qb+Wp*-q)99FOypJ`Xif@c|7y`P&H7q(OiPqd=h33q>RTh1 zO_~^9EaY5yJv_Y6Swi5~qn+1}J}mqHVn^!6nxi#Kx6SeiGyTc(V^W-N<0m^I|K;2l z3MT$JvUaM(snh3q=KCjhtZ?@=ce>kX;WY7s=nIo0_P2uOv>E>Y`KYAz;u5R6U9S$- zD3r-9PPTO97hC@FwLszp(avXaS4843L=DVQtm5^NpdMq2*KY z(#__*mk%&Mf6~+IS6A5UkyRvOFYIPyZ0$bdKT~I$5-+nQf3%zUGcm!1=Z-on`~KAO z`V=~2g?uM_`}{*$Emx29Ose18!eM`4GTVVQBJOQUKQk*U^%^R=x9(eT{8ZNI7k3Ut z{kuA8&4imvJ%blFFZ7r(?WU!}o>_M^+56}Gy4d=4r>4k(liV!AOENWmM1-|CKJ4Bx z+vd^2`#0{~x_9%gvxB<6K%dOZyWKxs{vNJms8VS+eEz-kNsD2ZDC*^$mWdygdkxxeZQw?)GD zuZGE6*S$NXz20uww-vT+yqSjITxVaMZTMv7TUPxjJLdzhD;#ec7#A;^=sxRX1mExL zt!nnQpLtaq<6a5&9yC_(k32E)Zt3*6pc(Y+M`4N()9j?QC*g_{ z`}}+b1y5b#OPR#hc0}lBf!3l0Y^*PMDu2z*5}KLvd&%M?Vo&3Ys6EA>ygsl%E$Uc4NzvCiml4=TEl$EMFOCt( z?R+(tRf>)XSaR*#xS(xuMOU%~$xuc5q=s{l@gU+fP5gecAl@rn(=0_s!1Uew$g%b}O}?yzg#2`)hKErTv%4nn|xGb8BR_)(+j+hM1I(q@w-EIuVBjg$T{<8 z#WOV2t$wt`)6475hDZ&$jOLK7>IJMfR&aj4ee!(H6wRHYIji;OEst5D;?X5{tMI>o zTZ@p%<4(IRYOf=f%C2KLF#AlP{SuLfO}ar0&2rgS=PzmZi;EHX_I)3J-$wu4zGv=duz;|1SH-Nk&WW8{LuJpAr?b zr@-!Ld)U-B#{;-nezolPOqeXX`>^gsz5TbdHoJ&UUCA|Z$DX%cbv3LGI>(R8x%Zhi zzGKhbAh)_h@4-oKee>+5?s}=J-uR=t>sDAO4@+6Z zcA2i(XL(x!Vc!S+x44Y-l$L?yX(;ZOPng8S6rq^!J{hm@k`bYi#GDy6*mt%Hjj{*{jxN?r2=5FmcW1 z6Uu(R6Z;<8n8pk6DkRRRh&sz54&#e!PidkL)X6qCRzy9)l z7oIMEyzj69gG1rdkLu~>i0*kfs&AG5x-ZB! zBXhxV%^S5xJJWpQe(&nP-}vWe{?vb_iJ}Kq-@g9#Vdt_bn~i>HWjzj6zWu`0)!X9Q znP|!Kt8vV)Uu;#iocw6#w-*hiNn$Endv}&pZNB1SrJH&B;KUPKnMH%|i|#+wyuJEN zZ(!?w(>MK&!W$nJ)GpoZljQwJ`SIf|UustLKmN={)H_Q<|v)~F}X==ndRcDURC;OjtK;eo>RKvgQ|m4)SK;D3*AV)EIojl$MEI-fKZ*Rj zYEKrNJ~HEGU}Vh&27i$g4<3Ce|Feg!YVCxjtS%M7C#0NN(v$5Q75gO0;+>|rZm{_& zvq-o3Y2;Ob(@$aUMH)a*}u;r-`0SFgUN<7T@22m2pEAkT5Ic|ILn>>@u=j4Spsv{ZC|=nys;ardD~7ql}WljUw^Cy{vzh^Ml3*_K5pC z=)B*j_~)#wfu7#uWm;FKS^Pex@c*LNqXT*zg2w;vNF*nv{M#qLJKymCY2n`oW%435 zIt?}c9FqQjSlll^fdO<=(=w)gi~090l{<3o&mj@{`OOR`wlf@A%Wz;h!@ebatC#*c zB=-Lz(~e_S2J7pYHcVw&*7N6}#F=^Wdt1~P7EESY(84mOiDB)+x+Z7lMeV9bZp>)3 z3Rs-Wuy=86dfwl|!VHI2GVELO^N`q?L*}(hLfLlC`+HRU?=gwLheY`nHESKa%DT8k zZtKJiJFM1hw_Vn0`Tr2_|09fl5ArjdKCmxEjp5?{zb*{V0vP|_<9O@{8VdM#Oei%e zF(4v0B_(CwO!JhK6!)N_hV0;!Y)>-X6$SfjJ!OiD_! z%85HlXYb2jdMb1Ejq1s}3MU@Q9DAa6?3TjGM=2>ON~i9t9lND^?6&HOyUK^}DxQ1n zK52GDc~yL79>j3v6ZaM#jZ-{%U*X(ije}QGlakUB6ReJ%@Hw_a<;YEe<8OP8G~^te zqjch)>WMpQ$8I$o={a=k((J2OQc_aV65`Vm6H-z@&W4zlnw;d_HOXlGQIoy{cBMPz zu02mnOtf0I#WiECd;IE@loW$yr#xepyC<$rO-}MG-QrNP%`tJcYtlxGRXeQO_c&zi zOi4-cFQ1qZALEp;#%b1)mlvCUUn>9f@XCXy-|yeJ{qW(V_b;COdvNUc$Cp+|Pd>eK zZ2GDr&@qI}Efy=cyJW0&%-HUmGTSd}dU{H9VEV+Xi~1KZz%D>lvP=mTnYn!x>-ql; zf4)Qd+FU|NpYb`(JPC^)meb|NkGM+1qaY|KG0o|9{>8|JT){zL)*^U+Zl6 z>dJS!JAcmH@q0P-|Njl||NpOC|3CA8|NsAOZeE{Wy!`)P8|1?G|978y4;n@Q&qh2m zt=+zlfq};iHk5F=>P>(M!voRzow?}(y=xc0`a6F`+3eeU_y0Ti*65E5i)WySuTg`f z=SG?1f0Htq3|`_rp;Nt(XBp?liXa_yugC9&yj8557x+|pT7wKHn#RAbLcr888TZ`?h@ zu=DM@ZL6NXvYQ-h;xTE7j_mo{@_ff1KP>rompSF%o3O)+BJM`}%|2Kww@&om-|zn) zeY*IuU>}poy71kp8>@_ZC!PHDtnd1+f;{E+Lk#Ph3zD+;JT)+W-?RO}yO}c$&zw1P zrs7WWk6`Va=Qrd&UKm<;_+b9M?<%L0w%&Yew)Y-`oMv~ke^$}8tvht`wjY1|@fPod zma50jXP&MIZk{sjSMEE8r&}EbUU&$n-1m)1&0ew8%BLt`o&(Dyl|?0r+jdndn1pU` zS@VuTW#dxl2lD~r73MW+iyVD; zk1kr#?(Qah_6BeKm$aTj`@V?_zwxx($(+^bTiGwys6Qcxt*K_6_(pR%kJ~&K6s{Gy zT{dT~x~F)oCr_!?*u}+q;@K*t$-xibXNdL3R;~BST+Y2&Ao|f6pR-pQuFhRIv*X&S zLJRqgQykw_CZ@T)*uG4%V;&Dn@*mOP=8j7ZR#(nmHiOeh;7plH@dra4r6rOkHVN~1 zT255;@IMl)YPx4*GQoyVc&E<$O1TsTuf?x_UUK-;I-_)g;0eV=Grs3NhkJv^^{x2wJ#}(XO1MtragPM zJh`5wtajZ2JePwO5j-i$#o5&sskTS#g1CE{ zjV4b_P*wY+z&e}v=FPj=@76q7`rNfez+jS->a?VS_BZk^Eq-z#W$V_se=pOW`tt+l zw4}n7d2O?VEUm2j6B3s=o_e@oNr24!Iq%*mOXhN(lyQ3TK!sg!nQ7GEEY58WG7?EW{_`qpX;(_J*PG1Xk9t2Zn|GXObY|9) z&elFXUqr2VMP9ys(z^*UZ50N^+sX?{|NrHmuYZ!~XI^sd(L}}RK|DVMPpUfeT4vQ- z?f?Jt6-(fy&(gCabCX@;*2q5%KH>OB={tAIvftPF_y7HOe10-Vi8q^*>9w$__LWTB zLf^$F8G4%Uy!!l|-Jieb_y7Of?{MnwDfKIpmYzMFx1B_Pu(>pYy(L*}j+0_=izJS!J-P&E<{38z&c~iA+d+VPKWbWn8?7GkwNP$*a?% zrdiucekp$!RJXsb>J{IQKTOAV9N-a=&D#GjJ@8>tft&u>Bp<`Fd(F-cZ!W^>i_k3PqF-bU~Ryv>aQ_p zySdO!!B!QIgE|N6J=UzX-ZAals-)Lt4D!dCBtGdhs;oTD&2i)Yg@P4@^)~F5fz^hA z%qN3deoj%4zfgPgen>!kSMn@H&uJVp)-NplzkZ8?{1vl|(_RXZrwU?xy?p~WOl7m& z5z7B5JC?aGGq){8^Jt-Cz>MIi8Wn%%yX)sDsCkIxzxkJFYnLEbLF#NDOyHtxxdpzIy?2u^+?`NuDj)fH7AH4?dXlbtZmExwFnAhP&EPIvK$~zpGck6b$N$a(9brrt%-Pk6aGkp;#r^D;& zn0QUi!!qNaACD4me@~KAPTRYUaz{3#u|BxUs#JU8fTdqk1zYUO`;(4|UQsh>%vvn> zMEhdDYoJ|>+R-MK@4Ip`7S7A52>s@i@?^u)R)ezcseUFKn@iTsTGAlyGC^(mvSqKG zQ#>`UzjUy<7Jg?z$dnVIl0s9DKeIfMoF2x&a#clFVDnuGmy+{-CxeUQwr_F?$?EuF z6~EMaO~=DkA2=dDJXz)cw%2Lr3N^#k;_}G?OBFWR)E_Zfr6TCG(Cgi^J(rHYzRh@~ zU`L*0h{2wuqmQ($6U-YVd5uJ>iY>U%az> z87B9NFWfS)=WU2cSIdtT_dhhI{g2u|#aw^BTw~4h>^sU6R37U+cZn)Xt1th~d3uJa zBBxGP|H9qY#tO@3Zkab_arwMl2A{=EcCY^5_1ARl^OgN4wrF{dpU5-sV}-a^?MA$p^bP&nixLPOOw-sG6$k)vo=MweSjy z+eO2cxQAv{Oo7aQ&uCtp%On|Q+u6EAxr^ak{DNC|534gOI7QDXnIw?HZl-%mNxUR@ z;l9Q#GQTu(W0@F?J&LnfD_C={%->((S-R79n}+k*R|S3EcZy4n9q_)bGW+(WFB}YQ zD%%Weub3Yewe_&oxU@xe-CoDQ`Q~o-U+p&+-Vt_T(N~rO3y%Gm_}X<={>v5ovoa^F ze!E2Bu7@%6(=365XRa-gT3OYo&7Jw{;E8OT7cN`VZz!28{C}%7sCRX^e*B(9ov41# z{XCV8i4Xs)c703Ik}y@Tdt~)e{q7Q1k;89QTz>b?{`69m;eMF(>A0q!*Vo#1?>!{x zaaH`m93k$8Me^VDOczIUmB#ETEH3+ZZEaz?Y1Z+c@v;?_^jXx|6k0s_Imt z*Cf6t^Rzi9A5T(zmU^_XHa%zN7dw~dyz5o|l=(WZ$}=!xovHm~`?2{k#+v@V69rb? z-r%Gi!C#!N*W^-WWw!W0l;MJ2BaeV}_g8AHUbss6bMU5vHfstjIj>6uyy0~by>P7L z)}cu$UkZO8-@f3s(#KP4Ep*jqNNGv!FAg!Z3kg}YaQkNrT=y7yy(@W+9ki^U%e%(Ky?kTRG0SP+{{*8R@xW8n?!U#@HWoB*(W!B(t9dBHt7vZ#@U%wa zTY}*eHK#=lk(xOI+mv#SS{9qOMtU^=Sv>8L!_>DA54ZbGS?hfAFKQpY&VIEt{%m-)%R?@OEt`*ie)UE=Jxqdw;lq}F zyw@Kp%~p1j;*Q&(x@&E$zG!u$ufx|*i=U{}Z);tX>a*hC`uh(IKCx`ov6Iu8>vPG^ zDtrgS4X4ddRsNb46(0{g+Vt}26#0t}m^CkoE4E(yQL6K-y>z;Z(v9Y)9>=!{adw`o z{J_#;vi;t%Y1h}VbQwhQhF&gE(0QrDf5|>p&CRO*pQ9dIr*{28{!67LmK!%pUb?;N zOL@$~*7Q%=_eJ?D(yttRv3L1)m&%k>pZuB^zh-hrNne_0w|JLbOirilx}>Ttr%bwE z1pKXYeY=A(dUJ$M!-kFA;lC#;8m0R#I>;aPNOsXg#+6Qw+e=elTS}E)-xeymG;OzQ z2V2pCjY7ROkw2bAn>l{}CVISWPgknQ$u+wY56@|IW1GJ0P>!(c$$o|7Z4wzhi=7V~ zc)8lCU1H8Ok5v+1ayT#Lx;CAed;h_)x`f^Kf+e4(CU^g2wCeWC5v;m!^~$}-xqe?C zs&mP6WW8_>xyC5_bBd$?KAtzuk#P(3^LO#s9Wt1&-+u1;{!;w!Z}%ac1c8K2*v21fNEv_l$;a>)vY0^-yrcm}{uN?rDyxRB zX8{2QeOFG#XZQxrGU)z#6{Fx1sG(A6>2 z)z#BeG}P7o&%p4Xogq(EK~hFR#>iM(S2s{Y^}oK{L=T6V^Jcp_TKx)h`P*6eb@S9; zw|BoiyWy0(m~en%u`8K7{rAy<|M&NH zwlrvSt^f02@9#T%lI8z3PIheX{hryCRm!$;nAcNy*8{D^{&cNlEea3pu=VC1_Pb zYMOUJMM_G_@|7zS5)x8UQ&W;b3kf39^OBR3QqxjXQc_}LV^dO6Hg4WDVcv>G%U4dA zJbCWo<;z#CTDfM;%=t@}u3WWp?YcD^H?H5ZbGUa@A;(&brM*(u4Oag;?XRz*igFIlm2?YdQ4Hm_L@R@^&l>B=>0 zkL=!f>*fuxvlAgh7I1Rv?1kA)t5fRMcx0`HuWfKh+Z0x^-Zf*bNA`x*>({rmwK=41 zN={Brj*rM}-1zSP`3Daly?pWP<-;pa9^78BYQ>I&m!~c}t{1kuHgG4{(P6p z?mv;s)1=i*qGt8~|KA8wd-VVR)3g5npM3lO|0};i0!iCXOq*ZKc{=GQk@r`!ga`w_I1;s5{NeSyD^Ffj1gK!+c$Fqbh0im*Mfo@Y}3XVS*l z+c*BNld^7a{$^ca_QL*Ag`C#gbMLPG zgO4wNT6#3S4EbbZZPYKms;gl|ed*_4zrKC@^Y7zK8`bIWGQ-b%>dXX&)Pl zh?tbG+UM})8tWOd#cX@rSe{J&`tV0fi}>^z-rlEAo$8G@HsadY)1$xMj`5k+f_d%% zeUoB3Pp@3HZspq5>s14#dRETZxRLXRgK-e&PREy-x@*_w=DvOVHOyvOQ1(ubWy!A? z&isviBCy10!G_KIw)SPL*WDcD&8dCy>Ro1u*RCOx6m9qPKRIygmWxp1p}>D^IbW5J zHUvzvi!csR&(=S#T-eDpLrQMp*(J}z`7>D-x*flvCK=wegjdb~#Mud183OJ-?M9jX zOx??tNoNYw+>9{oImfUpZT52Y=WUD%M=z{)3!d)(PU~~2{+3w_zi!wbu>5Y%`pJJn zp0AYjiec&L<=wh%TUB1$gdF=#^G?|R|CfF&vdv`n!fDfX$}>c3hlZ}UIDKK(^0a9= zXYBjh6{RkOhrV2$eae=fMg1aUo7%*=`&L!o{p_$|KZCQh$2KO1^6ASP6YPIHaO7Ej zQq&~ts!Hyr_?RP-F<&gzvh~dy05SHcbWernIey%IYLjWpH0`x zO)L7Z@a^mC?d`KCc@$qrnsN91zikSq?wz?~@#L$!%E{NUnJ493Vjx6UVPu%lw?(e55?|)Rhe025? zL>V?KaH+W-J+|}tgOYpmj$d66S8>x*Vd4JB$_FbPzc?K+-!4-Zw}0h4X_kLa^Gr-3i{t09ozH&!efI6!rz@)+C(Lrr*RcG3veMciZE1hkk7qW*=k&k4lT-eGJ6f)y zN-NxYz1;kHSI_n`9a^&F#Ql#}5ntcdN1ajH)w{a;arxV|kKSi*KfCPA9p9Z_SMK7{ zW44|ztWmsM^YW@3j=mGqo<>~L@Sij_sz)+2=BikWvU}N#l_vhh>GRl{+<&co-cwin z{{P80Vj9S${hyY-%&{C&Gv>chj%&U4Nb{B{djYIyB; zwYcS*vh8`{2N&7=e^Ohnp~Wq>XUkM)w_E00PD{V~yWaNKs^j}kY-H8Q`MYU_&Cfr3 zxic~h6;5PGZ!f!<{CAt-``E{JasqcEB`?L#=fChT!C``2#^TN|v-5R7=c_j+WH|ko zpQN{?|Nh1g+oBB>rkuSHW*7NYt!1yvp<|m5-{^XIv8C+zd;Z()VmB`)8!_dodueQ} zP_mlg^RqJRQ`cA1y{D=gzT9}dSF%6$m7m#mwp)FwZc!6!F8!3ff9Lyr&d&d zQG0=>kd?E<{>lB5)hge;veXgPRJUgztf7=t!TE|^GSuWMSnpF0s+1^3J zQ0~EGVJ?5sV^YNo0h8q-uShR26x^N}EpRY?$Fba!w%{3e*3K4UuGHXPq2~9)CqS*K z-(P9@GVbbdrUvg$3*Si-7xGpw}`FaDFd~o_)U71N+53u;LtX10B&yXNd zE`Pp4pm|AZ#iv<@lA-foFu8fzKAq9|SmT%ALYCzslV6&6e0i+g-S=pr@HKs(uhn-G zx?DA*N_z{vjySJ7rg(QkmYMsV;9r8a^DNIYJIr)mqR{zF_|1k%+oWa~CDk?iZ<$vp z$X@r}@8|__Tj$%K&KNIWrXJNDwv|EU=7iM?`<>5xuTt%{oUCcM&Sdo>op*X6U*^qS zCiMKA{QdZN<*T;0gUYtue{rK`tE$Z!mcrhXQ!luwUETI{cd6%a(Us zl9_*>9BlsmT8Q@vN5qDN(7SUhxwcqLJ>MyDok#Dz=YJ<` z!=wzp(|Zo@X!z~p+9TK~x0b^zCMRZB$%W%4Jv_74Ud(xCRxV|d)v-l{==y==Z|kWaya4I ztTh`=cb{c{QxJ3iuHd$-XhUYHxVXXL$X??L9WL-~AU^BbIUamnHxI ziPcZ0Y>n%z?c05B%}L|!;eKB8OOCmpEjAaPyfdZhu-u(K-6LKmDu-`*@;E$54w5#$ zdWP}nnpj`gwV5meYP(K1TiI+*-tz7I#63PL%l^oUZ!;-T7R+fcS@XH7M>>Tk@x6!f zx*ci9IvN*lzP@9Iau@Bcii1=}>WW zoA0gy-)^3Zmg{x$T#7bDchBbYX!k#sa_Sd%o{fOYyQs5?fwLb=Gi984m^SB~s7}S= zg6qtl4-RTrt={_fRs*{@8>`KOgF3t2UfZn_wNBO2TZ1#+mtNMyd zISw*o8-z$BWf03tNV1k73`Egw*Um5BLASw`WR6)wjF*XOv~0xq0Bv zy*-877clHy{QK_SKaURbE$R4kZ?E#Ps|-_X;?q+%oL;-;)asR8X20(4eSd4u@4LGh z&K;;79x*;w%KP4q4CM}oY;KO-GPAQ&yBOl#bsKJbHJ=l`EhlQanpH zyJoC)N?N6G;i*l_F3*yM_DO3kJNG(eZca%_$&L(vfB(YK+qZu`dHmqvqxa9A?FM?2Th))j@)`cvCX!!uT zs}$5zN5cQ$><9=;3N-TY`~Uw}AnvBqQ%j7u{{t;s`2R|#0wnZbJ?Q`c|M8%;5chem z{{OG~|G(J(|H+H*nAk*VbpQW<tpWxBczKUaz+QKmPy!DKh=g|1C|5|Nqzg|3Bxz_5V?~ zzn47;b~31cedF1&{}=CgJe{8Z;s5{U_5c6>|MWlN<^RJI*ZujU`~Ux>4d5||r~m&~ z_BREbVqoA=g^fa7O>}YOU=29-b)A85Wc^=r$?~7APfQw||4-a_?stN+rnlYnpe(*N z5!3r0m$6(Dva-|c3|aG`SD97PzTni~3U#}=4f9JUiC#Z2Kg07_ewfP12c7?N%znhG zII`~Ftg^iHkKP2C&BxNC>lS>teCfK)u{oc+A~z~Ou3~sF`}WRCeA|6DvB}u;)sE*!b>>K$FEZGd%JJ&TWW^OK)k|_kuC;llvAHb@Luh0x4G(jHc$WXRjKQ>HXvT@`3{q+e62?5_l6^?%pj&b)j$W+>^)Boy}gMmn&i!jgE z*N0C?x)}s&_^mS8T775nts50Oa{aDKfe8-(IV}&coJ~0A`T6{@C5D!gJ?_533+lNF zmoLzcK62SYcD9L6lc9j;QKQ3qrDrW$dFrlpw#rPCX9rkjTo)IJ7t`FZg!Rtp$CEXM zJ5;<|iygINU#8tzo$cl)xM2SK8|!{ME~(s^shq(uIn6Z8tn|p#wJlulZr!`($u89Y zY)So$Vte6e;oYw}92IuXVr=76X17RslFc^5>5rtzCo|?3f41ND`OCG3um~zKHS{-SzK=(XZq}%c{8VWJz<&u(SFZ77tbjD*j)v6RwB2~XsPWH zXZktq`{LP|X^)EDil$wXZLad^f1+pnu=IcAgXNh*XW#tV=)@nlv*hKUrQHiBtlT7N zDQw4hv_SgmRM%P0w(NZEpX{~qlv1MFbN@4KLNR-0eVSl-_iOCyMVZ?oZIn-*=iHe$ zt7B2c*EdJI)7N)R;t~0DTi)TiSod?4nx?CAYDybt>v#&eaz1(>bfR~*d46tsZ+rdR ztCKq0HFSg=CrG*`987o0W4C&rVZv&o|6ppD%Pr+-!8i95%b8ERc;EF5$o&{~jhj8- zo#&zdHaYRD%vYOCy0y$DyS;H^#}x5MpO)9(tKj=na}*L7xEsG;?m-AV9C-*Nwj-6!-C zk{_sU`uL;tcsIL7=lrOU6|1g@&2;8wX4 zNf>$TelXRzuk=di$&V{1zFarA_x#mKC*Rlak399A;oh8?b7%J-^(Ygok*s*?A$)`H z;^%8$ZrlI6{C)CSuR7LCA07m3tA94PT=|~N9`-*{pI0od{h_5BDZXMax(eJ$P_2SxM1$*@Wcy_U~PqIfWt|^WxtOQZ9S2nmY%U*P>AqsZcN0@NWsyq~c?PUvL7z-tUA_Mpi!2GypFjzT{$>&>(;MF*X&cd{k%^}@E}u33%}{(d8e~fo)`z#-sY8j z(6aCe$8V97LW`E3TYvTXwf5kYPPe3vBU28{JmY!f;XK)(jaFCE-|U*xtamoxQDQT{ zuoF|z`uug?(Jq~{&Yrvc+Dbg*z{lv1!sS!&YcT8(;UKRRk|G}0&GgwkK*S*x?IdZ2~ zrK{KA*r|ms^WF%BYdN|UzI*R~>rSlE@uTZsUz2{*8~D8SvO@04HCOh}TOy!1{rb8T zg>dfU0sj>uCrQl-jX5B(Bg&aae#^sEXZau0SLxw3v?#U#zZl2R*n#=Lt*J8PAz zpXo5TtT<|V=G8{mc`QdW9j1pxFr^wST>9mPAHxj?HB(8o(9Ku=Ul1zt>3@{ZyY^zl z{RJEP|K;Ags1~|#X(l&=nd(F9HCO6o?asF7Fe#?!6^6H&M&-{svElPE#|{_ywoN={ zd^hARzcKC1SZV)iXCBwjN4&OKt|>+0yLc2=wfA$D-ZtX+*scDqYn_DT)S|hagj?jTXABoWX7fN|H6%qSY zn0LI${9KYC)*G#UTlB_#rDoR13#xsLt!g_GGJJUT-tPbZ;NegAe!1Lh=cDYnoA`2d zD`$)7Ud~rn)H7kvn0~lbh3VHE>lNo>?Dl)QOUNt%x7QsdVkbP{mG#R6F9>RT{DE|zr42kfUr9oSA@asYL+h1hOfJN z)%~ws)6156CdgmEbXxv~c#S95Z);y_a5(X5vifTO`RBeoHuLFx_u^2QV%)+B$|d{@ zCv=A#d3JgKe!<%p?OTE)nSGDi?9Wp^Vrd$`yqY6;@@3(m`d?pqKlI63CuO8%YhPXe z>PvpEZ1yvj@XKDhts+NwzfI({+g%r}yQ}DFp>xZR$^(W_^o1E0!qKnp)pZay4t2@&7aL z4f!=6*tWFqdnDcTef#dSmvt)EJ54)&Is9?R-YL)G{R~6b8H>eAw;v9%&_BAm(6eBU z))v(p&#qYB@_e#@S8~@X4yR8ZUs66ES-Z~7;Q-gJ&j~UthDE)$qUY?K!*9#6Ra#3} ztnynKogsXKBTN38$=$^qx&@uTvjZ2mHwC>uVsRuc@$xe6mXv9c4s#~AJM|^UTs(O? z!*z$s@scI7Z_o5+HdQRhE8x;TsDESOwVUB>buN)&YqS-;e9P7uw+L+a+$e3RbYU9r zksY%hUn&wZ<%2cNet&GvSsl44xLNVw=QtO@h8#Cjz4em3vBW@ut|O%yQSh3p^n3!C)|G^EE1$r;g?d+ zU>f{c^g(5z=Dx|MpU?aMiu>~W>;16Z&Ce#DYV@-CyeMAg=--wf4s3BvF^ccM|JwU; z5sy6UKYn#h`MZ7BeH*b2HxPAz18mR5FFuCT9`6Qx0y zl4PrWy13Ki(e5e#?=M<6p(-;a^1$r5kp}zJ8O}l$Ie1H5DNuesDQ!hv*vd!yrtg^7 z%*rRSsb{4e!&ZIaC7_e=6h7qTJyU;Np9FHli8Xq>8+?2(+9j{EmRtv4+puie3dpL4>)WS4-#6v)o~f%O>+bBD zeq4~@tT=P8%<2cbryh{tfA;kBT1n4C1}dvpuXuQU?StmDyCRmy%{7yf5|cqEG^8w@ zR14~#r=&ziM!h^ZJtaBWtGF~hBO@s($+M^|B_$<3J}w2+y-$u#%S%p5dbp!6B_*Xi zDk3E%rGMhYl$4ZBo7T-+wr25)Rg(*}CykX1M z<*U~Oq-QQ!xn}9gRXgW4p5$RmNls2o0UiFZbmgk$t3l$c)~%noV0BYVOL+xo|H#sn zs}?R_xq8FK)$2DTCnv93wRHX3<;z#CUcPG8k`=3#fwe4KwR-cWRoAawId=3QXx%~* zV%Y=agoo)fXJs~SNU2-nnz7a)Z4>xNhc#g(>&@cU`s8i2Pg(1jzPX~RYQyFY&KVmY zoZJ2Q+4Bbv9(?=s60+36JZ_C%*s|W)8>UR3;h3?_FMVc6T8HzrrJ##={*(my1v5a_ zJj~n1a^nBhhQIGP{{NS#|Np&I58$N;pziX_gKp3;|NrX$ zl3$?vr9s03x9TABAoAZQ?=K+wf8ziDkIMK8{(rpof1hH)W>v$l_LZQu4iiAKQ~$5M z{r~@||EK={7XtBPcb;0fFy;UCgR9nn#tI_3{ww|W{h$56^d)FDg^ZQWYmj@+|Bqh1 zY1Lhc?Z5N94FCW7|NC3_)qnN>|NpPOJ@<(E|KIo4h9AuX6SIk!Q-OLh8(O1*0V(H{GU}@B<6njwq#6Thvrfl z?m2-;f{EuC`|?(9Q$P7(QuXfuPCd8ZX2LQB)*c4tw*(JHBTOY?2& zjCYFr_T3ijT6WSW<%dbX;$Z`w1B!hz`W=fjE?io=Z4JjNwfc#3ITU1U?i%o1-o*I* znBf-T-zVP)x|GUK_oz!}=s3XlUC!!Vox%C-GvtigzIA41`Iy9aW}{A`#5<97eTTEF`<~@lgzhzayyonUS-rWpe=ICdt3F>>m{~nP zXwLF`-)Cq3Iije#eAnBLZ@+iwWkq_iBuoDOwtl~AJ$GZl9Jke1|CR*1hIV8uo^F_5 z$R(Nm!&_;hgzx@WXT( zL8m!Ij;ybIjQ{YQc9e*o#3J7&*-PIIzyLN546l<~I2X|8dr!oC)D!ekLYmHnJTK zaeUucKArM-e!1~NUy6`$m4Mfg`Ft(UrW|m(qh#mU-*Ra8yrmU>pKbd&FEOc1+F&Db zLZo(Lp3ep4Lk{Zo_YZ&lB>6RK*+NMt&q@3374uib=T$D9aiKft$=NgK&V8KryT9ke zX`5fOuUESK$b0zx=1t9c{LD80|4BY9zSXa1@;LU-+^TD^_2#Z{%GFDChooCYh=8Nvxipz4`WS=uf7cn^E25HqWAsafs_ehBG32leEsp?hZhy)`m2@LEGNHnu)Dac{!{8R*4d8V z-rN8Dx!v|ty|u0IjbB2ky>rjhoS3=d(VsU;d%c+@mhGu|`*dxs%Swvd$7Kb}i3e6oN4E-U4j#W@%M+UKVU-a96E^kex|-=}iby5B?6uC0Ag z+}CJiY^=$CJbsOpfwpU*Ze;eHsWLm$wy9?8HftGZWS7mbycs#`?p2E~k$>lYpZ)i2 z_5a#g8+#kx#JzWv3HNkP(meHScb@6L$b!T6))U>XM*UBH;(7gYW9%IETy{~baFeO( zX7(lQKZ|X7JDdu5-FLtG=vUgYp7YAJ#x}dim8YC%zgJwilu_}@VX0Xs-q-wVZ*$XW zQTAQ%c$uMLd)T}4d#lS7=W;~^+r^a&yHx62ezVN}*!{_0ZaDwWKfO1jzuj4DZSIC= zTaumJlY@U>pBsBOFX_{t?|QpW-DlYT{mZwn#V$+hvjuJDFyH8TV|?T5<#PXB`^qC< zeKNFYOL`cQ`}W(8^>_GP7chz+Xt!z;?tH&*`R03HwH!o}b&e_JX$UDxYz}d<5^)LCP1V)e;1Orl-s;kzB1I$n3WaID_qyz#}MDHmV7h$wOppIIQ< zRnp_U@rP9KB!%GX0&i997P2^}9N;{<$TM=ktoDVETEBb#tY5n_*!y9|F|KBZ!hnhD z>J@UUdmIWovVNDCC$;MRUT>WE-C48oxD;=Ih@0WU%N)7NbHno{pQu-~s=98XmizVI zr-Ti6qUVcj@G)oL5o>Aq=l@buRe8~g==mR(?+rbeu+sc9Ta5VBkDGLY9$ZU4cp_u6 zEzACkJv^T`xo`5k@=E=4o4L7VtI4v{kG@`y>8{W=`tZfg;MhaS{ga||x0E&?I~~$; zB}r-jb}8W_g(seDI^h<1b?cR{kmJz>1gKqNl0W(gnmhgl!}l#OLp^(Ox0eQh~KSN&wD?<~is>{?BgbxC=3|29wL{N$nYz|rT_ zrGn5W6GZ*veWpxb>)P_xuR(E*Kx#+Fp+kGN>@ZQ8u*Idyw!`;N)}_EUp9>u>TmJg~ zS{QwVtMt~<_O1y{9+y6KZH_W~*m~pFRiAC~Hy4ZE{CK6sQ0#E+twlF^O1hQ>{$J+F zqAn(;n#pRkS5Pq7F6MM$hi~g=F2k)AAwTxK^hukqkfihB^;gs7e>TW#*W~WZuKh1N z|3ze+-3QGp#q%6kR;NDM6x}rSlU8Pa-?d+-p8w_w-t|~AKti3D|N4c!TbmZoGI#sC z>#o)PkHSBX-ZcB*Ke3^`GU#|*zO=-Z-4TeA1<6b%!HwrSf$+^$UOIjPiM64d!; zIm3g?%6^lM@ZV%N)9sQEJ7}0|@`2Z2g|xvrtJ@QgO_|*HtDiqx#*24?R@#=Ahgp-( z6mQx8wabuG%HKl5o#7DQl8Kl97})cLq_CuHQxNsf^DsFp?KOMjeXoQ^SGuRwF8;vb zaBtzZ_@%z`Ur+9u@~rTQp}8gp?(ANe~0X?*e-cLS<9j)A1)?WzWgE0 zko))9rtOz2lNTm^^`CLAh5?+N&(TX$GqMRWr}6XqtaoUq_hJGp)63*`#~z5r!)xOxKlk^2{hy$qheY_IaB7 z^Cd@Jl@=Ot`>jogygj#)XHCV|w?7W{Z4RA(Uu>75Vx+`Uotcu=)1RvfpMLPAfQ4Uo z^-ngZO6TrN(+*8aSvKS6OC1R>yQrP!eUp;{#Qfj!UlCwh{%!kelm5i1de5dCMs9so z!Qa&StZBp4OW*W7!^A!dPu#%uY~xhMY@cmerC%H8dM$ah)y${2R`&1?kpx$x!e3wh z6vYV`GFu6~o%vq>Ps8b%O1!PYE9cqma8mX2PCs|1^@h}%M4_0_B~vtomS!8cObg*m zDl8KZHODedziCeYU0=Qukyay@75K5)6`>b2~$dp zF;O_Xa!TB)b3R3~?2QI7(Pfs)`-PQsB6AgWxE0?QF>d-QIH|(Q>wL-1%sxgxO0`oPWOl9pQJW={+J8gqSL6S^=J)?|Dd{HuDu`A3rzJ2;_@mb+sqb@nr-{!~ zR!{n&Zk+aN)BKr>x2CXb3+;bwl*U?rw_nwH`EjY^$4X2-w{Ym~iVg5p=3G!P&HZYK zk>RH~MGf;WUTF6<=34!SPd(4Cjd#itqJn)+u|O z4nJ3`a=Q2Y-VNnOy5%BTyX_S@m2Kj!&#gZ#fAN)@F|*^6dmFdSH9l7Qc1igi7RIJx z!`ZL0lG`HJRk^!MD3-Rl3A9Z&O<1PmWir@66Kmo~QNt&J{>bntv(6sySD=(Jhl@?vf&3ovx~jk#cEy%kJmZ1pl{=e?OP2 zc+$$5xX=%hQELRt(@uOAu#hk>~>q;K%n*3l} z*UbWvuc=H=gP4x(p7-a%lFOT8yNbNz71b(o<3Cr5ou8X?@5s`-C)YeYFek-L<ZIaru^Y)G@(G?Xc$8Yu4%Azk8>?-aYBt zuHHv`rZJp5@M8B=u^lt&XNEo4J#}A-+IJU*zb*`+^Ku#XE_$$g>b*OMUbry4-_`%( z;Ov(fLZI~u$)LRo>!#H~1`xg;p0;~oTUcHhcx^+9XAoj+qPf1AuANBA+{xWDygX+nA3BUOJf5ZNZlM9VGc0%<$Q>%h4cJTZE|4-Og&=Q7gV*ma}txmZk zt!5Xp5_Fiu?*D)1{LlRVKOeMT;{WlJ|2rLiNAEbed{OGvdyChCRu^>qSO5RtyXYy{ zFe{MZ=ac{cU$^R>?2flnz1x2L|2=!#!~g&P{%`)j@W7}45x2gVl>HB`b28w5e)St@ z@xsUV(32qlcmIF?VzTsl(3Xx#r_O>8g8Y8=H!CXx1CNBKi(^OyZB){#c$o=tlW@Mki_Gzsn3R7wbZ z=)aYnC+Sb~@me`~B?Yku_qi5`n*HeS_}N&qqG3|=f2|quuiC9xoHYNPXSIs#{LkIc zclm+&+6n#}RQodp>(ryZy1btD$0e&qc}c~(-r7qqAALTd$e-@?rON55?ZxTM4=+2p zJ??apWM2B{W#pG7v(7yWzy9pmx4e@55$mqKK6@#zamw{m$Ig`R{`+vp{o9wTY^>}* zC5fHsR1Fk)S1Rus_F~8GyN|v;-5 ziJIlz@mo!8*|v527B1Yk(Q~C!pz~T!&#NDpX6dX=SmdpDLAu9nvUqXqWL8)9Y_8)U zHTN{=uC_Gar@DIU+PnAOF^D?Vmc-1lSvsR*N7UQArsa28)R;=Y3lxWZU&-OA^1bnJ zuJ{Lw4vwV@Un+jS`Nw~W^1hJ!dEXyxD{taV$V=M0GuCE-ZrG9XEjJm<6@*qb&A1dR z8!_?6oNM2*T^p*nqlHa7c35qyy2B`FCFQ06IN;YFt!=OVH9GF^*nPJ|x74{q^YFRG zeVg)HY|0d#TnRX%tijcD>##3dhSM9#&FwRNM11#2@YqWpxX~ez{Bc4VzrCc>`-ut~5t*4GwK5n~z_6C%kk=chwor*!|A?mWZed3L4Gh`n#hc(dg{^M#;UeZ?EP1^yAR0-)9S}n>syo zRz*a`$FCCTH2fgC`ya!q-ySxz_lS3>#CGL(us+yhz?t&@!G{b#U)w8pzgQlZ=bV;w zC{}`NHm_yale_xQG{d5@8$CP}4jR0eAne+H?S10oZvXO^tn3#=ypC8%h%K$U5va4h zv3<`Eo>$5dDuHFp?Gx%M>I!R`luj(2R+V8bA|8LC>FZ%t^;1s9CwEr4So~me?NPSm zKapG6<=+2oue+s(%F+!6FUtZnE}dF^yq~2{a*xzTQFGybcmF-I(Xu&*L_fxNr(Q{Z z|MIfC-Mob-9IiVW8_!-|@#oLc(-*=T1G*-u8VRy}S|`UiF?#a5-wzbu@2tA_>4(hE zfc9A#T|1WS-uKgEKP&&C)hF(474E-$J%8W-hsWo)2{4?MGMRtHW#f(g3J1<>G^xcd zxmrFYzwYPP?f3t4)V7PTL`I$Dog)@8!M&d^&_(n1TetduU(FxRSN!#S&9k)uCQse} zzq1YB^2dF4CG+-Pm&6}m-(-hR|GiV@hE^$G$;$(A54EhOOwT-PnK?~H@Dj%+mSa~t zLY5V&m5MDEX4QWF;>|0u15FI!s|y6^b zqxSLFTeJJRx}2t3Gu+j+4XyWduviN$*^u3SG8x($ao4nZWJW=APjMKtp%M6{5EcCg;xW<6* zXcE(B!_JVH*)sBPk7%VY^tf?!v5VUJmzAY8=2u%xl>&5jZ8-R&N=3bp>$w%1nOT)+8H`+fT<8~iv$S_^;8s>-l_GpGN4dwh>+;@rmn zrfS!&-Mrm-BsV?#O!r2OX%g(wEuZaG-FNP)Rb8u-yFl2_Dqme{?&g&yf3&59N+p*l z#T@POXgD^F^Wb?mw>GCE%3>3G)YqKL_$Ih0<(1Id5B!|!w*uvEC)*#p@qJ0$+1xpt zj*$yH-oM-|6E?w1L3FM&Pib$Mg>Be(e7ctj%+RmBZa3L!iQ%Wu zr|m*j%FaJ?YCmamD0Ajn1!KAJ(+bDpUao3*mZyF4s?V{R^7*IM*S0w?%CAdIEWEPZ z#^}d^XO1?nCKYHcS|M=zs$-{)^_#$Hd*`!BT<~dH@M(6Spv)Fo9MwS zIR8lIt)O;^9NRj6D^(uds_M=#3rPUK&ee|AjVtYl4vQL(-`jy287GHbovnf0b|AoU}_z@0i&wirFpkX|1l!{iYAf(;M2R9PrvFmoD*XOWvio zHIKGdT%Mw?9pL8bV-+3>kU zeNKV2uhQIaVQF4p!kky>?u1J37@M9$2)s;0O%lGFCASi=l0rFU=MzI|(7^EK+8hxD=xF%H2qy_{F% zwzs~XcuZM4-7Cjhtl`fpRQIdg*>P#hVv!jekIc|cx$)=Jvu% z%%orLcmAA_@tS>mMNE~mUV@_0#Wf#OlonkyYc$=p!&>=v#gmWc{w#ePaAS^J_4HJ? zl(Wy5CkVbSNdBb0_O;pu69r!N_w9?kj?J*!p*1@qDk>skvdWouv-Yz!_aE}s%+?O7 z{o#_8>SEHV`t$DYpNcg+bNATZ5@!`t4^Nr3?x1+&GNB`nYS%xI{FHohwPNRtrN5>q z{kb-0Y4(Tc&8nwowVZzZkt4%m`e(k(Cq*Bf*qRDXT~qnV{H=uj_TAgdHotfq?dv3Y z&t_}c?!AIvwJNgS@GNE6vmx!y0ik)1&tLzxZu1{aJyx!_t5_C^^LlVe`B^mT+}*dm z@#v(bebX-MPV~%H@=z82yW7gxy-cFzpn>i3Ppli+xvEca#r_JgDnBvrl=uUIeDOpH zmQB0APmOC8J8f@ugg5)@W+T2e=fA{vZb@4bzxBP0{W{)=^Z$9OL#OQT{nryL;`@8f zq!^=XAI=ns99(;1)m;xsE7SE8lp@brUEVZ7=;)^f%*%siJ{{qit0AoXqyF2`qZy6@ zGTYR8k2NJ7BC|%$ySM<6x;cS;nc-8b4);V#% zi@g3WvuD3<#^x9D+PWrg;raOY4>eaU&X3<}_2_Dqc1zUv$$b(VSUkJ9D^6?`I`r$^ zQstUl(~YWMeAPofCRhAgrsQ<~<|5sLKW}%P+4sWV;bGikpLDmR?zVIb1EX{kn@fgT zO0Oe-%vCDd9vN(P_*ucb$qc<~ALOWg4_JRdWqppG-<)0hjcRy{Ue?rRtDf@k=;*>PKJZl%;5#Ki zYZJi7GeEAJsL3k^iNIDX{1sIk*nar2^q&GXG{n&&9{n6mHro_wQc`|to;+S?k~$pmV{m_kt6>q z$F#V}i{U_Dnt+Vb!peM4iEE}JppzKVRBlBZ&CGW&&(fc}e?rEbycTti9VVhHb%hp2 z%Y00c{huoPKS%Y~{{D>kh}Z-v&^m>LxQac!>E&_W+h^4JYdx&+pLk$G#))a^j`Ay3 zFJGw5y){k#uYL3;E6KIS!W$Cg|A&HaoJdbegIqUpVNU#|1+m+@vk&y8?HA8JFd+@3 zU6`Roc3GRuu_cm?FNM|iZ*4h{>bakjb+Yuj!xJ--LFX={Bqt}&tO0F{2#ih1&II+& zBjS=~7E?To`$%>Ver%mshIBDL(MQhiBRv#=|y=L9!Ez4K0Te51+vQ?{33vhwP zH(-Z7R<2yOVEU>f;2SDd&6_=a z`KncG)~{c(a?Od;mk%G@yJGD+$YO-N{QNZVbr~Bst;%Uy?UT1@)0Pd8p#_JuP0f=) z*G(iRCx;Yoa7^EvTDzvDt!>r%4c1BPl9G}x>|8o?;p%5E-`u)-;lYCk4{lug_UTn_ z$8Nna&|wVj>7dIcwrt&ymJ;VL7VpEr!0-)edBUtU+gXnMKi}|+*@dh{~P}QKm7aug#Y;q!6zl0{0BNJa`)lo3&2N3{$I5mbi+i% zfAHoA@KKSaFG0f#|3G&{oJ&~=8e8b~c+vF#|Br7sK{r#+IefWPJ@Wtm%`VUX&${~m zj`z#=pp^+5{&)X>^Zf&A5t>W^%YIsS1CgP^dbrda=Rm3fUEsykGyIzJ1D+O@7zaqV!C zx_hcXfRWSofNN~Ou%Oei#m6TJ=qWbO6Id)iVXsL`r=$PUMf0!h?O{;tTKqhM!{4lZ z-eY)ma;r2lOyNRT zg3pPvwOPCJW~BOL=uFdlZ~BUL)x8Ot(oBj^zWptbnWSmOB7AzP?c=9M*C+&Cds>~# z;lZWo)LcNuaO$HwTJ!hD;KzJSj(GTQU707 z_DkQ+W3~SZJ%yMY-8+m#>e|;ea6H@c_nl;J|FNWx6-p16FXmXJq3-JFvDBDj4*Si^ zO7+!6|7P@0l$h?)rLgJ=x9bnHm?g|IQrN#?T}~V>M0xAmcKonar3Cl50&Mf zjO?o-dW{x8%{Y^;=HwZk=zC|E$Ia;OpFWpXhzMv1uj(o-N;)O*v0LUtpvBY^M_m4! zI2o&@TC9vLVLkJ+BtlZyh+|%*yuNa0nuvhOcClGg9%}fp_>`)Nb$>KUoA8VGg{#=& zgBGQkac(hDbtS?FH*MOrOKdIc?CFYM-7n}Lzx-xnO6gUzXI^IVEp{c_57-L_O!xU` z-^}2@sV_84Kx>H)`^}7w207KRHJeVJTd?J%!l$|J7v%M{A{IAEu(}#bvP7jYt==*5 zRL;B@qZ7tjOmot@rw3Mss-IfAoafC!Da&ZKtvUAf`-;z{WPYEh^@-=*m%B%vpZc=D z;^Uv6^PF7x0>5o_T<1K0*B+lI4?c9Ps+smvqh&=R!}@f7HN)oVFUue6o##&bl+>Oja58VIdw<+BwFE`3?@#@#c#+Bb* zT>NzJq)A6;W` z+$Z*dD$mqk1yRPE#n0@qK7FRgU!*r|-o+y0Q`c{L??3nF(8P-yKib=#bvduF^Zdc8 zj~;%aiT5XTo?I#a_UsjPfeW{~ln*j%7Cf|1$gWD;HuqV^e={F{i%IvE7n{0T>KWOu z=sRntY&q5Cb4u*fPX5d-eEGnIq|G|V-<&zbS=68!XPdWT<;nQzv-*~% z9(=)>kT&O8#=KcEk#VdC3yS5Yu6pTp)-`g%tak5LsX0!a?#k!)`EbRrRrJr(csF&` z&Ooy%vtCENEjkzbZTanQTfa(vJ#{Rt&~wA`Rm<8QFO1n^v0;nOO{TDl%*Q*w<-R@D zSH)OVHH&-YJhQkJI~}-`Zn7Rzj(mOpw!MYTC0?hSD(gd%GW91kC6qTLPO5vj;$QIo zejc~Qoqk;M(cRadzd1U~GDhH}gu&Ok3V}0hDjPn0nV)^uwJP-Swb$B{t)+wbX3Nef zR=7Ct}eY{Tb5!c%3-W>}12C-L*;nuS0WzErWnd1kV&9 z_oZ)7H?2`k@>CaE>Y!+|O0Ffl@6BQv_5`nRm1%uPn;X3xnKT2sgaaK5U4E4aJ-^vs z5K}mzc!9{|AAc`xJi>Bhf%Z@T>1hIq2ZhB{ikM29*k1O&kzX)JMdPqeuKNCV7rjWg zqRdU-jD!z4x>NH;z@gRiYMQe<6G3Gzgy$?{+-`?JFd3A?Uy1$n(Bm} zT)qG5jEqOF3fEzMwIGKxArmJqpB?_TP1<^W()+K1Z}-j?514X(VO7Y6)Ru!wcOGDu znlJTab|LTca|NB-_c;v?8m3x z?wqI|lG1d3Zb!|+sKrj-=daDRHY)AdQq3|^^Np(B$2op6Po}#$trNRlvgbyCy6=Z( zZPQe3!)NE*%2k$J(@Q&Pa#o1NHBZQ#`(|qMvVBw4ZGWX$rE6Or-yc%U9k_e<-+v2F z$L=~3p`|CFZ^S5kMQyUkda2ax+fP|{y>(zpP_yXX=eo%0)Umz$ZrYc$T`SyKw8~@8 zPfd@dDICm^DJSo3HD>?1>37%POR=VRwQDb%y!XBx_Hsqr#YZO(p85THh0qbF!i`S- z=o{kW95ey8%K+6&uD9KIwTjan2oP5hJblqE~{zVLYZ#7$+D&7zrs{F^&1 zZeLEgeD&4$oh=s{Z0M3+YW-FMz%|K)}^EsmErS8j@ty!m9|nnvf87h2CvI3#xc5h-(Hm^$z6C&A@Q zHZw;UzWH5ef8dmG`@7)J0t_WMZF_GHZq6{;Qai+K;NJa%D9#u^8c#~Pji zrBkA(O-P^fJj|H6L1w!}>7=N`yt7$dzc}!lawep|1_ZiX?R=<#=w4-Q1ncEZ$Na z$7(aN;=-)L^MVbR6nT2L|GH(aKXXF(`OGUyEs2tyUuWkR`0TiC^}w^yAgRJj=6+$+ zw7KTTMOS6(&yT!V@%7cs?pf9uzMK#EDZl;FHg$cLOEPVDQrhtPz-Q}u z0lc<~rsZ$%-ZA|xrk2dEBDO)T%J}}F$!zw0Y!WLEPvRF|^Wimb^h)>YV`9PwUo?lD z3GQ-!ut1zc`OKOrAq>J-ZT}XhpUT}?_~cRlSb4^md!yBaJ}rn&T(fHR1C^CiSPt4I8vdF-Cr z+wbi))}MP~6p?T~{c?k)Q%*{b;GKy{k6XVVSGqUr{k`{gv7!YBSG#@9ROIwml+NML zS8SirvHktM{r|1&KmBUIx+yW)w`+#zMuGWPt}Oqa(bHO!J!@OXo0F5}*G9g$sO-G8 z@=HeTq|51yOVg%JnDM<~Z=qEBc7wdN8#X6*{>WIl;Co%s|9^i~i)L(E@W%at;8b6c zvoZlk)%QuJ0n^tX@}z5{>mQ7Cg-rdf=R%_Os2(Ct2f$SWeiAP5ZYd3yWW4 zIAZZy%HZf8;UdLAyCc1}ac4DcJ}q2TT+F5U@Z^o76BF7qmGw1MRi6~jY4VR?W$s+o zofcK&Y0z!);Px6WC6Vi2OnfhK?rPXlajLmO|Af9_24g@6Y`4|J<~~DGyX%WQOo|zCANP z^H9ZvEgQ}n^f4U!8`0C)p#0-um%e0S)lb_)k_&tneLkYd?!VNGlOOHrIohIr&HQ<>d&*7| zpI1kYUU+ZfspPhX`LCgD! zc}Db-Y}t~uq7^OnU)zml=x{}1;ok2^ItGsWLy8!`wYX2{@I z0CYh@7CU4?!tZRxD{X<_iX|ay4}Rw{=T#R$q(CCM4FB>N{v|W~&u92w#P}nh{YnDY ziD>SZ865vJ8J2}B1?q}L+Uevts+2n^%qj|2)-t#k&;OxP?qR*jxz6ZAeQBq95)YMV z*qZ3Col<&sM((5(mmSlqc1|i>)s`u*q<(XL@#^Z(DDfCd6G z8-vUPGrd8FCY)FgIT?X<|5Bx$OQM=P_xES)osgwItCr#94u+!};42LncFfz~pYd)= z+UyzSsw=v=cg$v7*3GzK%D(;#UQzklRa05#H#6*E@YT<%N0*%`}lbnSr& z84TwR9PCf;?DD)=o3ZYi98 z^e~(;B_&1i^g}i9NeAjjZ>pZSt9JCZ%E^1W+fKVroRtOM_>i8OB75qQ(usS`OQ$HF zysvonQBHVBa&m^_-s4KgZZll}t9tT|+Ob;^Ted2nxEr%+lkU-LYR7J=oV=@h^7hV4 zS7%(hk(vnFrvO=X0P=GR)Ke+o%O*_M?=yv6Fp-jy;+(nBJ$`j~1t@e3mYwp9UhbT= z!LxLWYsOl)~|IVUey@H6>1BgSY=k685OkKp;vJWFl~{0s_BQ%AO<3=l%cx_y5KM*p80 zzhC%_^pAd>+l4aMza22R&w0q;4eL5qwy$$J>|69^JaYTt`=VLU@ZS`R1c!$D0-ygs z9xxk={}*G_*FVVbHvLP0I-8$Zmg@mc*R@BO-4tKlJg|KJ!g<^^YgqQ5e%aYMVZN+u zWT@%Hlghr$9aqYnJVFJZc8GoWxT(KuQAWoGSq;s0XHzGxhTtzjj*m~4n8k-w?u}VH zRf2DN(9Q#=4yw)eVV`}qZ2R5Qd6f}z{_V^8G|wG4z5UNyzp~k1pKjXMb@-t|-r%N+0d|TFUig^s%n!`$Y&DR1}YU=#?dG^J}Uw;~n zo6@Q|p0;P@On5AF>%P?4{ia(>zdkHD;vd2gT^F-xhSGJ>VVL}7BD|;RC{b1MV9LEdm zH`og|bnmq<+}$q0alF=%NAf^RT+5q-2XuLy6b{_3$vNWuVei#4Z-uY&m3#?53of=5 z?{QKpoBw~ALtC}QH6=-(0>!4q_oY2z<{EuvwK=|PmQHS)!6d0K>UlDXI_%oE?%SX0 zy^MEvzudg9Tdnh;-alpb4RiK6Teu4e{*#cFmX-ZhB`n_cvG+Ms<>9JVm(msqPYzBF zUVQ)6(kdalP182=9C>+2Y0FGA@vxo8mnlryxaGR`DwRLY``*p#m$|&~*0du+%#Wh# zr}Yad3BG>$?o%aW{B?^80g1g|eP3^M5nK4(`N{U%u`07Z*u-C)=~o{1!Djkn=G$MH zFQjMK?DVL5pt`zUywM_p)yUY|-2TBKp>^S3<}vRG72s5V+|Yle=^#gBL`;yh!BQ#4 zBi>ysOgp>Y^iMyRT)EW8Pk+wd%a_`ml_j6=v8NRI92kyb`$*RG`#6$1@+ z@7iY295f`x)_rwzaAHB|BUYS`_`TW6$j(^pHQ$Hoy z7izQ_d_JVF{2SpXVXMy$3$&%==M2 z&-h=-^X03pId_+YsSCXM`0~Erx9>m9#}mK=RUWhGzQ9L{#^`eE8_TjOvlam3(KcbY&(z zh`N2t`jz!=of}V#i$lZ20x#%U%a?zjviEYd(%f^KnDozB`DkCdeCyh#J@4lqpSQ{= zeCd^^eg;2VqAuS3dz`DfPu|Eu-sq62MP+&YfA6%n37hsau5j;od^CzXrGwFB;lhJE zKb<`vGBL*{aJ%9etrH@v1!b43O-hZsY;mD6jl-dBL&0?+NfYhLwX<%&cQJZ9LDOpD zu~iF0SJxh1<*`j`($Wqdc7@;)gE8a*+9ke_5PpgZAd1j+a!H!sC#h!1x6MFyRS^MR4Ohg*m*@@ z&-#uT@{gq_wBO&eGm6S9Z#gxDtThW*WXKy zoOjnsl;_>LgX)L(I;$n!mb2ed5Vg8KR9w5&v7bs_@=bi5_Urm{!Md82jyFW_8?pZ}jMjgB ztnn*{?KR5VbpK?Wuh-qIWwp z89KbYWu7j2a{i;V5+#v5e=qH7uaG?kK>6()L5v)J~lqIQ4a%*A&3ngNMZ z7PanOki7GsvUn~%Y3tn2>VIBEQAQLAKw;NuL>4Vzf1)`xGBV6Yr;E_nxuEPj@*vR3ov)>DSn!kR~J zzm5@=xV~%Jw6d93JEVj^SzPqJp7Vb41gGjK|5F$H%AF4>Z1P^As=&AMLQ;^!t15<` zDVvPKZpnAK@g7Tgc&??-d-|i3v2t>f3*-MerCicrP__)2xb90|h_B$ynwOWJou0mZ z_r=l|3-&JFSR$w$x@7VjNAa0qDwC$4o<2onclJd0DGx1EmUOE*t>pNd!IZ-P>*9}( zjVgNaaY@>GntF-5v$JgS_#UrYDe1Sglq2s`##ttfo*&yUKF{{PzyIn@^GUA_co+h%*!1QtNS-KX%Ez2nl2yy_ zJ#6{A@^hBE%Xb{@XL|c^g23MWx59Im9N{?d=iw@|7Y}yN;@Kp`eBi}rd0y6M_uguM ziuZMm5I$XB8}sbGsw`JTrP0aL8sP;;?n?>JlKtp)_j<+mt#ZNTyVQy{-RhsY(Y5WW zo$>1jtGB;CbaAfihG#zOH^-e=8oX;m(&E$xkxdq*CZAs~aPpepa{iNoZR;J0z<)K# z*3DK69^4T1y{p8$KKx00sb_A_L1nAE#zFn%XU?+P8=kq5eMVP#pHUk7zP6p-iIUIX z7F^xa`Ptv-vs^4=T;_SL%Q{~hUVWGK^tXz#XpNQh+Fh`h}cEMr!+y>dLE|shyb33F zfAaHYZ{pqcBCuOw%DP2|V-6WV+V(j#M0TFxiU{E=yE7R5yUI_^o07tEzU#}Hl2iZp z&Z_xZ_qR5DarLB?v#wrVA18D5Y5rF~mj8;PqKrl+W-uV-m$kglV$I>z8X8^ad~wv1>yF?HQH z(mZF)|y zECiF25;J|YW~bPA+D)31ViTxWkR|gkNO}FN6q_wYCJ`!o(&heV%m0s)d+%t;GCRel zBiz?r;|;z28`5rLORzRQdnuvj0=${)b6? znw?@3Z5LuDx;{k~wCZ4Pvc>E~izw+&=~mTqQmkjE*epo1vXfadZ|1hS36^?%J1xc6 zmE{$h}xE(Xdg{_M`|yi|n$4V*InD zOMCM@mw6hjmGp$%^DrmLJQ;Mz0jMk9nBosQhA}lOGda3EF)Sr5JtZXtvc@1KIVmwI zZFZvh%ozQoq{M{y_>`2CS#idV4fXkjMNv^vsi~=pruQ!1v=6?zV8NorE0!)?wrcgN zb?et|+`N9v)^!`#FI~NM*}9Fe8y;4j6Xo?u2CZZOEi(XL`>=HN+U2X)tXQ*l>8jN; z!`0_a?rWd6Dl;=P4s@pk=;+8bTX)Q_PoJ0Pot&J!Z1vj3vnDNBxoSa2*_2QX(6WS8 zt04z1EL#P-MB?P>3tP6VO#!cF0QnGnRRv@nLP|>Vv>7vNJ7$NJY~HkGLqvG^nl;NI zCncn$q*x`afm{$_7PrP2VR-rpFTAzy)-L1BrsubDSWSklw(4Ai2kgtsx0UK|8MyF zj`P2C-^+=2jJ$`v3oiKbY}$N9>3H z|8JCCl{Wa7aBS{nX^qd|#R#4M|L=ZTl=~liB?M@6;s1ZTr0oY6F8ufZ|Ju|4|3@l= zv}c1(Mku)lT88l76vRHB`2YWM!Bzk7ZTW)~r~i=B+Seos?Q)h8Rc6YQA|ppBS17 zxE6nCUD+%kx9_v4z<~q$A`d?oE@n=bs(a25AJky~;*t4@R(2cDACr}Hnc}WMv#;~B5{@{U zM=5{r7vKFLOuB6`!@Qllv-#fnIZu4B#pa;ww&(Bi=GUFv<+EGv@Ar1O{m<_$kXwIV zo}+DEb-|7PwPIo2XWQ1QJ##RZv#o#i)pgOv0vnmbldk5fa^6fjcw?5&!}=wHb8dfs zcQh%iye+^>C~UjVV-0(?Ag9rMB$cx1v%Kn@9xPiq|HsN@G83O>R4%iKUVUC` z)uoJQ(L1i5+P?V&i|j9M&xkuS^VVN~&(Busni$!3RjXQ}SDoX|X8rxFohPQP|9VTt zd`4)ybE|aGXYTV4w*M4Wc|2{_-ktA%{as}x;?r4FANb^h@S8rd?BZFD&Mbn@8rh>x z{f%jxJK@$GKY_$OJhPXmG^L!<-fMX`vxSu5Wn$X4=kDvPJ<}h4v)Wu+Ss1Z{NOf?X2OGOPQMG z<+0i3-gV8EzX7fDmVL>VJbU%vzkB9UXPl1rN^~tcbjWCP#JvY4Ok!dFssCDxik+XD zojJpk`s0jMaJ7ukZFlXcixfzdZggSvCK-uU^&N>`UQZ?;AdK zgdTeze)WL%^^W$}Q#-q4rv7~?wC++vlj7C=E8Fhxj(aJmS7yL{Jaw;Dg#C?^HrDJC z+sr&Q{+-ubzwFbg(>6~+zut_!P-!#gtF^<1i5?tk^KU;bow(nl#P`!W{j%gU$?sli zN;G{m5c>b=meUt!l~0PhHmFtd{uU_lvsL+M!_=j_<>mcb*RFX@nm+%di_zDLC34T- zT`cEg&HrgGer)2U2_a?BL1g&J%1k*F6q!=M{-1Ici%rSUfD8apw8u!ih?(0VVv|dXwiRGf!*Qz0J`(bIro+qe6;? z>V7ImZ53u~PCa#NIZyJ9In$iCm@R5Lb99nh)Uhm=oo+T>a=FLmH5qOYKI36O-!@9rNX{N^vf^XL0hMwP;so+om1crfE;p@GYEPW)%>9t!(){-KRgdrZ6o(yJyYH zH46ha9(mEZuW`$}Z|w2=>VBUS<16k@5PB1`<ggxtYc7uR8UUIi*_*KD0K7&6zhTG>tLvOUy-^OBXl(XIW+( zS8Sf?`=NZXyNK-V&6D;i=}tSPd1;Bzxm^#K1;x}mk2&05vFYQ9-mX&Z?LEKMUfC%a9RIsL&_kv8>w^acs?O7ow6X2t=-zOc zWopOF#(y)Gq^R9;-Ol@w;r6Ce7AtDbYq+eElfBaCe=Mm>$g@*1aq|lm-NYm&T_dY2 z93?wt-+3Jq`^~;sKviLD)ZYoa*J^YgN&3s&;`<_Jx}OktEVH;sw}*1=S>Nw>3j&Q| zzWz7j=nU=e%iij&@ugSGTggjga*J;Rd-NqWS;qAH(VFm#u-yoZwlUmvZ-*0|S z*E&Dn=d#I;*>cOTE2MIt+2TJhbFyPDE4$U~8&7+@-f92Z&^CX;gu9{vACj+5pXHk_ ze1_vzrR{;1;|oMDCnTJ{@#NH!&W7;6Ik&spCOp@Vzpz5IM48t+L&f;*i)}^*FBAPg zY(6G;y)S#u3WHBxf{RvE{QPrsjbVnXTmt+2X<{{R{GBdzs~T)d%qxs6F>Vj9{c`g3 zbp82n=hX-7KF-Wham$A949{$b1M6DuW*jkjJk?^Mq?B~^x`i8Ot$e4Y)W;XM-)_bI zONXV{xa@S-njQS}c6siaC?;XyA6{Epj(EFz%{+0H-Mv(6(XxUS(Wd>%#<$fNrFTCP zV>LLG8|~(Cu;R(<@a*Hqc?GA~KG61Uk4Sq~YM}h6kY&T6=^y`@8TJ@Yb-N*OHTrAw ztVXL3<&&l~{%)9|E}(LE%cT3vVRtl_)$7eGnjPLRQ@=jWxadz-&I_j07so`JF8@|d zOPx|375Bb5fuYv^+zMO%1D(n6eBiykeWvK+ zLx*QIn&0YYJC*Fm*=ZY_vGlR2(JG9Ei1%HmgiZ7>8v8H6k**% zB1M-397Fe1U$0#^YvPg!W=*AN$u#c58MAn0N@uRj3{SZbut)j%xw)^^0$m+VoC532 zbJNmfd~~*nG_jv;>O3o%T~_^Nwdl8R^HwSC%DB(3BGlCVn&tWm=g6rirrLY7Oqr}d z_mXCIeoFaf&kcv24fdBA_sZuS5S|{*dAIyi@5LqGzNAi6_pRY$>zlVZX!<73HPdgj zi#C{>|}dd(I<1L0yi|ne*e~y)NdZ5!gfeTVcXHxkfyl# z8hrQomvl7#PT+6%iW1szy>Z(%_R<^a$EOLf`_-#tIE%?#n5?umk|n)B_0p`rHWr8O z8rdd_Te#)SoVVaXjc{7ZN6V)IbrUpIA2jkS%5PFTpetoJ-Zrz&oikJdD(P)`GZ2v5A_N=KH0U#DDvKC`Nw{9NwUPRuN%^_ z4K<{72Kc%2a!GM9Ffj0Xdbk8JFfep5FfcT5fNqd@Zhn!Mfq@A=)Q|@{MB#rf!_O?n z|9K4ilGOg^GW^PBf~;Risw#slVfdfN@Hdz7A4G8;Lw-^+XgNa(!~Z;n&q*97VtBSk zO5cj+o)n@XuB4}{t8Z(pmt(E`zkuO$9%r?WL57dHm$}~6T**!8dh^q4mS@>L&*kk+ zc2QB+iF7cUmg>+PVdbfg*(o+}d!K`OTa==FLvAVP4ceJH=*Zs$Fwss9R?S!`{WSQf&4n>&{KK=33BV zI&+iKv8${LTGcjnrKTjU?lk?E#IP#X;D0*9q9n6<$(EZ#)n=yHF`PRvWs-~7ju|tP zZLQZd{PJLc9F6cakg++-?}HyhdP>s4BK3;d(J4qEDkV2FC8|5cBelT%Y|H|-L-`Bm-cP0LMt zoffXv+jl-CC1pd9d}>OP%+)t4C-2H!d?A17sp6@JN@qZ87F15&RXu+DZ6-%-SX@eS zlHB=ckcA8&61JAXcKr^6?Wa7Z%}L14fh=d>y7x!v)B~BbPZZBRO-W9+TDeX6*zM%W z9jYg8s~x*#yJnl}anN!GkRhN|4EIz{-u3EVIW5L;^TjI@Hk}eXb2lY9IV}-17y|Wu zGU)gOg)5KDCm(WaT`YI)d1?}9@dapUM#fsmAqrm6%Ux18ShwzWPh6#V?uo|1s~Pbz zP6?}>leeTMB_3EjVZriQZ*E_I`R?=Y&ubJy@BaUP;=BK6l>h(xA2B=gj*QJL zP*)#xM#9VK|NsAA`~UX;|Nl?^7ySP}dH3PD|Nq}x241|d7COT4-y`#X8D#Z>RU2rz z0ch>QN})IZ?`{3__R{v=;I@B1|Ns9r-R=7S`u`38=N!2l`{es=>EfdQfB*k?j172x z_3Qut*8^Tod7uA(!~g$n|Nnpg|LKME=Kue-|NsB{@c;k+?;%SUPR9R#ma4MbmVtps z)6)fVtU_qfVFLk%3#QJS6EzJz(%L@#?GJkvw*U3Z*%!A@duV^D9$tOw%3*O zUeA`&d2uM>A^Z83r8Bbsq&+>LRP!e@`2bVQpJv7<+kU9Ccg*~;UG&1H@)ZvP_&d7z zrRWwz&ACf7!LDY8Y*ayaF% zZ}qF1H_J0;Jzd)K^r{U<;Iv0l8J5du-;O)tT3vqsoRM5xQO%R1dKJ>03l$iCuQ+qp z$e877@r;?0w-RQ~+`0d6&h?_AEr+K2PvLMk*7sPK61TXWOX={2B_U_@k|(8j+O7=H z@DS)dmSGgFleYToI|ts!F_%^vZe9{QYsq0B&DgyD>&JiiZez&mS&-Ms)2u1GQ=rvI zq|YUJHExQ%bU%*J89(aK}HNT7lL>68)(wLweW*b<92# zb0#@jo3AT8y4god`l+XdeaVz>GS8+>dw%@6(ncMBq34b)_8%N7n6pSAxBtK7IJI;=m^U_bTb<5e&1Tj!L^dANu_`EB!TmO$#~ihr>kEV4_^ z6kGf(-hK0}_Me}VEZ?iOGWZuOPJ8Gzefd56Npm($=XtYH%y7Et_b6^&3LB%LyhrVf%OftBUJ5ySAGKa%#G)V*V`m z>5rVR@|K|2>dd3tsEu@y_Md|x5b zkteoPP;Y(ck1yg;I~R&P3r+Fz2`Y+?7FCk^xjlNV-})fQ9<@!Yj;y@!(R1g|4epJG zr^_?yTWvS#iZ#bwmDDu}J2E*uqTbcS^Q4*_*Xlb{ZQhp8zWcCbr~L(~prqvm88sOW z0&LAMCh(}>1gW$2p9XFWso}aST^<909+aY3y zaKt9#)!Ww{auJq@y0N2c0c-TvE#dN zl{fk61*Wt|h8*R1*VFm7=hEwHZgv&rn5C0{UU<_PTevVhCp{+Ww({lhXp5~ZhO2vA zwtcAo_AoV9v98=rW}1wk;E5G%df$%NF>qHTE{*n!H5IkAQ&hUW>DZEUi}SWbNnf3J zm!pNxo!57*3d<9l1!v0^_xxFZ&ZbG&a-YG!cQVg^?7yG=Z`=CUvx|3F-d^=6&dyIX zv3bI725p7Fr6GqEnnPO6*>5!Lv3xHi?tMTbyZGGCCz5AhFT9#{cEQ(^`!BaG`}yqa z_4WJHOnRjSbzOcv{+Q%B^}*bZr_QOHoXQk(xg?XVZ(GK7yq#!lJyXz2C1Rz}5}6a? z3C$;d@@#y$bCQ9Y-@J}>Kg6VOsXf?y>;3y)38$=jf8Wc3S$iEVoP1etxql4fbS}H3 zQ~AitKftWlddDr6{o7hHR&JSgE&bb-GmN($=GrE1npPxpOEpMMXK&(X&){1Q(@biX z73-=#KGScmp)yx$&DnEj&;AcJZkLff_f1G}p_#bGiQ0AP4?5C(cCWuaXIn7S`9$xN zo{a*&(K9YTKi5CA(9bx_I%_>jaUDFV7&A3euwSLVRR)4;)fzMlwAIy~768-o3f9GBH)#$vGFWass8(4BN8OV)h;r*q(ceo)@k zX_E+PGu+1v`6>ai|)fT6!deeT8DQ=f#lpBAEx@WS_j-d;0r& z=7#A}F~-er6C->%yC0P}exJfA6flFM;MO^-xhy-i4&G3h_kFv(0{{EDX8KE3E!}Ev zUFkAo@nXsF*(PrV1XVZ68-i3j@0(b=&6&}y<9!xwy9ZW;iL1hVvoOk+vmQ+ zSj+c;W=B1nO#J1^HEVM}Mm=xQxgz8_*+odXn>T;5!nLh@HmXU2f`0=_!U_~b8K0H5 zP1hF}7vHi)qUz^k+xgr~{r(zDl5^dqa(U%s}P7VQxy zvPBYC{Kzeie_y1ucBxL!k`tF7YPGE1v0#1K2j;*N`n&QvIr48_y6yf=S9j?&-D%VO z)<3)AnNgg{^{An?h<*RAzdrg^Uthg_R~Cw#uEV9bgK-`=vz`Lmi<-C2I%@>P}QdhWhQicW`@ z7zfT0WqF=IeZgPrIlcd;9XGx=!$qFG^{Gg~l9TGmZ1L6Q^R1pQjWB*DXydm(I`XH3 z(h1+d0*8|y(-;3RIo%+amfIwcsISOayf?hf&gmpaS^B&HsjlMrj(G*~%gThL^(_wdta0C2 z)Y9R5rnFqiTxna%(iZLayY|og)^$AFaZ~z7R*!BAi%04_SEcWzsa$&h_K54l{9}5v zxi!lxYbSbaez#tzZP)F~cNEU;c5ai=C$@d26YJl1lI-ULRo zE*VZXsU5w}2g_^s%jK3`{H~H(zjw)=*WHU}oL4Z@I=o*YN<(t8Nb)MC|E&KQb37NX zW_vQt63cJ{_hDj&8-$^oCZKB<;ENlC7`_WJLj?Z_GyNB0cq_~X;ih;yD=R1{D=1u* z;X5V9`Bj8-qND&s1VSczK@}v(OIgUt)+ot5mf&=^GSk=Be=EU$P)}i&l|ezUSGSkr zK?wnGO|?WXXLS{oHP!~!CPvu-?ghbKL5?=c3JP{A`O)%sQ|14AYW5Tadub||`b%F( zmH%&|5K$296=hT4D8Ix^biK9Mb{B;Sj*d$Ug1u7ZL5C?o$bw+6f?zKXOV4nbm&hW8 zAwC7c-l_8c!=#^@iLN&jU7srdKTqyMtX}7A>S{(<%+1sOzFykV6RGl_YIP^kj`^bN+yJnjohP7Nx7^c1reV%W%AOMt7gxe z-`m&M*xa&o<*JmFltoLILDmyA`MRd0q(Ionw(Aom9#%VKV zw$|13wKOhSxoX~$6^BopgV-`>{(_||S2a#tJ%8z{w7NB}8Ef+k3S2YRdStDQC|Np;X_M!g<3bF71V}OAF4*$>Z|9>AO0aE$@ zzDYsK`xb%u@Bjb5YT(dtzF)ziVE+=(Q2_r9{`dc1pYZGde-N)=zW``$!TtFO|JQ>L zGWc&0kaU0k{rBhhHxxK1ECJn_An@Md|Nr~z|NmF$zaH?n|NrCv|L3>v?oW9C|G&fk z{|5X2|39yl^8XtH1IGqPC;H6=W+4_w0hfzX{$FoA`}=;!w#d8P;-^0Jx2XT|+_dOi z#wI=)$xWToXPDx`B&E+hD{gOc*O8Ou3G5JJ_21Muqi6X_2k%3o_of@z92a~dkmBHZ z_%n~flSh?80#1%jORAl1>=n2;7i+|wRXO{~hWigw*eR_OuP3Q3Ir(|d+p0O)pQl=V zuC+h=s%BZ!_6z+^Z8qnR7tRy%t=!E0)vQT^cM4ahOLAf8 z!p)p5suy0nKHDld-)q?=m8pTtrs*r_bPp#FeSm52i5-&y z_5=j^WGB@syvq(%p2+0AwDd1?vqBEX=@&7X;?vZ^+>X=!#(;p=l-oFw*Za!4|G`c9Tf&Dxcqwd}RjY{o$0y^|*k`(6k(SbFK}*Yi!R z&+=m0zBcapDLw5Xzw4ZRXL!XNZma=O@%tDfy+8ixJ-y*+`TN$%Jj&~yJld|iS?k}! z3SRGP#Xm33=2l#<`*VK6;{VIIGoOEF`uTs-vV;P~yBC)IiRRlB$1p>7_dDD>NxYK-# z^*28&+g)CEdFnTdu>q)ygO}LYsAI$87f@M`FPc& zp3QWad3*ki8`ElaUHP_rjC?(@e_h-}Q`X4eHw<#v!#H~DKL*db+G%5#`$^{OiAkYy zMJLvJ-shWVapHQvrrc{2h3Tg@{hi`x@bSFw9QCDh*4$mxR3oKS_rCAXbGFJnUe|d` z6lY$IyLC}nyU%`(;hg!UJRU7OKTZDM&7?i;)Y7hJ@{^=)m3DSA7<&-Y* zTkUxZ+qd4zKG7~;$H)8ZV!-<>t^4=(eKW1vQ5j)bDs~}ftMy&pImR=~-!-1SbZy&* z6U!cKJm_>GJ-yuPiR+86lCzg&9yjpe(+o(C`o=Zsj5I^;v*5-l85>x(J?Rt-zR|Sh z#b%ao$x7_)xr%pMr>xlE>cSP+q@ZiXlW7|D*(Ga&SUb{ zPM`K<%?dqNxIM>czVliR=SPMQ?-=@?^M9~E(DrQ5!7u}l|7QdZU#fI_=&mZ8<|gs% z(((tLFN2mGu{p=#W08I;@zW-yqC&~778_$%C8Tob@NHb_GO=<>?BoY4gZZ65OjRl> zt<{LS5z?N0Xi>_P!W`rIvpv;A8|HO*I_no1O7OULGhI#oc=Xi7#azG7EcUR?VGBWb=X}b#b?fexuV-MnIbp!v}ezdJhwmDE^xly%TDe$OLaC$i#(}*P_nzjaAVQ3 z!#gXpbP}C(x^7(kp}SGyz4E@R`$fffO2q7c+5gOKj}`?b!t&-P36;@twOU8dahg*-cVd{=f>}~qPb7({|kN6-u*+4 z!EdF%Ba5eHiI2%i^}OYJq4Fvf-fxaFKbcgpI^SDqe`T{+?x7hbR~9qxXX3nZOQG}w zkF&7w_Fr;cCQDx4_1s~er0?hC_=W%IG>M&8+Pxnb-FX$5;w<9QvrPFYOX0IUJ-L6m z<*vK$;TO(lnRw#8qoV<1`>z=XUcQ;M<5sC^*s5LYbUL-%-Ub`h39Xn(#OjO9#_XyO#32ZLWb7&1s^A!T35bjj@RtQsmj;8PQ;(x+psyzBUW5^O?^?AZ>&q! zEZbSkHTD5JlA=ru4TUau{mrfuIcj|};qXGOPr}~I*8acKq;zq=OH1<0W0Q{F4;R-l zooMFfqHN^Ux&QyoW$rm*TmP#T*~xA>6XIsW*>7vs?Dpxo7*{s)?+Yc0Doktgw(s64 z8t_`{f!mUn(u+^I@0wk6j@|bm-!!dJ*^!6&V9nb&V;`>;_sYiB$?xTyWg~Le7I^P4 zklWq-b~elQAcgC*SR(cnITx=mcCJ}kxIm^*@oAgby+?Ny=M*^k);e1DJxS^oZ=d&n z`?rtJ?7rKqt9&6?`(kBw!(z?l){$R1R%bh`3KF`*WHvQJUNGf@%m3Il`nOlD3H;i! zbg9LWr&spUu5Gh+YqI+ zA)`v|nPl6=n~qmvmRz)}KRGq?$zt8suhTWmj@)ufPK{oqaG)-6@=`OA5^IH13z8ag zgnb+i=3cGTIF|VB;iM~PJ*SK1{jj=X z=PG&o&BnXS6x6SA+|+De!sEvs@ z+h0wQT?-b+FrQzl@1ghf@%-u7+Va&zwB;Fp!`kw>4FADLtwW~>!RN34%?8gW!X^qK z3XVl^Uk~GWo4{zMA+M~UuqIN;#>7xxUr$|K-P2t2R+dOtm{moHYeBGAx`o*1T=v~5 zD(=?i$@a?13JL|mUa=ld1;Jh>73q*o%#1td3GQ63eC%35u$NeL5W~*-4EvTaZk;W) zU}1J-5cBdLmPPFa!Cul6tC-eKV%WC?(n8nwbY@yV1;R~Fh${&8@+m7|S=1ggKl6U2 z=>L3%`1s(0V6T*vGYil;?92xNH{$S^O*nt#Wvf?%)4Mvwpb z4Aa6)AT8p8U~dQ`B_$;*F*YS7r6x5bB_-u-mRw3oN@7N)=7B3}$8MQ!*zY`Jk;(e~ zp!u?+w?O2vTPu@|Qc^&dwnMmZ(q_fxkh*4wR9rzGh;j5LM7FIoKl0oiqZ7AMQc`S| zY)nZ>(b;~{eDa})vMSe%wJurfboQS2?wxEk;h;<1Dv(IQTGx!Vad`#SOE()YIN_QB z;yRXW4y&wNF>C6ISyR(D?0_`Vn=jvW%HMeH=G__B?p0p8d+F+(t@|(aEj$`qz11~i zt!KuPptSy|)N1cFOMWvjFf0SN*#!a`_B$;5Z}9%U!uf)JP+J^<&x4rz=l?JGz2|>V zvVz0^pSR`<{Qv*|{Qv(30`LDvI5ZfnUk_H)e?LIs|NZ~JJO2OwpYUJcfB*jd@Bcge zPxv1IQvCnl|MTnn-v{g$FxcOa;2`k(|NMgg1?TV22lWp+)`OHRU;qDq>-+x&^Y{P1 zZ}9*A{{R2`|NlQ-a~|xXgwl1Zj2Rd>I^j+ArUM27tQR=zgSKCs_1*sQt!GQR%NzNB z?WlLss`c}96qW3bz80W*=#icF3byAT10KKnzT?Ty*<0lNUv|uV@nOrn3f>Ag=QU9_ zrv=r!(={JG`KaUD!!z%?z+yRl1-GoduEz?aoF`UtD(VP6FS+U-#JBKC?`N$^5}q-) zdZKR^vK-qo+3B36&h9=7PX0G<^OrWyHD*7Zc#7Rx^|{a?!H-$J)^<<#>P?YpZ&YY_ zHN&vP;5b|5;WIM2*4umj|ChJ!b7Y(vY*N+g7a0D%DC=h5&^-!%A%Rxl6?sajis(D`L25+Fh3{Hz@WIta;rzf4RzGQ8mE>PfuZ^cYE~{U;9C7Vi>II)Y>i+{7c84jKNt%c{*(6W-#!wl# zO;qVfwC;Y+Z*O&57fkQ*lV(zTEuPHn_+DZzGl$HhX5ny-sznd0cbv0Xs}ydvh`&fi zcXL2kT$i@MTa)%8$@`~w{&MQ*->N(P<6nDAOWViU&klW`rROfow2Y_d)9G00XUjj> zrn$7qM#L`L`~5FV?VL}l>F!rr=lr&OVx+cjg3ZU6IcuLg_?!IMZF%7Noc))N3!lHf zL8M%bX}w-&{fWhl$?eJ?V&^XKcRKTI-RpDxE>Ae$&Rq0(;TrW7Pg*Ce;IiDaZ|BY3 zwrwX?=>CuWF*QL^C{*$A?%!NGFXyn!XJ2X;-uUvXbLq3I_qXx7e*7)FYx?JVd&^gU zTdA{KU9u@vBx-}!>7{8tvy0juIi|ngTW*)e+Pdq>QU>XqsSp1L&wjuz8zUnVqcmBs z!?Cm`A<4gKkA%^aS>m3?mwQmh3(Eq6K2y)8HTol2{KY`vks(vzjR$yUqC3>r-x zyZ6lbq?dfgQ8A@B?gZ!0R@((U!p&Eb8@xC1R?hm7qVD}c{bs!akM^W}cNFyBp2<1m zP;|(-qQ9bi7Vn1_eS+tc0?RhED?FLJMCG!mUGUm}z2Xl}3vKfiY))WQZ?-IXW^SrC z<81A{6F$3pmqr+Pdad98kMqjT1ilGRE}i~({)*qUN9+cfQZ@@Cv$tBu?qMsgVXc3& z>fGiQgNDw{2RNP1ukKE^vir+&tLA{u*KF$^p9&6>ojs@4WhpWKUMeT9bMSD}>IKrw zvUW>&`8)giCX`q2j^^L3pt~-~N_5i+_bm?+FFw}XeD=+MU9XlayFW~L@rlQjp??q3PM-YUBd`(*D+$uw?uNt*V+ zzUzZiv+5hK=!VuKEbAX`&W`i2%@#I}D!ajvd{bNJ7;j{osNN0!rl=&Qr4z17-8!;4 za$f582|QK@qb4nEQ&&pW>@;niFtx%~vhYBHQBJO=;|UG+oe6F}Nz1OEyAv_n{ye)( z*W<${JDPpY6){*%DNwwk6l!+h!ji5>8x6H$CVYui z{HEqRbAt27hQq#nu2UY1UT+jT_>X_r*Eh1iYr{OAzHm5hXc6}?!qqZNQP%B-{_c03 zcV0Ou1n#%hev%?H--=gJ`UdOi7tzg;r~XdJt7MT5Ow;U3O`7f@o_^&s}}f+@$lG74n#Co;=a(W^hkc?`dqxBlj0yC-zB)Z)W|-7B#TR0y@Pt?9w z6WDskp=h>3S^OEH$hw8<%H1a~UTSO+o^f<`L*Ln{UlNOB+H)OPsupOcS`=+R?LR|g zKg+HuIm-^2ISOB&pns%Usp3;)kCDiNoc{2`&5J7jRhV*}Yx;kn(OtlN=>r`zXBp|m zD;1W#{`&jxiKR+iK}CxX>debN6!swghn>jFjj?y@v9!TOmlDwiXZj9ng9|YH7hw1% z#s=CZ2p(16To(fwKnIZm4F7o;X0|ov`Z$~wXFZ`O^H_q*BRVkG*CyA;F~>E2Vr@~b zk0S*AXJT0DX5sGQni%X}XJv3eOyIvJ)8V-qbs;X9Zhq=odIHi$zXCYER&)QH$@}}D z^qW>Ry3=lbzPJ8#2TkJmlgiq7JRfxH!V~*Cs1p4XUn|K zhCj2#{=eekmI|6#tx}z)JG-;x?-A+$$Az~}l>dKNJlml@MdE*=(Q=UZIguX+7-#JOFq-w*IC>g!n8+djX$t-Yo)B(t<2C%dAkz%w+b zA}_S5qI5}r=YLzK?1J)={Jg4ytl0R3=(zaE*tj^*_P>SFtzNcf?W*z;vm@%!PvGLrdxPSZEm#kc~ZGF#y^;I*QYnQLzxM0Pm ziA&D*&RoA?dc)lt#}6Jpx@y(p?97af8&@~fO>oUvYn`yhEOB#A+03OAy26WA1!YWi z$k>|MwBhZ=hN*RB_n!T@c=Z-&ci^+<-#)+A3tN_+98-{T|NsA=_y6CuU=aKL z+RzIHDv$pE`2T;$_5c6>%l-fVe>cdM|Np^@_1Zy-{;&9d9kiS8|NsA>g?3;e+7s8W zU*5XkpMgOz0n)9xa)ou;BLfDu2Un!;D1J>XEH8ilPkh!H?RU5K{9KS%FY?D#b<8q=f;|~0u@s|_ASo~IN)S+N8yeqi(s64e4WdNv@;eP&fZ(9;5XfS!?N|eY~|KV z9zFQuPs9OH7U_ir3QbM%^IT;nJucVP?&>nR+vw=)swTt6{X@CJ{>M_gB=gzMlVsSA z1giXu|6<>D)KtHuBBVsG=Enx(Cx0TWI|UwzxGBx_O5e2W@a)s#i@bD}t(eu8_f%ur zsi|3O<5q`BEq$hb$sk~pdeGXk<Pp)QS~WT20$G zUa1HQShhLOD)z<7j}lv@O({{(~%*1#znN~+WV`Hs}&U~vAw;kq5efDqn_U!e6A8!Sl-cOMJ^=wY{ zQtLJ~&;EJNqT$!o1qDxPYOdVA)<^HemzE`rM>1C|F_xU^$;INVJHCnUJ zdhU~L-1+N1?@T%S1o8c!g$y&OlDb-F#hO*?R zw(by_ZIUd=b9>U|sOb7xGqfru5JaU&>L3n z3tK#*Wt+X6s`45GS=RM(T=8f3H{+c0!zNSvjBZcU`}H+%8n?Uoc=yeU>EHh*{z9x* z7Ms79_RS;T8g%T2dV%?tJ2`f{83MZ!^ne zkC(?EUnnTjEOI<6;NrG|F-h&x>6c3~*DtzwCFu%}qQK5MRc35{8|Rp{DtRu*R5K2B z=3%+F>(e?%cm1T7=8X>Fp_7;m-IVsq%%3npK>i}*Kc~b6!D_3uHftNL6PJ`=nRMFn zy>;S`y!{g<#~<05(R?cMn@hipWz#H{ze4L&F0$G@e4S*e#Ab9WrNe65(Kv-Z*8{wp zT7EFi;}E>-G51&Kyj9`;*>6~#*0udPx3QY>xU{#X9*8OOvK z>bAXBGMSldI!*4)k~=aTE!@|{ZzR?|WNo%>xif*2!6MJ%PV&ct&E4LX&jL(l3Cf(< zsdwr0v4>mBm~S*bp6b@GvaF5y^Q+XQVXJqy_{g2f;90ogM6=DRb8*=pzu9Dkvn*~e zE1ef^zUI}IU0X9GIG=p-nC5o=%q|({+@7yY$A8?cZeTE+&G6w)QQO64!LUlx_${oa zC01*{2^lrkSJdXErJY;RD5unH+rY7Nj>*KM-}ug-Ek4|nX=l`CS-N(5*z)w=Z!JpG zpKhCTxY0uG?9r8;ckkZ3Z7&fQDrGC-c=JHvRs%kst|yCPSWFGv_*!E6yeH(!?QVBJ z?&X*;sX)f(;vbs_Q*JQ3D{--`J##~?pwDFH43C7v-%c;ypyJr*DP%P5s?Ch}Ymtje zmmg`gk-mMi^68vYEjJ$9Y)DPFKO;T0Df{FT%LtqBC0m6medlieI>V;o^S6Th^5xev z1&b7Be|~RtM$YHP#o2d#H+DSF?%Fi-%JJXt@7MpR*s%Nc77j~+1H9a7{Ocbt_Lu** z?P7gY*P68#x3u5U5_xs$U;2^bhu`iO>SR%Rc3bkZyNUaJ`}!ZBxESOfEIp{P?-Eye z*Cvf;m;afoeENI*{M`Klmi!)_2GPge@7LA1bTVuWHQzr$_3h6KD~jIT$$!#V@xSPH zq+pRk!am0H9S3yY*Z=?gk9(Hjf%DPt);mu5_U(ZD_2BXa?JN^NJ3e^g(emGNCAW-u zl19(tM_s3Foo70}G18G=khD@|&9t?t0^zA?Y0vnsoVy{{o|(qI{N-j*zb9Is_dC@6 znrAHgp?>G5!<(L~J(ua(`u>&$&d!^BM+`Ww*q3~K^l@{s;klh31e1i4 zcF5ahMO|WS4!Koba`Mvo{(bdjv0p>(9}zAOh!!}k@XPhf{HgmMXj#8pe(Br|jkLp; zr|VB;TWM0CT2xe|_u1f|*HgPAf_51O9g1x^r$Sq}6jywkb29G)=IhPqV!aGCb?Jhc-&OAi@{Drj(}a2vJG)UP%RA(9eB4^r zI32sOB6eqwualyNqN>NnqFH^W_G<#FTjdvYOlUqaqr`>PDcJ9n|E)^Kz#w+bh?uGB z$wo>k;zr_2oN@!CW~DH?El&1}s$Apb?ylTYAR@SF1-s;73r|b+ZT??Ac%C$v+&JaI z%s-cT8ZUduaBdQwIeGD%6`BS-!9V>o6s)TYeI-9_eSf^^Y-ys^t^I6&mmd&Zs=mTL z+r?t)eaq@S>v>Mr{)lc9uo81=%yHMRVQ ziduQ4^6-~au7;+4ODU>8t*On;(7sA&l|++r8;h{-$t5b6rGkwgcV&NTy_Qt@?XR$n z1Mi_Fs;_iwKQ(3jyYSb2v2>7Ht!~r$sQTYN%{DvZwW?}19y-*alsO~fKKl`;4xgag z?@Ds4r-o)JoNo$xYpdH7>)rh4yZ!a|r!U*SiC?225?Pp49u{ZRG~uhPqk-wA11E+3 zqs~k6xk~VD)YQ6tw%Szi&7qXIESC>tHaKrS-Ul z|E^0_$JsA^o;oFI;q8L~-3(P*_h(F4&h+F<_sf-07rSon{2-*7I$fns(@IVCzR;0H zZUVo!oU9V|Pgh_+zPHS6?e5>-*;X6pq+MA1C${;|+b8=x9^~w+uTl!O_x{1f_`RALD-n?9)AJ!pJW-j@e zspafj1vMjX`<2IxIvtdf>N|g2J+Hpjc44gKqP@zTpC+HzQdrLaeDlpmH;YvI{OV1L zsuU|aCv{ym_!Qf8)=l8SiND=*I97gENebuFx}AL2^Yu50lu4=C3eP`3@7|pH{D;Gu z7xH&H_5@UQE(zM(^`?g1W0u2)iJJqSZ+gvACbfK}&ho`|4-b~HaPAB|Y2o@XDJt$zO3aD44?SHM%nz>-_Qkdy7%{0@7`42 zpa1TigvK*%MHjmhOV*h0it;PcZxOM+af`#rx-NXJ!j4O-e5b?MlU;>2E!bMlA$#!M zxny1?ZSJC}cd8F2gyz3<+6&Wa*P4Vyo+2wJD1^T9 z&*Kzu{P^$g?2EC%>@IKERwurgH>q>m(zBaKxd z5ub|YBw5G$l3!oW&Suv?_gvoYjQC~QD<2z@RgWk?4v6;-ZT{2v;<|&E_!?fWRh}t2 zszKbH;tI|sEX)7uGbE|y6mDydWo5G3^LzHklWa31ZX`Y}yXJ79_1tWu%MrXn;(Y~k zT$Wxqv-mZCdU2xhhNG6}iuj^UJLb(?IP1zJ=iH;xYZ@cc81=YLuiDGRlQ2Q!Z-kdu zpq=8eb0v%dOW*GMRI9e;`J*=;x9;vXT9h4ZIkRPhtav=z!9qF5v;y8I-=02{W98BN zCb7Ne=AvVU{~!H&zux2b-?h@G@;VpttW)h+d5znY&o?(W>*tvjaj0)+SW@<5 z(TCejZ?ZerG_SZ~6CW6}_f>68m4Qs(fwpFEGr9lE7?&8DZu#b5EWzLQAX(RR$JeVl z8@Y~NeRsTHerI{=mHbVI_f4DW<*V$mCvwg2MN(HcXK!}tyt?V!dB#VJb4p@dCfwC+ zd0Of9{T18d58DN_XCCjPVJ`G!V5KgjveDtSl=18`h%0>!Ovw~8#G_*9l3h<*B9OErlKay z+ikD1T*%d%;I;7ix{8TsYvNc|au)APJ>a*v;P-8F-TXCtQOu63{uqnrmR`K3r{M6i zi)j(ZZN`Z?C2!1y?*3GY3UX-K@hV(rQ>yv4o9alsvR+uK_v9Mb;1=j$3V0I-fHQf6woBrtq zIiksX*qAP}u;_G3f9cvZq5VSsj3qB^R;;_G&5`%O!&0Yl^Hw&d?^;_v-gFZR;bV%O zacP$GqGMt?c~3ejRxma7lnP`#a8lrW{B#z}nx`uI|L?1~PB7L#ZjvoKJ)`eJ{^hot z;z#GKp5gNCDZ7Kq<#k=|Tee=)$^D;H5c|kGNnQ5b>ASNkggNeXo^n4iQ&`zcq}x@X zH`c%Z{K0EVjdxCI*heZYTFvg7`OsZ_x1qFy)_KOnLp!q5UmX;mooT(RBB0=4dGpK& zJN7C4(s#?UIM^iuz0|fHw*4D&IWn(uh2n{ir>9=8nYP>U_%`dt*~Nd46!q@pc>6Yz z_o2XlgTQN7&)W(ZxlAtzbM0~6z#y{GbglcUF>Q5S}xoB-z}c^d~`V&`+HZ| zW{+T9wnH!G$#Ew*=CdYty?f}ndw2Sk$=gobc)titQ(5V;HSFNlGW&|BzhBGAaP@s( zvhCc<;Ey3~UTb^AeCJyK1 zYj17O1y#H;QejRzzvU*M8cUJmYEf>3`V&kZ1}!s~td?H;_T!te(G$VGZM;`^+_*MV zAitwyB~Np^%=yAho>b=f>xC!-YcnU4JaMo>P==7dXCTQiO8N zvM^ zpZ@>5;t;7*b?$3Y!v38U>rB(=G}PF$YRTUt5@D&CjJp>w>|eosU_t7ZC4Ucz$}VYS zIJJx6&`O4VOE~r|5!=4#?;+9umpC@06<PMt7M@-{|H6u8XAYU0 zt==$q!-Bo5mbC5+{(VsT?@6(r2Nn1hHE&+C;=tPFen-|H+O&4(sx^-~J-2V#ykUpc z>UPujH5&g9ag{Gf+_YuykwyK}dtLXeS|+w*M)Kw*Q#NjW7RdD1nW3xJb?fr2FLycq zKf7A{K$2YGzx^eZP^($xf_e2%eR+W|< zUlGwHOD6=uAMitJq>jBTY6IL{K@^L8A&;zK@m~W5eN2gp7^YG?3U%K{pR!5EZDGq zHN*}XGGN}YBMk}`~eTuYWO9I&ECiH|6vpA;HU&*%e8gk zy5rZsJgxKttC$5Qqn`g?da}@RFNpJ5trSH4_Xpoi7vB9Jw5b{_0w!Aj#w^UZ17?EG zZU-^`{;z{7f*v*x5~L@-4gy7{weAcILP4I;4cAviSrmC#FL0#X+i|ge_3LvVywBZZ zd$h3r$f8wB2W|O#)5I1VS!P}NkmMA%wd)%n`fIQqdzkUQ;P+{E zVdIUz`&U}doiD35?ex`OFDl-2oqA7QFqHeb->$z3R7W?>E(a3BO#mbWNUUp+>Q9v-YjiO?wNKyB7JK z)beUAP;#DOe0q*~;}=#AVlM8}3*e6lB&qZ?Kjrlg?MZb0LOpxxj%n=K|*B z@UG52b9eW{j}?Y?(X!Y7{!njE6ZCPo&-^@Vu19|T|LbM_i(9TQcU^S!)7kAxO*60D z^quyWz%cB`NLi@9Z6tzWdzU9hG~m z_T|F!7yVj3yeNDj|EqG*=_lLNHtqa(g}L)Vot%w;qiAjV^GMgHuRe?GuRd#$lUw;k zi{+ZJ@ruuz%J)@VYyKYc$kER?TJEs1b!vt557_|Ymg=iHvy zk*cg!aUjj2aasHJnHO%w6#MZRif> zS$f?Hp691s*~94Xf92>UXB)Bm+Vxc&EKRO10W7=+h1N=cD0v(Ez;&x+PoYuCk;1o3 zi5eTE4w*c;P{%w^Dqm{i)=%d! zpL*U)?YN^5*ZGe}nB_tROH0iz8UBZ&ofyZJIB@-{pDq zosvYx%Kc4IC(;BbT@hLRRIpP;HT2ZXOI&Jm|E)=JGA_wCk?8qm#1qQv;$-kZ%l5X- zqMJ32lTv@`1kL6D<`ec~2-Q~LlYis|O z@l5>UaN%h7^V9{&1uIH#urbWFk`_B!`sznmuATDPyMnu-=I}}=MJY(>pLH{PRrt8} z^MwrWt#_N^d@c6}UJO3=*gE-hrjuO9yp2{o6AxGIU3Ae)^@?d((VS-C$-==iL!Mln zt}d*$=Ayt;kwPBbijWCAJdT?j%kXjF*V_L><)D=Ja*OGw-+nYoIn%H9NUcrdTl#Oar9s#p z&NVIe(M68D(^XE}oZnezUqA0?mQw3ACDk*|fx4I5Z?et4>(p4$xyGprP73gsdI~AtaKE>}zl+7}>GBUQeGQ_D^Sgw4 z1RIL?=p0u+YMaoxgG2DqGo^jSP4kcWJh6!oRMk<}QqoP)=eXC<{d}T-*NI}iTMFV_ zEZ$GJA_T3%CVFUXnjUf{!O&X9#qLhAlCO)9rq9IQ=?A)IoK=+Mb#>U-QLNZzIJxIh zx<{4aAB$L)Q%uRnUUk$3o6c|*X?tSIy{AL#LGTNYfGso6=olYyjY!UrbDPQiXs*-- zr4>pS|E{y)J+Ub3NV@ivvhr&#)1Jj{lsg&B)v8$Z(Ox}m+Z>BYtqfg2bQMWUfPSRl6DbL7x_}IGb zNe4M*J(CD(P1pRD>!2}j`K+r&YST|oS!y3y!b9B(e{7ahD;HExp_ANg=^&Z8nf=K|8l7O zQloIs0?BBi7CL3-cMItn~D>*jS7QCa#R`+elu_?f3>o>tOM6_~w+ zS$M(w|FvA7`uLN=&Yev-;-+bRrPQ-k%eqUYW72eIz1Dq#9E)N@uB13>w%oe+#WCyr zH@#VUS8eSKYlLM~Iyf)L|Nr+~v*Y4D^Kbg=`(7J7N{XJs^*M;8a>n8x62Gbhj(mK& zP)2vdYT21}F?Kg5b4#|p{dQ38Z{8vO@6$C-aNk}NbN^1$#H{y^nJ;Zp*%{cntVWe1 zX~!B3kwv$v6CO#DL#(>h>J4)mbx1Pef9z z)|BJX#P0zYmG*{&<_OL{vp(R0$j*yz=33QVvwj=Qt=lxif4%$S*|+6q<^IuK_A|ks zdzHqiHOrRSohjD&r6q7=L7R=VKF5vqr^;A$m@W&KTkTbE^nFxl!oKPMp*_3h`t#%W zRfTy-+kZfV*o6H`AF3XO1t9*doVbxUo%wZ<Ik`z^QZo4UfeQ2|M36U z)@Sb}=P-5rdcpf(s=t1|`?Kx(M;F$tj+t=+U)xW{*StR*Aa7ZImGh|hQw7#^w^?0J*;yT%mxf#O zL~$Ov$jg}F+W#!wo#D1U)0UvZw$sd=YMC$J%Uo+#cy7n{<)pj&^2rjxlS1mxyu0_? z)M(Lt-^CeGWl~lXItqAWm>l!`_)*#*ei>LWIq-(I z9v8W5@an&_gWb<3ll$xXt}A48sPSfQ``yyRFx%xxnhWbZlZ0uG8K;Dsw(Tx?GUdk! zgFky^4=!iWKiJ8-vT;(O(39NX$~+%Grtkk-^G7N$XZZrQ-15L%RW(94R0LTU&d{BE zq3fooLJsG)?5zyuKPtPwtaZuA=(KQpr1hI>qXB*f8bqw(-!NX|v2bB;>3wgLH^A6BTft37}G z`l8Qc!LQx9i>l+lOmexKcYkJ{w{f9wuaEovByq+6zz54I^-h%P-6 z#9?o}>iX2fXS>#)J-+Z)dxet9%*EZ#!3RrhTyz@@LO-mUGkdegr@|{rAKpz|rxi4F z=A8RI&q`{;xl^t=|4gsi(RgIB+DReh6^Hq@a~MtVs9ktQzcwJ{&HOg8#zw^xxgt+K zefsrv?#BIo>K0|`kGhriEK)5KT(XBt#nVosi0|^to7+M|pF1))_y+gu;#Iqh3+FX<85bmi=s(kEMD z&FB2eUwG`&rIKUjJ47Xt(#5@3%~(6_Zq&-Z*9xaF>+Bb5;XNBQ$NaUSor=Au+B35* zStg@|j9*z_p6=&xaSWEr`)ly^@SWY~YxhR~OU#Np;kCeZvlGXf>e|o6>+{ce{ry%F z#q3v@^yAl~FP?v@tEVTNbecBri2C}H6BEPt{%A@nzUbwc#VO~j-*91zIE(0_q`*l# zrn2;TaL(YCJ6^;a8>|wTk+RyRJt@aCaN4rXIw#U4w#$5sw7oIw=X$M!Qxf+7s$ctT z;u9^QmWR<_1dqMFm-&j1MSLZL$dTfu9FlXq43utU-Y#X_(yHF1drO$rw}1Z0wl&+P z9Q*%%>)}6NQy&@$uZ>CnQ~dDv>f5_i&MbQJ^4}TZ8K1Ndsb9OJE2k44JZneFmszfF z)qh-={qD!pcMcMVud%l=>lMUb>9&dw`_+C=^FeUnw(T9~8gD2aS=(o}Z(iE9&B-VE zf-NT0NJjB7MZ3PTsbF3tch>V+REV_K$GWv_v+kY{Oy^&|gl6B)z_V#ZVF!4Y z#Uw5Ktl-*tm+S3p%`kt?<>GTCF1j**FE?Fltia~#r+@2wwSbzC{z1!9lk11&Hs9j$ zZZu!yyYtbE_}e9HEgM|L5~TER=&%R2_W$P$c%HiVyZq^Cl0r_imA?y}Ik@H~)9DQh z!{&HQs&zgo&0g63dUN#Ol^NXv-KWkhJ-Yk4o?oz%d(+kTJ|{Eh+VFe+Xfkwh=eDvBD3Zo)G^-ca5I~l-@Nii%MHnbMMW9 z2NzByoIabZ8Q`7{2&4Sb(}{aENTnd9LMzhbNP&LIc(hDsgRtmxIV2sSM~aW!pT?*91d zhK*BWujgN$P%NkE9x><8r`-})o<8lgYhGxuPvdjgwzo@_ctvDwW}LX3d)@Qq$=s^8 z{l^My_GL_PzJITz%lXsa9r_CxxZm)VeVDrBww%~WPiL9aX8Re=sA%c!?0LLU{z3HY z@T*2$P3)iI-d?iZz#<@_Getbn>bj!_%Qe2aE~Ss(y|iTQ@{3$lHDiWc!l_kz4ul+# z&pPU%xn03^-JNX-TUi%ZoajuAVO;2T^;o$+`Gf40u}b$j>6a~m&t*}Rkx{P+6A??(r*t|6Y?*)p@E`RR(*e_u}h{d42`lcT2k z4ttkRXXX;n)Dwbe`SJD5o+h8Q(F(us?74n$bz+!*b7dJs>d*cC_xcOh&hB^8EXb7k zUnuiGNMpu~*=>t9&#XVS`>Yc4dVS%gY2dR!QdGX@tN)+f*-~Cs9V_yG z>74v|eRaR?>`8K7ogn?cE_Cm|`}-y|*2M_???~IUa7y{_dwVBW7ZzFGnNTrzR%grB zg;S>0m(Q==_xs-7|Nk$zsjbuET+hR>#zu1eoQX}-CiTwhXbw{NUnh3+v61TeO1gsD^KbhZ9}wy!|$MPt~$Rg!g!rj@?A zuw|WxPov~f(6U;Y)lJRKGg|8U>TBMFL2ag^=~fN#OOzNy(rK zOA?ZjA|fNp(~}m?n6_r!s@aQIELpyM{*;MxC-f{^y#}<}xUFHu`VEi;$1_{%(vxEr zEm}CSvvbR)H4D3%7c5`ZGi&wL>o->~U(ndUvaPirw30Y+t!d)ssLY=5qE$te(*rVQ zW;Shj_u#_4>lc>y)jfRlcqUlOY4sJ-Lb9S@Hcv>7D6Ob9*{?g_$of zFfjZ8k4MV}q?mMVU_18z+TVBorR)Fy|6h81paQNSUJ`k-1BEZ=+z_t|NqVG{(s^3|8kHZ2rK^o z|G(w`|G$ZgF29R{jB@|4{r`U#Nbdji|NnFU-~PXTBbWzTbPQ%ti@5&mx_u`DgP<~W zEc$Y5FS8>LYry*r#;4ERsqYnk*1>emcH+@x{QoB&ws`Ji;owuSa+`|sTbJVI^e#rx zZ3m^@7&tq>>nwlwxF`5~q1uDv5_ahiw#$g~uLxiCL6mdH?%~IcvxGPipxprLm_lp06qV$nn ztB%>jTC z{`so&bB|}NSzxrK(jhKtuZU*twSSC`jiR+-7ORiBHlN+=?0opJa;)3D=e?(vU$nni zSlG~HaZ1zZScJBYTj>_kHb$`By3t1t`Xi8aZP%* zSq=|NQ;>m$Y|}=bR(B=E6<79pO7im`*gW%1;-&eb506RKoi1?*;_%~dKdhJ`%+;zG zZLWK7o9v4XbCeR@!;Wm z+_{N8T(|4KoY*LT)}z3y*zxZh=GzQ><_|xooZqGF{_Vi+FFRTS{Cw?%1m{-Gxe`;r zWUQny#U)AHNKsChM}29IafZvME5dinxDqy;J!rM|Hjj~~TJVf^Th}x3$C(=$mPw{e zva5Y2axR6nQYrnstLjlzjn?)$y;-W#dsXRfwo z61wTEd1spNPo|y0ZQ_nP%Qj?~Cxl0Td*`fFJ9BYO`R#umN-~#NnBqgOW-%!2DE^dt zV6E}wQvL0c=~_GA{%bZdx#-7H7a>@-r+xK@-3P3;oH?FgY{u_lw}iLNJyUY#0tdMj za#vMnJnlZA$FjC{osV#7@Cmcx2giD^JYLO~QRME|USyMEY&Rh$%22Ls!hGq%^LtOP zkodUf`$^spUtS(emo@Q~K6l?~p@y9C(J7(vd*?A#iPQ^!C>bjSY4ZoJan= zbF@0Fe1&^Y*1gB)c@71>V4S4S!(g}PMM}DjUiUwKeY>9T-G&xB7p-t{nm$Ez@9xhp zF3v4?J;BU2=?}+-2jQ9h#~xi?&aeN-Us}I=jh51;UjIbxX{XoxGKz7(ynp6YjtNY5 z0=jaS>t|irKHskX=dBm=J9_@TOFeyHx%kKHe-|}uh|0=zp2%jQ_`~7D(;0VW+3c(R z|7?3lfz%ZXz4iUa9q;5jeq1qehN;}utKo)=SJnT_W!qfwS6}@Z@3U%6*C+^I+^}Zo4BOpX@u*cr(dsLwO6b9w>DkQGxz|{ z!X6umQ`+47uBGWEd409yV4p8{zP827L*PjK(cZ>;f4)q7e@^;S&f|*BkxN8uWlrR8 zcJ_&#Sv2R@dDh-X3{Un-uz1X?`7?2g`oZuE-Cc{MdA+8yF*+Lw`TGR#ToxDbMM|*c z66cH!f)9f2|Nj)e-**0BVe-BmH;kAieYcr#NK6WRxme=K%I)`dC(PU>)!^W?BZP)B*_49M@xOM!`-TA9*mF0(*pI4(UVPCTD;Wf#o2ECbn)D> z*WapQ&v*ZLmc;b8^7YvT_V!H;1(Lj7(^*eSF&*-7Iqo;%RC?|G@9eCOA8hhpC_2W( zw=SH|_qICTW_R|M)YFdwO-(X8m#du@aG28@h z)mE*=-n~C+oE`4*6}T|XJG=JXy?eKMwBOf+NanGh+xhq2uNjQTHYxmU<2dYh|9n<` z{pU~f{mz;!`=hyKL%amnf~Ager{42iiC=J5fTbkseavzJtLN`3_&Gn#n4q11cz&jD zy+OfUi6_l0DPQ}mfB&6O&d{dA&1C&7=Ht2JMclVrFNRHtD*xPkRdRywjzf1VBPN)) z)bMgAx*YhXo8QsWJNK>Mfz4a@a~u)h)6V?!WVX{ffu@e0nsotSFcBSA`|?&zF@d%CUTpb{U5U94d%>5}Gx2(vkmLR5(kVEuMGQ3*?e==ruN&l9E_iw1U~v3o>*yGfB*e1_Q`MaDq8QGlpOatJ*jl9 z$I0df1uv~_hS3K$R$9kwzi4(wYO%qcAJw`&o~o=u5=NGL3YGROD&LzsGm=$9)#>7Y zX2%}0(wlQae^=apYQ9Y;*i5RTXWN6;O|oY0e=@|5yuCL^M&{nGQ=WJ3{oJ7yD+9X@L+@p_4 zagk7|Va=hS=!S#ec1Yd6dMP_WSpLcUvVA?JORJw>`)e53o58i~9!GnwJ+=tl zCef0lyXfj`rkVGd68bN?xhUPfSHYq(w_av;(;M&atYKwyKG?AxVR`1OES&&A`W?$unuX%;M4&4g#~(!{=W#e$O#N}Ckrzuw*ZZmM?t-JO;{f4x5W$3~ol{ zRdDN0)YjoL-i9J2)1 z&tg2df=~68MEX7^9ybov=!d)J?5O(xE0KqB*O!%vFB)(4ZWPb5c+!{V_cUZvqGc}+ z$J$$AQ{?CT;+kN0N4+pNQq@e1k1tqea(4LnMy|ykt%5TAmkke^#BFPM?htV@vsK}! zkISV*<*iHhe$Q8xS#a2Tug71VQLl;9* zx}z4i$V$drS+H;vmzQ6k z=>P5ST8}!n+w&%5o^_fqi8V3wa^l@@?0M>&#W=K&ndjfzapM-Rh|a>h2~)26^q$t6 z*t>;g#YE24Cj3sSyz}0u9o7`uvv;DD8;e(juH6r_mha`|Z$I2wVq*9$;%tL+*2IcT zMMc)8<-yv#lm1L*HZE*asVq%npJgDI-F0_TX=HX=yINS@L6b+-^JF$|D!t+$91+}j zx67l*dx{LVSIeF?%cM6g>*{DNKjzeuS$u}|)V__I6t=$c*4KW)Glij9D~nZ-X?yF_ zlxIpBx!GTmgvA@C__F`oc&3PFqL2FDyp$GSasI~~v*ssru4GuZMsXIS;G(q~=U$KJ zX>-}VXU(KD&!e0a(;wR9Uko#R<*O~J8YvjK?bG|iv#R#2R(;WN^?(3lw6Q|LEQ5t^ zGi44c-rQvSI5X^I<{>_tWOq}yZ9?xiD}0D+m6GzBn8L@THs?~2PUCHZEf+$Mcb2_O z@L*%vTovNH@ia@i?9?qk?wk4)Ka!EZEM?K{ecjc)O^eNDex$$#(RWX-a4cBD-(A42 zUVd%DBE#Z>)Z*@it8|X9cGclF3O_vUt6Qgl)W!rakF5(`v~wl1-c3;8Jsg=Q+deOLN^^yX-X@of9Eq}-HhE6LLKz}2F>yDeUaeEs=FL8R&Zwg*k0CFIq#AIr7suDyP- z;DWE(Uw!WWhr9naOR?<#DE_@~l5+B-ZzZ?f)PzIDJeHKQG=ZUb0&0dOnL6b z5PL}SGH>9ai-#)t8Fq-z%dquO(YwAR!2QDosaKOCj;w37P*SpsVLy;FcUh?6u_a94yv0Lo*e&^l)6MEWE$dFa!{$De%QUa405yDaqNM=XP@;%dYU zu6~CNu7Vf%{>fpuAIJ6|d`{ZFRkI)r5ShpDKZoIe3FD4%!JBy^|1%i=Co$wXD6n#i zNXo0}>*@WEV));v+!*7vc=}{F8_R?1mOVJS@!xdMA1iWx9-sB=_U=DdHykQ8eICg0 z``M|Bo9FLYwd4SJ?eE^zpjE$+Wxn9$ze^shYrZhM^zYZ3zaJjDcjJhmxWu7FeQ*W8 zzP$eT?(FY7doJ!;l^GpTS6ME-X4>Be2Ubt*wea?1+_R8%&mxBXOBj}Rf4Z{c|I>px z!2z*B0nBrnKzA@5T@Sf~Np$zTJ*$?02T`XNXCxoLw$E<+e8#Py^})i2mjAl5XYZt@ z?GG<9t(nNMZ^`cUOPlJd;fsU++~2pPyUAu{1M}X+`I{EsS-a%msztxym8IW4eNKWT&%RV z^HHbgvIARJc9^}d(foLQ=a$Vo{@>fhcy?d?jIiA+7f;@_`PZF2kNnvGIx~dM%Wbds z+_!q^)+GyfES>-A{MHZ8A3e5Xcy(^;@y#oCEMK&7(Y#}uR=>^=I=p_xgJT;{ZdrSM z|JonhT4wZhWu~W>78T@VWlidA+rIl`Rar?;Sa@4XxJOb^WOPheL{v;{+`LJBDJdzb zDJeW8nJt=(g@WNTtl(#qM> zl#bs~I(1Ls{9~yrukDUpIlXQD^+@g5EwPgiV)h=7PfYULcUt|}ErUZ> z(smu*v}VPD#d9^+obl?P5zyEkpOqtX;;zoIn>jrjt}UI#bNb1Y%NOn}o>6rAOvje( z5&1QRdAXbCOr14jxkJX**uvEwF)PgD*VZ>LJHKg(Q}s62jJ3Ue%k@H6m~`!XckjZ3 zhmTI&f3W=Sqp8b|Pp>Wv$e6x;@tpSbXvlDDcTQqgR@|XYYd6oIF|}@CEBu%Sb%z+y z8CyBd{crmJ0d*u(LJ7t>CCD|NnmhVbhqre!Y}OwTXd2 z=pk&tm9>glQNZD$;_8;Ktvhz_zW(>0dDflRx;20OKP03*uyKmpL8=0&vo|hN5>V>s7vy9K_#ipy#s3>l2WGaMzuc&Q^FY2slX!|YhmGPNwb&2K z@&qLXA#LVIy?Zb2`&GeY-xg39bt3ZZ zP1m%tlh34!N`1u@n`fIFAKQAd(~G55t&Jq^*xQ`5wXv1|U%lGS zYW1hj@s*WJkLt|0?RLoE&cPmc_8>_nuFF@8zr|eXn`*Rjs^%GcQQXM!L7;EYwAnM0fwsTH7cmu<>M8aKX1bo!h?g_4({mo9t)TwlMqp z!FRVbgv<_l@SVH4x$#t@uUh?QiG*ESUT=y$BA3J~5}35rdR@#@tAG1_g8Yxox>>q* z)i$%493d9?`38@ZzK3-U(+uBM{^xKoS=QeLl%gW7) zSpD9j^Q%ba9{-@%)~|~n-rpgez3k+wJf*wJ=W`DB{crlbM6grgVAX>K8S=tL=~@pXYc1m#g8vj*ZqQ3Fk-;V;P`*6km*s~iX6UJhufHzu%dufj{NrPNvZdcrl#-i!__}y{OA4g?{c;5L z^)9cr>$vGx(sa(_RpX6P6Oo1O7Td2apI^kRcP9AAq*KWgubf!UcXhI{*|`@=O0oei zhqq4K!07)%xNM2^#Km*o&yg{{{U~W-fkI1`LHz{XD`pQ4UpzT0$fS71g6nV3ypr4O z^-*}!^d`9_iASGIT))Q2uXU4$_*Wf2mb$VnGo&+T%$qq=cC&`>l8t$4LL4uDBw2NE zJ33B^&+>FUdSuqg$2;!5R=s&4ZB?jx|m&zhUDiTUqyz>A=wj*S{@i z&YqvHw^Tnp{d~&JTDvb!e-2y2KV7E>-p>PV81_rlZJ1+w_K(*~iMC~uOB^{`zDTI~XXPt=_;B&@ zfm2-H5*jx=`gCshqK^wa+NN#R)cWUZZ=-lySAD6*zG)7xU#cfMGW@v9z|i#h^PN9j z-wsSP_$c>+PjaHA(3AFfZgKY)4__{C()?xL*!jKEcGL0W$ptD}N`KEY?VGT=+*nCi ztK53Jz=_4D)f$h=HLcuoo%#Q_8i@~FMc>|DJv#fx{O#Me+3~PcZC5W+`S{7gZqGYK zo0^Xn3hEsa#^2udo^Gl7`ReOybNzX{&615Ac~~C56|Cqn`19xJZS(g|0ZT$O4{cJr z+#LV?(v(BWudn|8{@%W(=Hjc#=BiG7EQazd7yqZPviSS)@a)q8N0j;hYYSb=NVq)X zYn{gb<^J;bobBrW71eK6dg2hkt)r**`StAl`}bu&ESz)b;+#bbpGaK$y|85J`U&h$ zz8=1i=6a&BKu(-{0w;Ho%=&%tHFu>PBEPSjAJ21Iy694A_QC-BMRM}>c6ZxOC~oEU za0}Nu&z$%}-tP?4wnClW$B%^NI{YltMC5*CY*KjF(dSkWanyaIS?8*yX~!;k#I8DF z>2t5LHvE>`rny%hYlV7sO0Rm$=4Jd&#d`8f2kV)9%`@Hw&RUXLeEFX%bG+UEd(Z#> zerz&)9n0frC^3X>)7pQuY5n=kUnk=J`Z9TU4Xr_VAb zL(f8|Zei))-@T4=LdxDah7{&Z$d`>%=x~_CFyT|2N#~}YQ40)moM%sYyS7%irP*0` z0{`<_g2~|$_A3Qu#i|I1_%R7hS(2b3D?M|DMCa0CGfwt}yP}-W8+tSL*|f`Dd+}{< z^OUw=H#a5GMJz2H-DRAM_sa^qoH5qBe9>M*@=xY-w}^k*qrY%P z)aMf8r*SR{H@j>171%|ry*|PB4A=8SYyRH+dhx2#le;Qc&pRk;IY0X1<1O5|QzuQm z*ty`yhX3*{;!AI2gyjGJ>a%Fl#x<&sXIV?hPjo0<+UC0<=zv-0p8HIVvu!qS++6)z zYuyRGZ)cC}Uh1~}a*BqnV}-&u?V{uQzxC31xa|_t)D~*#bMUTfx^%?gb?COz`wJ9~ zU79<0@7&#%F%$2;>6Tx%#D>vjpE-yA#@iP|7JXG-8=)fB_a&wMxd%nmv< zsO#db`eQ%a1Jm>7BP}PD;()=tY6?Pj9W8pFiJlg7de$J@#wAIo3}$ zRCAA?(Xn*-<#jXi*Q|JPHu13cmJ{- zM{f))nRz(WtmM_(W#=qr{{EiV`d|1`%J&e}=(Zm>&xSjvt8z|AncKE|qvh0${VFo7 zN*?<(WZT#L{$bO3@W7@>H_mUzLni%8|HArSVOwYJT2`k^%&XSVIhph3UY<$Q?SfUc z*Nr4gluqnxn1*Vzt*#-$w?yEh|9FTAkHOXHQp(wx5-&13lA*sCrIo*rCz*tyC_AgXls z*Xj+vGLHpYDt;WCe0q0vqF>LEjrX^v=$tQZ49d07za_#l+0$qBm*zYHgV-a+S05`n z{J5>VNl0K;TiDAahr|Pgr@Uw0di>sQXHE9^dwcKRmFCS<@m$W=#3Nm?xMqj%C9TS9 z84+)oCaQI`K5)48l381gsj{~$Y2{*JPx*w^>#rJpmj3?!jbn$chJ@0C)+hfQ5=u*N zm~{9uy;Wh7@hrBCRoLR{4k!gWno?l)7(N_T9D*5Y~SASaD+Rof~&=W`}?H zoww$)|K7Saho*|&K4kWCM@!d27PH!-O|P$ZOuVS{Z+)Ns;+zMjlUsx?i}0Qc(c-oE zCML^v^;}YBA!FvoD_6L7PLV8o&E{0b7HcML!@zXO)kY_E(P5=0&J!b-$G*6?c>VUm z=>=OH-leZJN(=Uzc}G9NWc%zT_MUg71o@kGl=Lo(z22^LSSllmMSPio2aieK_U1c# zc5W`NKWXLkRI2ChG?hm`A6+RC_waekwotz7&79?#f;PMK1UL$d-{0KaTY1__DrKvz zioc_fd((=!3Z=r|R~WT7P6#g+4vyLVWZum4R^Gmr>?yaJ|2=2+eEsoV=MQ$7%Nu;> zyuZ8Nt>?|#qz>+nk{YFon@#<2lE{rPH^pN|IPG#B5APp;ZC*qhSM(<4SYZUY<<_U{P3le=~p(h+UB3I5SG+j z=5n=gzP64h)BRKFwt_;{rJ3^%KIzO8$b3>?6M3@tjeg3trkEfZ=s`QMq-V*Ina`(EtfjnmVwtKF+komiu|TTSuCA?Boe^&YV`;!F&Z z=M3i@+pF%_Ec32YZ%s^9RliRXN40|CypXFbQ}Py{dY##@Im)T`;fe^dX1d#-P)7Ejs1Ix%yO)0t|s2+@d`S|ztFh4Y_?c1&3L%c|zT z>-I&fX6a~ED_?&0lFN0u(u41USKqICa;JU5e3QM*CzgM92+@*~-W+TA&nV($?ex6@ z-%ZuF?sQ=M`}VJ5)Iyd-?>~nnHcfqWM$X~%;XBNG?%Zy!xwr6v0$=+ljiKj`Mygkm+4LU8n*Q4htNek=KHlZHQo1}VXf=a{x@1qAiFF%K0-Srx(7F&RG`xf@jr2v$FRbc580dCB1kT&OGtTiK(YuwOr<^ zerJ$d`B;phb*KC9w|~VayQOT@S$^63+OpT>lfM>S+*0l-cW2do;l#=8*EJXTZ2fHa zq9icrZDqD${lV{r8SU57I|CUmoLb?|pmuV}=0*lHaA~)2E+Kx^22e zabE1SIht4fBu><81Zh;Hs8n5lQ2wxoucmHB!dhM<_IWN!Y7)ykG*z2F^%D14a`dCP)Q%76R%JLH(*&O?u zUVktOGM;Jh^Wy&te)D%;E`D}qW`DKi;Vt=cCN;lA`Ko>?#iUJtdxy2`2iq*e3EZKq zEB0dERN@z`)SKz`)SJ!OXzG@Z9_&F9QS9N7!(=0K-2a z#^18+|M?l<2OF<#F9WSk1|M?#Uy$iPAH#nJhW~5~>-uUBt?++hrTR;OclXNZ1M@<5 zFO1l~AawtN&=U*u_bmw9zaaEwp2xQJu_so?&h~WJ&dGM7&FA5_i zYOFab7JhZ}uMc*E79YQomtG}VcTk+aO=k5zR;Ec!O;cK$ z&aR#C;=r^whi7b_)p4&O<(jD5=`|Ckw>2%D&~?;EV}4KD?VZz}U0=N|Gja8_t{Kv+ z7x#58?Cof+Do;*M&dtg!FU)VMDDAARoH}P-VQJ~)=K87iXD_OIA{@i72m#kPde^P&6L(Sa2u4Sv&EL*c~-R3Q;Rz;%HZ^5tWUN@fapRgLGn;D{tz5HlCvYKY#PT^#=}H-XMD7H$9kr*hZ1 zgDbT||HD@vL(d_G4_sSUgVrWL+Y|&E0RQ)YGI$;G|Ns9Fz52iS-*%9)zaYK0@<2>5 z{`dbDXyE++|MhAA|NpWgO^49`AJXy!jqBIN_vI~RU=U1$ z4wGLA6>|#YU=6sxROOj{?Cz=Y=ZgFr(!Td^b9LEcRwCz=m9~oKY>NLg{$m?#EdKOz zs`Y>IckQsbQm;^9|L)lG!~bUc*7tvEdm#QqD_#20+5`EoLVNc`e7-lU=IujUyH7#9 z98xZd6>qcFJo~#X_xAVwXK#J`e&)_=|Gs~!X$*od)4bMax=ea%pP2IBQvP_?q7@9+ zd){R2N}Mq*?f%_uvfVfTJ=S4z37@Oo@}Z)(#o>W?4fEkiroP*Fp6!2>>>ZRp!-3_i z1m^|$gl7pFGK@W3b)3&PZaP=f4n)#p2eE0DZvEFj4yLk(4KP@nva`Nl1g*??QHWicmBbJ)g^gLVfhx^^G z-2UDFJk<^6o_nSw%%wZ+Xn^8=shp|otC#0UeCxGz?|sO<=61CG@wBqTCrYMyvpF9P zFg)CRko9fq)jJkEu8I3~jg5`hpI+mj3x2ZHYlYyhM&JdbC{CC@f{GiMFL>_k=ky zWzBNaJwzs)cs)nysr==*WpyS#c3~l1>sM>7%FcS7^;*<7OuDGMt4n8Tm=(+Q#R3jG z=^EQY%V%E;qHPW8y79tjZ3#}UEB9y zRk)P&M!&^=)y2o}p3`FyK7PG7ddZ^Sr9u786#{cg_j)a6k2vW*ZQr_pSzne1aqUmv zBex=Rt#Kh=kRaE!D}VgFHH<6g7hgN`dj8cT&6-XZwoFnyE&r?Yfsy6{rD=^_Z0yl3 zs}h8`a+E&G$~r$yK3DMbM5OW7UY-qMMqJm0KgT_I)VTJ}w+FivdII@BUop5aMe(!+ zQ-@H~L6=zR3p{hD)Kmm0H7Obev70y_+;vhV;ZVKw>$6)9p1t5Wa~6|N(ob8fV={eV zkC;pr8`~Cd7B=#HSf8+D%DHov9Xy$ALNoVQ37=`%Kj-0*BdtgO>l$#r4b{4!nbxMRQ*0Mz1!#^gMomugM$BxsS(^WL@FnaG(J}v* zUv%nIPTDM6#gYiiu*shI~2}`8px|fA*v#Y;1@7-5Rqh-gZa)0^3)WGdn zrttT3n&Fn2947Z%UCQk0@4fkIGV|Tt4?HYt(jPh;a*maM|HhwT*#0!=i^Z+Gwq6$Z zZr=K3v)*sF?K1xih48Rx>VhnL*6!thaj~@OL-*%R0eN>i4*w|lS+L;D3Zr8FZN^@b zUl_hK$n9BpA;B$qc|y5^<&Bx4QrZ)l+YB}bo;tZHi$fz*e(CO0v+ml4#!LLYegFUM zyM?6&FM>6+3QTnNUo~~}$h#*cv*yet*OD%sk#qKAtq-uwDe?(|!& ze+<_jTNJcidP2YToVU5Qy{eD$Ps%)AYfj;nJrqT8RSktP54v@2P0BT50-q<XlH7E(?3y>aC2f zY5U@0XLmo!_cLoMxU~53tz9gM+?g>p->-eR-uZPaFVCWmiE64b z*H!;5Wz$S=H#3)=u=efI8PNjU1Y+7>r3ie#_vzQRWS1lNpZ*lntguU8ZT-wvsU^i! zu9W+b7?a3UXFkqJ>}A`gg_nD}JCq;(w^ZZL(scRy7iXNeD7-dVz4@KvjqS2=Hj_@i z74lhj>2u@Hp8d0H!ULOhRcyY$SsH$_#>25p!#&CRb(Kku;yG1e5rOBYmzvb(zwb*7 zurqu#BTN77%oX)oShR7tw}uJD+$y|(mJUJ*p`|&??8$*hg|Q|?<}7r6ONynDHZte z_|&Di8XeH;=BGWJ!3OX`uaw@e-8Jz-FNu9_AAG`^aots zvqQDcX5~FeD^lQ|%n)ew`_n3hRUOmZ)3l>Y7CpW($?ADsBO^zHi0j46f8(Rp9KLV) z<1s_KT=9f|2{**MmFG8b%%0bmRH*V<*im6s``xf70t@>LA1E9)%=>Vz%*HmxoRLAu zrQ%8cWADD*+tpW8{?&WM5t+C9sqv%}ojq|GN zGiez!ZumEgedn&7dxQLIo|P&)MLc*BEyREG7Ar@c42MDB(&xdficA;Yvz~ad@^k%zmJ>@uby>HTU=Lid-l6Ue&*+?keY>MH0Qv(oO$anFOA6{&>B}em?Jy zZh00){-haKPhQ-j@4Mi6FHee1-KLl|^X73Y^H%Ww%~e{`uDC;*Wr16_)$6S#Oo@UM zGGjnqXy-G*1?yH;Y=kfCYyk})B(kX25+L1ZSf#)3)BZrGg^*n(? za}+k7NVqcDab}Rg9jA%ZyZk~Spnt8Y4=k!^;e)vK`!E=g(#nd&o*Qt7X zIWVj{ViN6r|HaOQ;%)BE`vlw#16!Y}WUfBn_~+NBR|ku>?)W>|-AZO&_Ltgrx3_my zx^CyPnwavcH!cuiIV9%0TKucc#mJB8_xW5;u&->)v^nU$>*{CAAOE*loH%{8cti5X zFLNJH+~OI%#jwRyob0*JQTOxP)@xsXJbimEeT93d_>(n%Ursa#(&}-Fe|ngSKcBsE**3=9(10@U zH=i4tm5ZAeEcA#l`RTL$m-+uQ4t;B~SgUm=WNYUd*-recwzg~PzM}`8g$Zm~eb0Hz z(yt1N>#Z1)e4Tb*z2$R@WdTo1`LwEEKFh7;xURi9HzChw(XKV!2gC$8l+-L2aZQpr zrL?P>ktf>7?Lox+x2umjUhjJR_P@WLmPLwRn#$e$PbzT-N)9~}6S%U3%VdjjADhKA zv6-tS8f$#{S4tmzda%^#vhL{SH&i_tvl{BsU_oIhQW*e_2<^FzrVL;Q_cUnoxAQjYDHcWa+@>z zj)&{)kO@)tVv!pdn#xKYCl!h6Dy3?>3;&bQ{~P+>%}HlRn1A_(Q=vaUB-LyE_PwXJ ztgdJ03I?V6%deMRT_K}txl~yA+Z=_;$&9`R_jgC?gr9D4YOq=Fm$WR*Z=2$|ReekE zJi4*&(OWSGp9_-|qn6Fw>@n$Lq4ROWg)DqYaaZTwp4v8H)n6y!(wp&FJzaU}=7%AgnOR9pD}Ar|UYb_gYZJkc z*!QZemEW~_Cf_2N^^Wt_HSej|7_(32{HZ0ACkC+xJrH+{c_!}o?054LWm6N6C@bDY zig7ygY?V5(G3mR0SSLIqXt&lv`D zd6&O-JACs}Nd4{zPmcfp{{HTSrYNtfmmq@xpC&CXIJjoxR!*k1hrUf!dG=5F>b=jmuM1wE74>*t z!v|S6&)aMK3nrgZEEV@PnN!@^w$)_9ybAU@-%m;ai3ViT6x z&AK>OahH|LrwG|LTk$3L%Sx^6a&M&yrbK={xQ*52u1eDZ=LLI~y_!(aB(Qq6eboGS z6HnJ{{ZT%JW#|pze&nA z2Of6jm{oOO`N>vKE4%OSa)egQ?fn#cdYY}9+rh+cwx2nl6pl*prM6`!N^>R(Y-2uq zLR|jtRWnAj$8R3D-RIT*w3?-9TDHNW$EW|sGAS*OUfJF=>BI}u*zGs7kN2?sdfzg8 z!?zPUn(k*!jy_vd*L5gqv365QZ-;>T(-%q+d`iorl~4Y8c=*LV+xY=r5|3TZ{LEjQ z)+p>K;BwL0x1b|$kN!c)4naq5%Y$I_wPBRi-Ss6qvI1tH0j-)b^6U-!3b9 z3m%%_{o<4B3KQnBWLJ*hP}JqUSfIckNk7FS5#{PQ$Fu} zyPgZ1L8LJiZCT6S_b!qeeT!w#n%%HW*xuBzr*Dh>_v;XHZ`~@F+{6CZ7 ze+t8gI@RB$0{;sco=)`JvM~Da;_&`h!yN%!XI4x--s*pA*EBmTBYrW3gKOtrT08ZB zJj3T+>qqNqK;x&|dmqK|9$UBI%gOmyR)*d}_<(Wwj_fB_q_v%`m$FP4n>#hY%8>eyY zU&63&$=+2|V8Ga#=RRj(Pc;=G|Mp= zaNUYS8`m(L*nY3hdh4d`8`_LEty%fz;EcnId%x`JySZ^LB@?v-*2-v$LCPtFzP7rgV3l+`6v5 zvb?ISWKL6MNJOMdY<@&k^rqR98nSRJ`izHP72sfTLEZpH08o)8_aaqOn<(Hm*I4y&&_16j7LeEg2Y$@{K{&Y##j zPkZ0Rt4n9MZrdS#;d$P!{Ri*fIlXQD{OfnOES|e+_VkGzt%<=w5hdl`>ke4YIt*IK zoCP}8*du0zLFDT0&SkC{YipWUn6~Y;N?3Dl=ce7qPoCYpoU*A4oy=>|8%a^X) zd@yy{@!XExfd%UWGNy;8Hmsh~GciB8Cns@oL2_4CTz5{w{~f^0^W^R{H<{e_jw%QXNFXuvOLS;}5@F2i-mg5}E`ep8x;9?(ED$ z^H*Cyy#N1SD;I$o{va|Ow6Gb(_>D2geWI_XrzQn>>o690Ij%G`?F7?{8@TvTh6$>Va^c~3$erW5;c+_H2 z-6WIa)nP`)Z*FXKQQmRnA_;r-d}(F z!9mX2iT^GqiQVbdN|ZSFwfg#k*Mc6mRtovgx-?NRa$<1ezkgwqDb@P8nef}7|4i`{aS<`YDZ4)y?vv=h{+yqs z`Jlsz=e+;34bRJO@7R6Q^61ftLS{mhA*TZRnpQLy+0^~%*e2mr?L23i!XXplDSmIW7|RwS?(hH2mH}zf{&`XFhoxX_B9lFToDry5gZ*I9v*)G z!iw{@caAt3ExL53NoK-=)^Y=$&nvzbMpsu?xBH~$I!{k?sGXx|cWa4}~yimvIJo#h*o8zP=#WpE9Nr_(L3ynSsTa!Pi&t>HEKQpCctC#Yn z!v>H4E@m!t`#q7PD>W(T!G|9{Ws5I;>M7d7t0Ey=(dQ!)SD+uyIn$)F*XBo4(5ti2 zt}f!7Oa8v?E`M*SSgcku^%l?9hmRW;a)kW+Vi~Go7_4@->%{c+y83RRf+4-vmN2&| zC4`=tJ2#(m>Z)h?rHfznyif_yc;ua9>o|G6`niMo_ia9y{q4(i<4k?^)a2Zed{6dd z<{fDPwm%#{E^}T|$8en|sM655+xX*>#JR`J7k|pk<5Lzg(7*ImcHfTVS%DLNJ&V_U zaDKy0mn7v}=0fosJboz`r*7RcT2`g@?D-6zh3vvUl7&oa8GUCu}u~iue@D;yTLi`Y>Z{2)1!SiUSyc_ zuyk=m2%ejH$$2|t`=pgM!8Ws=F5dI4s5sV$gC(?Cu_e&pM#JBXO|wkTUZ_iaxO8pq z-dK4K8>3Apt}(SA@0RaB;4iMdysZD(!}NI!+YP2{-@A7)ck15WDa?+?#hV*qIsUNi zf3o$^Q`4J0;&qvcspaL>)&7@edA$9dqBNm$j{B?D1E(bw*!U_$JjyLt_A5M_ZgZzq z>uLVvuO5?vcpR5-vFu-K$!pu^S+ZPvxZ6+t(+U?N@0zW}iy> zB6qp$38NODYlQ)S1ZGF63rP7<%<%o8|>7Uy@^9zcq)aD${d=Sb%LH|&N)|B(!Q48B&AJlD{ zqL}xR$@e`t|Fn zA|t+k9xcVIdUU&5Y8I3_xTpORcb!$IB=ops&b^R$U2zq8i<{w#7@kjKmr{y+(%)zk zGsF7#eBsYres{ed|M>hZ?(*$#_rf>7uD$c9cK+I)bImhlw@4ZtZkT$^_i^fKm079o zt2IuD7i3&F=N9u#h+#T%gU|5W+Hb1YXWzS@9(Jib#rv3r;s4tYcemgFIe))hZBx2W zu;1+$`EnYM4qcA7ORjq~)0kheHdoi6Y(li6q*!f=nows;2463mQ38kXoP7@`B>yQ) zY)dnlP=C{*uI9ITp6#oX@&A>(78xAAkRdX`(V64C@MCrva|;$vj*VvS2PVn?`!=~O zxb9zy&tx5!8xv(D4UXKg`KRR2akM3Jo`OJO^V}!L?RPyk%TQRbf4;5sWmV6@JQe|i z6p0fv+y5)6O?o7gy~nDoJ=Xru#kbRz)cidu;lcA!xj`nGqp{%lj)xEB?Z2jI>84q@ z)r+o+pI!Imv46e5;+k_$CLCQU=#Xb;7Jeb<`0-<#cNTws{(OF!;^WZ%zXcC!-d#EG z&VQob(8DNR;$g-H#by=r42|+C@hM3wV+tq!2xXdMrM5*t!1)l*@i}}fJd#dL`@X2k zhlXZvofV~Cv!r`b%#!nuuY6$pvbg=-|LQEmxsy`w@+-7*!I+^d-~b@`EWyU#z*NtF{PSbQ(v;7adJ2kKoLet8QiK zZ8ep9zuCOU)+UYl=cLJzTGPF=wf$}Fq`NkM;n1y{p{Q``cGfk%r5d`t84Dvb)8E%g zNPO6HB{JOfPH*pW^~h<;0)<%+UH!ENA<9 zt#hfJkP_4U{ML;PJ^i`cR-f)loH5&JapRq$BF&fi8m4R9jF)eV;yM<2qvpn$*EcFu zrw8-y(s?RuWX*G>Ka-)FXk@OrML^+2POzQBqZ5MrbPC8TwahF zdV*8^;kR|+rSoE{a|D(=loWizz29o*rI$I|P5PFu;k$HVYpkC7%U3UQ&&q!2lW(}w z=$Mst?Wv5W^5Mx`MLTDA<+U2GHv7VnQ`W=rqsDL2B0l|l(zm$!iq~1)3jG{6HL5t{ z)$cbI)1st07gbq5Yt#MwXKwnu>_;k^x@(hICcKx6KX5_j{AQi|bJs|l&(gZex#HF` z>9uXgTiNFQfA{C*XYOZHm+A?ou^!%dOG)Q^v57Gk$KlUs!t(XD?3JDMI`m72M%*d( zmAM($)msi&t?B){V^O2Yl(5Genw~|f#m$&)6vp}Lzm+P-bycp-eHlSlwiYjpxT1W> zQqXf-v765s0fh>qcDD7OwWfBtF&QTQOwf4b;jw7l9+`PJ-xzsa@D4K}w!w*0Gq`sx>3NJ<%t zX4>>Q;){Y!{1<#@b2PD^zCm|_*P2ZA;GDP{f=Ptej*{{8BQ zjX~b4HN^Cn2tU&jD;An$aJDc*gQK9OwfR>{oQP^<+#G#Jmjt=KT;GsF9}l6M4q09w zf4%$nkNf}czgdy%HP$Z;;`BV9?Q`vagRIo=LIW8ozNQEz9TlIPzg==AtvZlwf zn@!D&FB%BA6!RS{aqh@Fo;fXj=gH-zv%NoCcXRp(mEG-*u3gY<6TeH?n|qhzRKXwXumZhk_RwGHqcJE^Jqro$ZtJ?1PKLz28RHw9l`cUZrpNXHCQI2Z|#%I!HEJDevJum9Jb@Hptw ziR52@+5!XLN2Ce6lx#mVgGG*+-7%ot>%j9z8)_~)vql-b`XO-K_c52E@yqoOI};u; zJo)L{rEnut=KI_;lP>y(yf9xT(7(t*sk_+5imk=%qRks~uZDDnO>1VETOPSsVLoY( zsbB!_>+3VF^T||Bb;&TyGRO4qLe7RA0AKHTx=f z!1<8W?E;IR21OIyl*6YyFX<4!Us1gO{ZFCoqTWfjcc1V~E#}>PKjO#+W2FcoOSYER zs=ca9X1wK`7iF##bevzyMDX0~*$eM*H9X<#d?p9<84PV>nd}C6J#c8EnC5^eeOa89i$9D1k>+dtB z@5uakKw#~z$E_DPW%hF(KHHIy(ssfRiW9Q!mj z+1+`3OjEu3&h!h>H+a_E?Y>!g;iyiS?drL`h0&Yj_?&0ob~_^|u#H`~c|&e@hjw;1 z$G&d`QSrOBUEkguqo16svm&A@s#jgWK9kqerDaRrMR!N8Nj}V{~HE9>?y9Esth8tx2~2QCf3D zGM_2=sCRLG(T$b9cb+#D8zkJ%iqb$Ro5 z2(No0^nO;+RF$&{-`b1??%WV|e6*^g?-{R<;ivE0<+g~u-)Dc*`ON7BhpO1)vZ}&o zso0#|a+*J+vgrH$Pt8i#AKpHjyoSkUy~o6-40mrC{}ns&bH$0ZJ2#r1TB9}5X=?T3 zKb@13{-uQZC>=4I5V`wj!jV$}nkP>-++aVy?7WN6q}P7u{%4%XELO}tmlwdT5M;Fc z^Yv881*hA@`ZlmnJk9?86S52)0VF5JH=oAY~wba z2@Znn?=Ma1^HyjL*&o@KyRO8m(q3iinTt232FM(?6j-~qJEF!*@PC!~jFRQX+Ujw0 zAOC-1zCxHQ-QDN(qm#ECp9^c}otgRlO=e-OE91(mx(4nU4hLmauFfpp<#~lUOELIf z_TS)}$A8sC>Iy~JhW)%SRq$xCRM(CFW@}b&uWeCcR{E-U(n30X>(d|0A9r*8np-b3 z$!G5`K}n67PAfk?yTZ$wwRBl?{?3)nsXym^vSwyt%2uAALRPf}pU-IeJ-e(s2S@RcL<{R;sF%U5MfU2VE< z^Tl?aeE;*ERJPB8;yNYH#phMb#3pg(a7d)*#Kuj?ynjAo@tjkiuAb|Rdl_oDWungx zwu=v4HU)%k+PM0r@V6bmKcp4z*}q$I(~DWxQWH0Gz0un;l~0+aVdh5b`z1@(taW5~ zC2X&`dDpHzCwHE0U2@+<;=!rT8%JGV_UOG6d-y0Su(_!?QImVlQDg3f{0wn3udKUe za$aCTzu^5StvNFuTv+P!SZ&e{nFVwDU))m-TBr44I=dC)dL`q=hL`a_4?gytxp|S@ zjxATVcW3!0ESNxw&t-6vl^`c#@BZ(qCfK!fDH0}2ZD zQk;+54XmDjnsDLUOXt@g=zeovzA-eT=Gknds=;Xg}bVphR*8V@(;SwmqP4M76csZNjlaR zciu+(xFE}GQ8ouFgN?n#XJ;1Z>1e^%{9-bmSZJ(>@Mwy)+%>;s@09$dvkQXMgm$+^ zW_ocKx^u(TZ(UYBIn!)^f5zUvjIvn&0~0cjP0pBG5|V3^ku3Q?Lv`nz&gKLC=_?u& z?k~$plKh`4|36FNe~QBU0~6Dil$8c*uQKAkYAU+kMs%;Q)U`5|I|a^@@*T{x^ykKE z@7dpLYj45S_Kp=@6?3}Vw`C?CG*p2s z=AGZ&wxFlIy}BYJJuN>cyP~MTKRPKbIlif)tT8)zZf|FCeqL{0@-%N3&%%=UxY(HZ zgs9lKsWnB#>B$L6Ny~fdQc_ZCON*m2@>5e%CN|MHQ&9XIXSFPW$e)E=9tCr1bYna~FxNz2tWoy?jUAbyj zOWo2HD;FB7E)C$cj$Hf~z&nz7b8 zVU0!7rs(_y!G-GzD`x1#Y)fm{czO5o^E;Ma*|l_9eZ{kvZyr2&@EyG7*D+(OUf43f z^qJx59TUrPy0hc^^OJjW6DQ>-_va<`7p3>+Ce7{bnAP4mqouBLq2wj_n6ivhN{HT! zt!(H1H~oG0U$XxH|39V2SL%hn`Trlh4EP^-a2aK6*}8h!$p>GqZ-opl|M~xa;{X4T zr-0P|fBgUd|7Cw)?E-WDBUS<5&;Tz2{uF)zbQ}g)cF~>xpZ|kSB<}vd>-Ycv{}=wh z{eL}JhPKOpAy)kVfBpLP>LYPm7#IXIVPne8lMXvb9Qdg3x2cOJqwycx%*zL~4PR)q{_~rA+316lkX2vn^@*Y-GW_i)K6#((sZ0BK z`jB1o#UE1y61O{N8_hiPS)}`FhVmOXb{&g3W#VNAj16vuHm#b!_pV&O`0qbePSPJ9 zSqeGd$emGeAeg1}^VfjTT94I})?3RQw2=BbbK<=xM}N=RpeCKvreM?2B(Rd>sPM@U ztI1cNe`-xS65REyP@%!Ubc*)XsJ$06uFPKR72Wo`(Bo?9q`PtZ?O*VJ>`)OozBGd~ z`F%=P`A#v}Hm}dQmw&rUzEd+elrG=Duj{`3(T(O(y;b##1N~Y24;tR}+-UhsvVO~q z(CB1O5!cUFV$TYf-7PFH=j#03d(qJ3oyEro@9MXm=XEVgp88HNV#oUTZzlPsRRs#( zWwxn0GU;Jq=4=KZl}lm)jg3COC!Z7@U2QY9zEYBH3P**Y=v0>#VjDPAr94k>|Mo4s z_%N5->f|q*!h>i0SN~Y{(kb=jszoA(9I66m7I(REJ%+wXWp?j}};Z97`R z-OZI2ERi|2Nx^;guG-YRt9j)!WcZAES}$gOtIQe1dCmk+`pBY zw!8Ca;>AqM9k$-daq>!+{ipM~yKK2+biRs#Z?fI_mW#hHMjZG)N$uuDmfQE%c5L8~ z<78J`!e4znu1GEPQI3)JVYl5YBUpsFBEz+xUiM5~bVw;%saIFMY4Jm$q(AozH=Sg- zd+p>3j-#*JdUK4@aye&AD4i_hum7|%Xm3u$y0+UTt8sX~^ICc7G3 zP3e5ZcE>#6%EXYFYin%EilTCauKwqhvXGi(z1)TQ-FuA)rM5HQbKQ@%iChedR@)t+ zx$5NdNxVB&&$_+1`9t7wlP(E+6Vth_{-15n{roYJ`Ovqc0^E+}mVf;PeDr4ewbY0o zQ+x1YO16;g-XqMJEsX(Rj`@YOon8G};oA*ko-YU0^YYTOXD6t!|H?SW%zk)YdS;UL z$_v+4ov!*3RPBF|W$Nq&f*x-@S>$Kg9rzq+^2>z(%|X4Z)*%z``R|uHy7NY zU+ylr_8>06Ac$Q_e%7qV&jY7jE}p|3WBUC`W5TXevI;9CR#@zlUf=Ne;qH%jxxU|6 z;N~tLF?s*b`eXg)&i6m6PwKaizwTltcsjprvCGdt57y|ENFP6B@QbB8N!NJFG)bY0 zu^r)uKg(?`a-H~;i|t5M(IV3+GiSb8aQDazBb&3o%5Ar=6y6zbcWCCNi$C|@+q6ex zW7B>%nW`UlKObm4jB8TScWw%3G~#&p@3x6|YHDghhQJ9WM&E~$#^tU9oGm50)KC9Zw1KWtm9aq7a6^zAcz7>ZwCb1s|Y zsxe*NvEfVmdK>w#FQn&5NlH!;offBJ#xZ|(Qk2ay_vI=3VxK(bkLR2{Vd=Ru=gywj z_c>{_*CR(jMQ76d%I-+1*f%l$?q-JJ*EBs>^dfHWu?6yF#=bNyq|48 z8u&kYeJ97pj-At3me(J)cM>U@@%1aOKxEv#5DnKy&0FFgW?sMc=h(MHeH?R7{GX(; zzt(5kr$3+T&-{`*@MnjIwvar_Mva<)-Fdm|^xvObf70epe&3&)ihrj4dr=wC*x2A+ zB*<~8Zv#_4N8PCvQ5(O6uROESafO-i4uA7I>})}tu3EQ4JHu4$IGR!qt^Sqid%1US z)nSvv|66CecrLZ8dpYf>UMS<2Ukn(^8QeIz`a=d`06RPe0zU`uy!-i~6ee1{S6Gqw#8UJgjfM44t^{a_#MF%?Xn|UF{q;&S+KI=@V@K zF?`YMTqTRk7yOvw*_%{^e@fjo5Nz*|$T}PLefF-$4gFt30;QX>HExeg5tf)r=;0?x~eOdZ_Ss+yB4aS{){HYcD_1n{R3oX?HwO(4zOG zs?bllqse}|td=~uqHw13t*x+$ZhuEfs+8Zw(v#^b0*>Ynrt07SZoDtkp=!BXouA%m zfr;n!{G0^uuBh~M+2<H&$n-XF6@?a=o`Jf3tp< zhnb-3jAmo?4H6mwt*2KCMP=k}wdj%7-TMBv`HYsD1c3>_4tpGw_&Z-gE05LBKV7BQQJ<$$dRbAs_3d9p zQ#&7UIe4jmzMsD5a^?;J?F!wAX)5b{FMXJKuegmv`#*b!l)K-f;QMKRP1yR?Z9e}v zD6o2MYPra?J;G_GFHUror+jWdK0DyVlDCppij~vsHrHmUFJsYgcYLtnc2Uf$&2}u- zf4#Yk4B6d87O(C;9jG;;e!K9 zpR#P*Ew?=Fn)HQzZCAB#9Cl(^TR+8N$JLyF8*bZIpSoWBX+KZIemOhewv9@E%?0jR zH2;{oUq<3_;IA}^$DTS%%7QdM*wz$=vPb&Nf4}Xw_~nmX>u1==eVN_#qi>DZaYvOq zUKu<2j^!u{2Ffq4x?=b6mTz>)CYN@F+3vgFetWvP;>`AQKP&D?@0id!b*#-A0F-aR>4`}@k) z;Js-(y*4ejW%ZD9RN1*S*nB$M%kMI|FL>KuPO-4__j9#unJf}Ezp3GP@q{gkzu!Jq z4^KJpRri)h>1m!zIlFUni=btBh zm3d-bS#w_c)2Ewr)dfHM->f=Rt2@WWY|)j-t0t2lS?VR~O^}ed%ht5Pu{iT~UrVZr zTSH~o-oqYoy;sGQb9TJYTm0jzv|#@I9J#mgbLN%`Kib8dZS%~C^LQcq)H7B_H7nW! zh3~U9F&}cczDr#Dr}($JSJNN5-u7mg9Ju!E%b-19-`wqg|9Qu}e-A%KN?VJ>Y8Gmn*8GeA*#2F9Q$_vWf5*#pZ*G3; zlN54-<DZU*sju%OQK}NkCN$mZ?K>wQmhxNX3M)6C5Ia%( zphffbi=ZFAnaNC?%8b*b97H_7Z(jbRikq3;gT<_4iB{){MB^KW_k2BN+EBA6&P})S zh4H~Cj?62uVV*W>R_D3h*cC1ai2Hr`$m{MNb^hoA<)RyATUhjux)|)5-?ZodkB@)b zPiuFYyDa!+74-8AgVUzkfuK-)L%- zlgyn*!Uv!I;b%%Z-8{P^r&DLa;hHTnrRh_rEjhhlj#P(MUGldLJeM-p9)5F#rSsCU zn>#Nod3xFXwru~}j=#oRm8Fh-T{nf#*U zm&)QF-uV0QC4c0frw4!4$t`vbRSV#oqPvh;pi;xlJL{Nfr^B?Y@V^dr)r>N%CsuPF zso*P=Tz90i^6J|uu1OR2tUs&JlOfu!;AOC+t+#R`MhLt&Xx7Rkam`<4G!q5`xXqPT> z|6grYz7^-;jU5Fg0-t{#zF9b7@%pqfqgnljE(Mw^pL5*z`*@kY!msb|?%IBp?+Je{ zu(~;7jh>cY)7)rBn`;`^xZkNj=ylb)Y>3j z_oJ)acE#S^=WwaEBFIoVN96YO-Tu$-y^J-tHWy@GICE9tq@Nv~=~o*>1URO~u4ZZy zkO)=MT+4N`=vr1u!Y>uWeoLgrKa8OX&bNn>u33vQxS5k z+tlmt5l)rDbMCr8O*-Oy zyS)46PXU%KJeD1=kG|L-tFg~gN_L`>{QO$+l9qzCE4>arJQPsHz$Ew3**}L@-b3v1 z0{*`nPJTFXtZVC^rq)++I`SQ{rnUC#!-Aw84x}rzzZO1yID%1ZNy3}RB^Gwp?!HXX zU!G-YbZrdU!9J~>bL&E>8SAqZuD)iNE_k0y$?{m{iJ*iVTXqC&P$)0<$TDA;SGV(` zdE1_ut7hHuUGlYtsfXuVxpBvm69K(H`d&^;&YJZyVpn|3d&8uYMciu8wm3)}$p89Dr^=TI9D7lC zPW^q|e9e154qD8eFaIv5KEFACt=H)%T3@r0-mI9B{Gn4}N=n(xw$Mq9#V4Nh1>OA> z_4RMpyYELQ$Zk6K;&M;%ysi1H^KCAuIT$?3`A}1o=^g5NU-k1ojhcf`lH$Gw{mxn& zeemavS7$AXHw$Mo&iOv$lxK~$#IB0^CTB6GR>=obdx9Edom{NApS{VcR6qatch@~< zr|CY=Hcn3Qk@xYllT(>F$C~5C!e>F1M=mU%Hun|WBdV19wd z9A7&r6>EWGEk8_Lx~K7M&1tetTzzf%@?~0EK zpIZL=_HQ3APmiv%eQ_B7B*!CUt z*oI#PJU_D-;R}CH=IKJ%yOvCaF#hK4?dz?Oite!2IsFH5w0F9L{&f9Oz3u(Uah6WxTR0`|ONd$THu3tCm0* zP;&Lsn_W?h3cc&2+}BPi-#?>f&!qfwGs}0jL_rj+ncBO3YT48j*Zut&IiZ0KhJq0B z0~0e3P0l?&F+D6dnBmY0hW$&KHcVyTy-;lDg8dURZ_Y0^o?Qhx-}vw{3W|eBJX=B?ulW|4g{{9Ts`OSM)E!p3n!Mvy)zWlc}HBxxbqJ+(> z@2*{PXyu}^l*pp>i_WZGa%J_BIkT!wcYzlEhRrWN+@Jn(W)AnlwwhCEo$Zv0`3kr)!Pl`RU zWo=VV@~N%ss!B^5sw*R+V|-J}!Xl%V_B0oyr-UbG#wR2srKEzF|0d6(Hh(E3Pe_<<&bi zw7MZaGgs!sJ@Jzdl#bt-I&+!Q`A7Qu&(CkJ-n?jT>((6`cWmN0{WxLwv0az0^_;!5 zdiL~;^z_K$GW)D;MTv70!$Le_R+z@EZERk4X8Q)$jJ0~9E6h6gsU5y{d(WEe=4}_Y zEwM{p^X%oD@9$nbeE9Ijwd+f6+zl&U7nm`%JTo~yDWx|rxj#RpJ11dMesV`f%;d7{ z1M62F-ndf^o z&-_55U<^G}VQ1+OCS&Hg_y@Sv;R*2d3NLGG;@LWc@rmiWv1#F8lU=U z?#G!VQgVb}zq7mN$8qVTi3#0GY<$)l>*{h0za$9lcCFHxoy325i$b(el}e+o&E|_Y z&R=4#%t?%#B(Smd>C_Gp=}qP`oe9BlB0s~mCaF){#4;hY^sY(n$BA7D73rz%BB|3B zzPi0k@|c?Yvlkr(XM-0=cQWiUioO

vYrVUNx@6UyA**x|c|2KGwSt!d4zREy|;? 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

h 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 z zAO~o5(Gw0ePxqNt))VN|46s`RIMzZ#JrHz$1~`NRIMzc$JrHz~ z2GrG{_7tovs0OHK@G>32X2!JB9$rzDb5a4$utH6OQ%Zum*KWA6zEXtv=g2Y8-=12hKooC7olM4YRSK;0U^aTLl5 z1f3%S4eR4@SA$j`fI>Kc1GM@8#0mtREdq5lX!QZ4mH~|xf!rFv0U9j=u>v7yV=x3j z_M|cda)4(tI6$LPPdPxd7tc6AV?fV2Kx06}xf(Rq1PN7%0mI>6=ur_NT=u{JE z3IVNMfVdhoS_E=y0LOKBScBTEAh!l^z}l>Vkdr(Z0w6nR83H-LEmaP1OO@j)xa0%3 zR5?InK*YHkG}Z)hHLT4V2s%#%>S|bN3e?rGHftd0j1_2DgVsQR+#d)!Z3UXH zVQtnx$hjj70g(N^41pZrmMRChrONRT>}qgJl>^dJWn=)&6S6X}F|admFmN((F>o{R zFz_<)G4M0EG6XOLGGs7hGW0U^GfZHZ$S{fF6vJtTGYn@L&M};4xWI6c;S$4ThARwL z8Lly0XSl&|li?P_ZH7AxcNy+6+-G>e@QC3t!*51?#uUaf@OscGjMo`>vpp$E3xi z&7{Mm&t$-4$YjK1%w)o3%4Ei5&Sb%4$>h%zz!b<7#1z34#T3I7%M{0yz?1^Ivy*88 z(?X_2%skA3%wEg^%z?~7%qh$}nfEa7Wj@dRmqn39iA9-3g+-M`jYXZsfW?r-h{c%2 zgryg>>zj2i>q*wDtPepa%&_aTJFrKy7qHi|Phy|PzJdKb`)&3Y?4LoW!Eh*n_F8ke zaa4l#RC8?SI1Ju94Z5)ud{Q7o6N4SYqydDW9h9dS9y2hoWU}-yNHH)lurV+&fZWE! zAjBZUpu=Fszzn{90<;g05v&Td1CxpI9^*X*MwVXi8hs`Phz!UykZu+RMlb}iK^Sz7 zBFIce2GD**E(Q_Mx_*{E1}3m>77z<$8UqvKJ(gYuR=5kY7(n|j85lr2C>a?*?gW_& z+TF Date: Thu, 3 Aug 2017 18:36:45 -0700 Subject: [PATCH 352/364] Workaround for jittering text selection bug using LinearTextFlag. Change-Id: I15d9b43e7d3de851c7eb40e2c4abf29adb2b4817 --- engine/src/flutter/src/paragraph.cc | 12 ++++++++---- engine/src/flutter/src/text_style.cc | 4 +++- engine/src/flutter/src/text_style.h | 13 ++++++++++++- 3 files changed, 23 insertions(+), 6 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index c1233fec11..7c5fc79934 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -25,6 +25,7 @@ #include #include "lib/ftl/logging.h" +#include "lib/txt/include/minikin/MinikinFont.h" #include "lib/txt/libs/minikin/HbFontCache.h" #include "lib/txt/libs/minikin/LayoutUtils.h" #include "lib/txt/src/font_collection.h" @@ -103,8 +104,11 @@ void GetFontAndMinikinPaint(const TextStyle& style, paint->letterSpacing = style.letter_spacing / style.font_size; paint->wordSpacing = style.word_spacing; paint->scaleX = 1.0f; - // Prevent spacing rounding in Minikin. - paint->paintFlags = 0xFF; + // Prevent spacing rounding in Minikin. This causes jitter when switching + // between same text content with different runs composing it, however, it + // also produces more accurate layouts. + paint->paintFlags |= + style.round_char_advances ? 0x00 : minikin::LinearTextFlag; } void GetPaint(const TextStyle& style, SkPaint* paint) { @@ -649,7 +653,7 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, // Backup value if the fUnderlineThickness metric is not available: // Divide by 14pt as it is the default size. : record.style().font_size / 14.0f * - record.style().decoration_thickness); + record.style().decoration_thickness_multiplier); // Setup the decorations. switch (record.style().decoration_style) { @@ -740,7 +744,7 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, if (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: kStrikeoutThicknessIsValid_Flag)) paint.setStrokeWidth(metrics.fStrikeoutThickness * - record.style().decoration_thickness); + record.style().decoration_thickness_multiplier); // Make sure the double line is "centered" vertically. y_offset += (decoration_count - 1.0) * metrics.fUnderlineThickness * kDoubleDecorationSpacing / -2.0; diff --git a/engine/src/flutter/src/text_style.cc b/engine/src/flutter/src/text_style.cc index fa9e510cff..67da19a2a5 100644 --- a/engine/src/flutter/src/text_style.cc +++ b/engine/src/flutter/src/text_style.cc @@ -30,7 +30,7 @@ bool TextStyle::equals(const TextStyle& other) const { return false; if (decoration_style != other.decoration_style) return false; - if (decoration_thickness != other.decoration_thickness) + if (decoration_thickness_multiplier != other.decoration_thickness_multiplier) return false; if (font_weight != other.font_weight) return false; @@ -44,6 +44,8 @@ bool TextStyle::equals(const TextStyle& other) const { return false; if (height != other.height) return false; + if (round_char_advances != other.round_char_advances) + return false; return true; } diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index 9e0c88da85..bda359f028 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -35,7 +35,8 @@ class TextStyle { // value to indicate no decoration color was set. SkColor decoration_color = SK_ColorTRANSPARENT; TextDecorationStyle decoration_style = TextDecorationStyle::kSolid; - double decoration_thickness = 1.0; + // Thickness is applied as a multiplier to the default thickness of the font. + double decoration_thickness_multiplier = 1.0; FontWeight font_weight = FontWeight::w400; FontStyle font_style = FontStyle::normal; TextBaseline text_baseline = TextBaseline::kAlphabetic; @@ -45,6 +46,16 @@ class TextStyle { double word_spacing = 0.0; double height = 1.0; + // When disabled, the x coordinates of glyphs will be rounded, eliminating + // potential mismatch between one long run and mutiple shorter runs of the + // same text. + // + // When set to false, there may be jitter when switching between same text + // content with different runs composing it, however, it also produces more + // accurate layouts. Setting to true removs this, but sacrifices layout + // accuracy. + bool round_char_advances = false; + bool equals(const TextStyle& other) const; }; From 4868e24e0e35d0052e6216af46842dd2fe3cc488 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Fri, 4 Aug 2017 16:46:24 -0700 Subject: [PATCH 353/364] Separate handling of letterspace/advance to fix multi-run text jitter, temp disable ligatures. Change-Id: Ia33b105fe8dc968cdcb365501842b4595b6e7922 --- engine/src/flutter/src/paragraph.cc | 39 +++++++++++++------ engine/src/flutter/src/paragraph.h | 2 + .../flutter/tests/txt/paragraph_unittests.cc | 30 +++++++------- 3 files changed, 44 insertions(+), 27 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 7c5fc79934..606855cd6f 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -109,6 +109,17 @@ void GetFontAndMinikinPaint(const TextStyle& style, // also produces more accurate layouts. paint->paintFlags |= style.round_char_advances ? 0x00 : minikin::LinearTextFlag; + // Disable ligatures + // TODO(garyq): Re-enable ligatures. + std::vector features; + hb_feature_t no_liga = {HB_TAG('l', 'i', 'g', 'a'), 0, 0, ~0u}; + hb_feature_t no_clig = {HB_TAG('c', 'l', 'i', 'g'), 0, 0, ~0u}; + char buff[HB_FEATURE_BUFFER_SIZE * 2]; + hb_feature_to_string(&no_liga, buff, HB_FEATURE_BUFFER_SIZE); + hb_feature_to_string(&no_clig, buff + HB_FEATURE_BUFFER_SIZE, + HB_FEATURE_BUFFER_SIZE); + paint->fontFeatureSettings = + std::string(buff) + "," + std::string(buff + HB_FEATURE_BUFFER_SIZE); } void GetPaint(const TextStyle& style, SkPaint* paint) { @@ -236,6 +247,7 @@ void Paragraph::Layout(double width, bool force) { double justify_spacing = 0.0f; double prev_word_pos = 0.0f; double prev_char_advance = 0.0f; + double current_x_position = previous_run_x_position; std::vector buffers; std::vector buffer_sizes; @@ -319,7 +331,7 @@ void Paragraph::Layout(double width, bool force) { const size_t layout_end = std::min(run.end, next_break); bool bidiFlags = paragraph_style_.rtl; - // NOTE: Minikin Layout doLayout() has an O(N^2) (according to + // Minikin Layout doLayout() has an O(N^2) (according to // benchmarks) time complexity where N is the total number of characters. // However, this is not significant for reasonably sized paragraphs. It is // currently recommended to break up very long paragraphs (10k+ @@ -339,8 +351,7 @@ void Paragraph::Layout(double width, bool force) { buffer_sizes = std::vector(); word_count = 0; double temp_line_spacing = 0; - double current_x_position = previous_run_x_position; - double run_width = 0.0f; + current_x_position = 0; while (blob_start < glyph_count) { const size_t blob_length = GetBlobLength(layout, blob_start); buffer_sizes.push_back(blob_length); @@ -356,6 +367,7 @@ void Paragraph::Layout(double width, bool force) { layout_end == next_break) { ++trailing_length; } + trailing_length = 0; buffers.push_back( &builder.allocRunPos(paint, blob_length - trailing_length)); @@ -363,19 +375,22 @@ void Paragraph::Layout(double width, bool force) { // TODO(garyq): Implement RTL. // Each Glyph/Letter. bool whitespace_ended = true; + float letter_spacing = 0; for (size_t blob_index = 0; blob_index < blob_length - trailing_length; ++blob_index) { const size_t glyph_index = blob_start + blob_index; buffers.back()->glyphs[blob_index] = layout.getGlyphId(glyph_index); const size_t pos_index = 2 * blob_index; - - current_x_position = layout.getX(glyph_index); - buffers.back()->pos[pos_index] = current_x_position; - glyph_single_line_position_x.push_back(current_x_position + - previous_run_x_position); + letter_spacing = run.style.letter_spacing == 0 + ? 0 + : layout.getX(glyph_index) - current_x_position; + buffers.back()->pos[pos_index] = current_x_position + letter_spacing; + glyph_single_line_position_x.push_back( + current_x_position + previous_run_x_position + letter_spacing); buffers.back()->pos[pos_index + 1] = layout.getY(glyph_index); + current_x_position += layout.getCharAdvance(glyph_index); // Check if the current Glyph is a whitespace and handle multiple // whitespaces in a row. if (whitespace_set_.count(layout.getGlyphId(glyph_index)) > 0) { @@ -390,10 +405,9 @@ void Paragraph::Layout(double width, bool force) { } prev_char_advance = layout.getCharAdvance(glyph_index); - run_width += layout.getCharAdvance(glyph_index); } blob_start += blob_length; - previous_run_x_position += current_x_position + prev_char_advance; + previous_run_x_position += current_x_position + letter_spacing; } // TODO(abarth): We could keep the same SkTextBlobBuilder as long as the @@ -405,8 +419,8 @@ void Paragraph::Layout(double width, bool force) { buffer_sizes.size() > 0) { JustifyLine(buffers, buffer_sizes, word_count, justify_spacing); } - records_.push_back( - PaintRecord{run.style, builder.make(), metrics, lines_, run_width}); + records_.push_back(PaintRecord{run.style, builder.make(), metrics, lines_, + layout.getAdvance()}); line_width += std::abs(records_[records_.size() - 1].text()->bounds().fRight + records_[records_.size() - 1].text()->bounds().fLeft); @@ -452,6 +466,7 @@ void Paragraph::Layout(double width, bool force) { prev_word_pos = 0; prev_char_advance = 0.0f; previous_run_x_position = 0.0f; + current_x_position = 0.0f; line_width = 0.0f; break_index += 1; lines_++; diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 3aa6265ce6..3208c65d8c 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -31,6 +31,8 @@ #include "third_party/skia/include/core/SkRect.h" #include "third_party/skia/include/core/SkTextBlob.h" +#define HB_FEATURE_BUFFER_SIZE 128 + class SkCanvas; namespace txt { diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index a818c71514..8c45dbbd02 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -993,17 +993,17 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_EQ(rects.size(), 3ull); EXPECT_FLOAT_EQ(rects[0].left(), 56.835938); EXPECT_FLOAT_EQ(rects[0].top(), 0); - EXPECT_FLOAT_EQ(rects[0].right(), 153); + EXPECT_FLOAT_EQ(rects[0].right(), 153.07422); EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); - EXPECT_FLOAT_EQ(rects[1].left(), 153); + EXPECT_FLOAT_EQ(rects[1].left(), 153.07422); EXPECT_FLOAT_EQ(rects[1].top(), 0); - EXPECT_FLOAT_EQ(rects[1].right(), 165); + EXPECT_FLOAT_EQ(rects[1].right(), 165.52344); EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); - EXPECT_FLOAT_EQ(rects[2].left(), 165); + EXPECT_FLOAT_EQ(rects[2].left(), 165.52344); EXPECT_FLOAT_EQ(rects[2].top(), 0); - EXPECT_FLOAT_EQ(rects[2].right(), 177); + EXPECT_FLOAT_EQ(rects[2].right(), 177.97266); EXPECT_FLOAT_EQ(rects[2].bottom(), 58.59375); paint.setColor(SK_ColorGREEN); @@ -1012,19 +1012,19 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { GetCanvas()->drawRect(rects[i], paint); } EXPECT_EQ(rects.size(), 3ull); - EXPECT_FLOAT_EQ(rects[0].left(), 177); + EXPECT_FLOAT_EQ(rects[0].left(), 177.97266); EXPECT_FLOAT_EQ(rects[0].top(), 0); - EXPECT_FLOAT_EQ(rects[0].right(), 352); + EXPECT_FLOAT_EQ(rects[0].right(), 352.48438); EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); - EXPECT_FLOAT_EQ(rects[1].left(), 352); + EXPECT_FLOAT_EQ(rects[1].left(), 352.48438); EXPECT_FLOAT_EQ(rects[1].top(), 0); - EXPECT_FLOAT_EQ(rects[1].right(), 364); + EXPECT_FLOAT_EQ(rects[1].right(), 364.93359); EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); - EXPECT_FLOAT_EQ(rects[2].left(), 364); + EXPECT_FLOAT_EQ(rects[2].left(), 364.93359); EXPECT_FLOAT_EQ(rects[2].top(), 0); - EXPECT_FLOAT_EQ(rects[2].right(), 507); + EXPECT_FLOAT_EQ(rects[2].right(), 507.02344); EXPECT_FLOAT_EQ(rects[2].bottom(), 58.59375); paint.setColor(SK_ColorRED); @@ -1033,9 +1033,9 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { GetCanvas()->drawRect(rects[i], paint); } EXPECT_EQ(rects.size(), 17ull); - EXPECT_FLOAT_EQ(rects[0].left(), 210.83594); + EXPECT_FLOAT_EQ(rects[0].left(), 211.375); EXPECT_FLOAT_EQ(rects[0].top(), 58.59375); - EXPECT_FLOAT_EQ(rects[0].right(), 296); + EXPECT_FLOAT_EQ(rects[0].right(), 296.62891); EXPECT_FLOAT_EQ(rects[0].bottom(), 117.1875); // TODO(garyq): The following set of vals are definetly wrong and @@ -1051,9 +1051,9 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { GetCanvas()->drawRect(rects[i], paint); } EXPECT_EQ(rects.size(), 2ull); - EXPECT_FLOAT_EQ(rects[1].left(), 507); + EXPECT_FLOAT_EQ(rects[1].left(), 507.02344); EXPECT_FLOAT_EQ(rects[1].top(), 0); - EXPECT_FLOAT_EQ(rects[1].right(), 519.44922); + EXPECT_FLOAT_EQ(rects[1].right(), 519.47266); EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); paint.setColor(SK_ColorRED); From 39f8a13f4dc5d785b5f68ea7f5cd3ce6112b7745 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 7 Aug 2017 10:22:13 -0700 Subject: [PATCH 354/364] Break on hyphens without minikin::Hyphenator, tests. Change-Id: I42e449134ac8c007ffa07d7f56a8c56a26ec47a5 --- .../src/flutter/libs/minikin/WordBreaker.cpp | 3 +- engine/src/flutter/src/paragraph.h | 1 + engine/src/flutter/src/styled_runs.h | 1 + .../flutter/tests/txt/paragraph_unittests.cc | 45 +++++++++++++++++++ 4 files changed, 49 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/libs/minikin/WordBreaker.cpp b/engine/src/flutter/libs/minikin/WordBreaker.cpp index 8d0d0fb4b4..3577ddd6aa 100644 --- a/engine/src/flutter/libs/minikin/WordBreaker.cpp +++ b/engine/src/flutter/libs/minikin/WordBreaker.cpp @@ -70,7 +70,8 @@ static bool isBreakValid(const uint16_t* buf, size_t bufEnd, size_t i) { U16_PREV(buf, 0, prev_offset, codePoint); // Do not break on hard or soft hyphens. These are handled by automatic hyphenation. if (Hyphenator::isLineBreakingHyphen(codePoint) || codePoint == CHAR_SOFT_HYPHEN) { - return false; + // txt addition: Temporarily always break on hyphen. Changed from false to true. + return true; } // For Myanmar kinzi sequences, created by . This is to go // around a bug in ICU line breaking: http://bugs.icu-project.org/trac/ticket/12561. To avoid diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 3208c65d8c..08d90e7846 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -162,6 +162,7 @@ class Paragraph { FRIEND_TEST(RenderTest, KernScaleParagraph); FRIEND_TEST(RenderTest, NewlineParagraph); FRIEND_TEST(RenderTest, EmojiParagraph); + FRIEND_TEST(RenderTest, HyphenBreakParagraph); // Starting data to layout. std::vector text_; diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index 24ac305700..e731d61b16 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -76,6 +76,7 @@ class StyledRuns { FRIEND_TEST(RenderTest, DISABLED_ArabicParagraph); FRIEND_TEST(RenderTest, LongWordParagraph); FRIEND_TEST(RenderTest, KernParagraph); + FRIEND_TEST(RenderTest, HyphenBreakParagraph); struct IndexedRun { size_t style_index = 0; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 8c45dbbd02..abdff311e7 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -1439,4 +1439,49 @@ TEST_F(RenderTest, EmojiParagraph) { ASSERT_TRUE(Snapshot()); } +TEST_F(RenderTest, HyphenBreakParagraph) { + const char* text = + "A " + "very-very-long-Hyphen-word-to-see-where-this-will-wrap-or-if-it-will-at-" + "all-and-if-it-does-thent-hat-" + "would-be-a-good-thing-because-the-breaking."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.break_strategy = minikin::kBreakStrategy_HighQuality; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.font_family = "Roboto"; + text_style.font_size = 31; + text_style.letter_spacing = 0; + text_style.word_spacing = 0; + text_style.color = SK_ColorBLACK; + text_style.height = 1; + builder.PushStyle(text_style); + builder.AddText(u16_text); + + builder.Pop(); + + auto paragraph = builder.Build(); + paragraph->Layout(GetTestCanvasWidth() / 2); + + paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_TRUE(Snapshot()); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_EQ(paragraph->GetLineCount(), 5); + ASSERT_TRUE(Snapshot()); +} + } // namespace txt From 1046161c3ece47c6dbae2063448da2504f17feca Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 7 Aug 2017 10:38:16 -0700 Subject: [PATCH 355/364] Save txt unittest snapshots in own folder to declutter. Change-Id: Id51b88ced443c58c5cccdc666fa1d412845a5469 --- engine/src/flutter/tests/txt/render_test.cc | 23 ++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/tests/txt/render_test.cc b/engine/src/flutter/tests/txt/render_test.cc index aa80d0b6fd..42d809bd48 100644 --- a/engine/src/flutter/tests/txt/render_test.cc +++ b/engine/src/flutter/tests/txt/render_test.cc @@ -15,6 +15,10 @@ */ #include "render_test.h" + +#include + +#include "lib/ftl/logging.h" #include "third_party/skia/include/core/SkImageEncoder.h" #include "third_party/skia/include/core/SkStream.h" @@ -31,7 +35,8 @@ std::string RenderTest::GetNextSnapshotName() { ::testing::UnitTest::GetInstance()->current_test_info(); std::stringstream stream; - stream << test_info->test_case_name() << "_" << test_info->name(); + stream << "snapshots/" << test_info->test_case_name() << "_" + << test_info->name(); stream << "_" << ++snapshots_ << ".png"; return stream.str(); @@ -41,6 +46,22 @@ bool RenderTest::Snapshot() { if (!canvas_ || !bitmap_) { return false; } + std::string snapshot_dir = "snapshots"; + int error = 0; +// _WIN32 defined by Windows Visual compiler. +#if defined(_WIN32) + // Handle windows path creation. + error = _mkdir(snapshot_dir.c_str()); +#else + // Handle non-windows path creation with Unix permissions. + mode_t permissions = 0733; + error = mkdir(snapshot_dir.c_str(), permissions); +#endif + if (error > 0) { + FTL_LOG(ERROR) << "'snapshot/' Directory not available and could not be " + "created. Please create manually to save snapshot."; + return false; + } auto file_name = GetNextSnapshotName(); SkFILEWStream file(file_name.c_str()); return SkEncodeImage(&file, *bitmap_, SkEncodedImageFormat::kPNG, 100); From 76d250550b9d5a8139ea4bd6db78d610dfd99dc2 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 7 Aug 2017 16:18:52 -0700 Subject: [PATCH 356/364] Reset breaker after every layout to handle different widths. Change-Id: I786c4c42b4db9418f4f802b4cbb70a051b35925a --- engine/src/flutter/src/paragraph.cc | 6 +- engine/src/flutter/src/paragraph.h | 9 ++- engine/src/flutter/src/styled_runs.h | 1 + .../flutter/tests/txt/paragraph_unittests.cc | 61 +++++++++++++++++++ 4 files changed, 75 insertions(+), 2 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 606855cd6f..5bb0a41f0e 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -140,7 +140,9 @@ void Paragraph::SetText(std::vector text, StyledRuns runs) { return; text_ = std::move(text); runs_ = std::move(runs); +} +void Paragraph::InitBreaker() { breaker_.setLocale(icu::Locale(), nullptr); breaker_.resize(text_.size()); memcpy(breaker_.buffer(), text_.data(), text_.size() * sizeof(text_[0])); @@ -182,7 +184,7 @@ void Paragraph::FillWhitespaceSet(size_t start, void Paragraph::Layout(double width, bool force) { // Do not allow calling layout multiple times without changing anything. - if (!needs_layout_ && !force && width == width_) + if (!needs_layout_ && width == width_ && !force) return; needs_layout_ = false; @@ -199,6 +201,7 @@ void Paragraph::Layout(double width, bool force) { // minikin::Hyphenator::loadBinary(); // breaker_.setLocale(icu::Locale::getRoot(), &hyph); // + InitBreaker(); AddRunsToLineBreaker(collection_map); breaker_.setJustified(paragraph_style_.text_align == TextAlign::justify); breaker_.setStrategy(paragraph_style_.break_strategy); @@ -505,6 +508,7 @@ void Paragraph::Layout(double width, bool force) { line_widths_ = std::vector(breaker_.getWidths(), breaker_.getWidths() + lines_); CalculateIntrinsicWidths(); + breaker_.finish(); } // Amends the buffers to incorporate justification. diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 08d90e7846..d4b7a491b3 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -163,6 +163,7 @@ class Paragraph { FRIEND_TEST(RenderTest, NewlineParagraph); FRIEND_TEST(RenderTest, EmojiParagraph); FRIEND_TEST(RenderTest, HyphenBreakParagraph); + FRIEND_TEST(RenderTest, RepeatLayoutParagraph); // Starting data to layout. std::vector text_; @@ -187,7 +188,7 @@ class Paragraph { // The max width of the paragraph as provided in the most recent Layout() // call. - double width_ = 0.0f; + double width_ = -1.0f; SkScalar height_ = 0.0f; size_t lines_ = 0; double max_intrinsic_width_ = 0; @@ -207,8 +208,14 @@ class Paragraph { : x_start(x_s), y_start(y_s), x_end(x_e), y_end(y_e) {} }; + // Passes in the text and Styled Runs. text_ and runs_ will later be passed + // into breaker_ in InitBreaker(), which is called in Layout(). void SetText(std::vector text, StyledRuns runs); + // Sets up breaker_ with the contents of text_ and runs_. This is called every + // Layout() call to allow for different widths to be used. + void InitBreaker(); + void SetParagraphStyle(const ParagraphStyle& style); void SetFontCollection(FontCollection* font_collection); diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index e731d61b16..ff3d58aaba 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -77,6 +77,7 @@ class StyledRuns { FRIEND_TEST(RenderTest, LongWordParagraph); FRIEND_TEST(RenderTest, KernParagraph); FRIEND_TEST(RenderTest, HyphenBreakParagraph); + FRIEND_TEST(RenderTest, RepeatLayoutParagraph); struct IndexedRun { size_t style_index = 0; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index abdff311e7..103c49b7f9 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -1484,4 +1484,65 @@ TEST_F(RenderTest, HyphenBreakParagraph) { ASSERT_TRUE(Snapshot()); } +TEST_F(RenderTest, RepeatLayoutParagraph) { + const char* text = + "Sentence to layout at diff widths to get diff line counts. short words " + "short words short words short words short words short words short words " + "short words short words short words short words short words short words"; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + paragraph_style.break_strategy = minikin::kBreakStrategy_HighQuality; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + txt::TextStyle text_style; + text_style.font_family = "Roboto"; + text_style.font_size = 31; + text_style.letter_spacing = 0; + text_style.word_spacing = 0; + text_style.color = SK_ColorBLACK; + text_style.height = 1; + builder.PushStyle(text_style); + builder.AddText(u16_text); + + builder.Pop(); + + // First Layout. + auto paragraph = builder.Build(); + paragraph->Layout(300); + + paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_TRUE(Snapshot()); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_EQ(paragraph->GetLineCount(), 12); + + // Second Layout. + SetUp(); + paragraph->Layout(600); + paragraph->Paint(GetCanvas(), 0, 0); + + ASSERT_TRUE(Snapshot()); + ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); + for (size_t i = 0; i < u16_text.length(); i++) { + ASSERT_EQ(paragraph->text_[i], u16_text[i]); + } + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); + ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_EQ(paragraph->GetLineCount(), 6); + ASSERT_TRUE(Snapshot()); +} + } // namespace txt From f1daa1e629411676f5ca84387372330e9454998e Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 7 Aug 2017 16:25:18 -0700 Subject: [PATCH 357/364] Hardcode no-ligature flags for performance boost, minor bugfix on trailing space. Change-Id: Ic61b7fba6ded25790f78b5040e4eb5ba3d1376a5 --- engine/src/flutter/src/paragraph.cc | 19 ++++++------------- engine/src/flutter/src/paragraph.h | 2 -- 2 files changed, 6 insertions(+), 15 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 5bb0a41f0e..54d5e8a7ca 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -109,17 +109,6 @@ void GetFontAndMinikinPaint(const TextStyle& style, // also produces more accurate layouts. paint->paintFlags |= style.round_char_advances ? 0x00 : minikin::LinearTextFlag; - // Disable ligatures - // TODO(garyq): Re-enable ligatures. - std::vector features; - hb_feature_t no_liga = {HB_TAG('l', 'i', 'g', 'a'), 0, 0, ~0u}; - hb_feature_t no_clig = {HB_TAG('c', 'l', 'i', 'g'), 0, 0, ~0u}; - char buff[HB_FEATURE_BUFFER_SIZE * 2]; - hb_feature_to_string(&no_liga, buff, HB_FEATURE_BUFFER_SIZE); - hb_feature_to_string(&no_clig, buff + HB_FEATURE_BUFFER_SIZE, - HB_FEATURE_BUFFER_SIZE); - paint->fontFeatureSettings = - std::string(buff) + "," + std::string(buff + HB_FEATURE_BUFFER_SIZE); } void GetPaint(const TextStyle& style, SkPaint* paint) { @@ -220,6 +209,10 @@ void Paragraph::Layout(double width, bool force) { minikin::MinikinPaint minikin_paint; minikin::Layout layout; + // Disable ligatures + // TODO(garyq): Re-enable ligatures. + minikin_paint.fontFeatureSettings += "-liga,-clig,"; + SkTextBlobBuilder builder; // Reset member variables so Layout still works when called more than once @@ -370,7 +363,6 @@ void Paragraph::Layout(double width, bool force) { layout_end == next_break) { ++trailing_length; } - trailing_length = 0; buffers.push_back( &builder.allocRunPos(paint, blob_length - trailing_length)); @@ -385,6 +377,7 @@ void Paragraph::Layout(double width, bool force) { buffers.back()->glyphs[blob_index] = layout.getGlyphId(glyph_index); const size_t pos_index = 2 * blob_index; + // Extract the letter spacing by itself out of the minikin layout. letter_spacing = run.style.letter_spacing == 0 ? 0 : layout.getX(glyph_index) - current_x_position; @@ -625,9 +618,9 @@ void Paragraph::SetFontCollection(FontCollection* font_collection) { void Paragraph::Paint(SkCanvas* canvas, double x, double y) { SkAutoCanvasRestore canvas_restore(canvas, true); canvas->translate(x, y); + SkPaint paint; for (size_t index = 0; index < records_.size(); ++index) { PaintRecord& record = records_[index]; - SkPaint paint; paint.setColor(record.style().color); SkPoint offset = record.offset(); canvas->drawTextBlob(record.text(), offset.x(), offset.y(), paint); diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index d4b7a491b3..9fb8865056 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -31,8 +31,6 @@ #include "third_party/skia/include/core/SkRect.h" #include "third_party/skia/include/core/SkTextBlob.h" -#define HB_FEATURE_BUFFER_SIZE 128 - class SkCanvas; namespace txt { From 843d2bd71d08489b39838afb07b3fa7083c2c166 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Mon, 7 Aug 2017 17:09:04 -0700 Subject: [PATCH 358/364] Change type of line_ to size_t for consistency. Change-Id: I8a15cc727dadd5f6ea9f60bd2443df068167e07c --- engine/src/flutter/src/paint_record.cc | 4 ++-- engine/src/flutter/src/paint_record.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/src/paint_record.cc b/engine/src/flutter/src/paint_record.cc index bcb396e6c3..3291d6ec99 100644 --- a/engine/src/flutter/src/paint_record.cc +++ b/engine/src/flutter/src/paint_record.cc @@ -25,7 +25,7 @@ PaintRecord::PaintRecord(TextStyle style, SkPoint offset, sk_sp text, SkPaint::FontMetrics metrics, - int line, + size_t line, double run_width) : style_(style), offset_(offset), @@ -37,7 +37,7 @@ PaintRecord::PaintRecord(TextStyle style, PaintRecord::PaintRecord(TextStyle style, sk_sp text, SkPaint::FontMetrics metrics, - int line, + size_t line, double run_width) : style_(style), text_(std::move(text)), diff --git a/engine/src/flutter/src/paint_record.h b/engine/src/flutter/src/paint_record.h index 5d60c9425d..09e1b46523 100644 --- a/engine/src/flutter/src/paint_record.h +++ b/engine/src/flutter/src/paint_record.h @@ -38,13 +38,13 @@ class PaintRecord { SkPoint offset, sk_sp text, SkPaint::FontMetrics metrics, - int line, + size_t line, double run_width); PaintRecord(TextStyle style, sk_sp text, SkPaint::FontMetrics metrics, - int line, + size_t line, double run_width); PaintRecord(PaintRecord&& other); From 099c300214a2be35fd066f40a6453cb8426c0c2e Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 8 Aug 2017 12:01:14 -0700 Subject: [PATCH 359/364] Round height offsets to better match Blink and fix red boxes in flutter app. Change-Id: I3cdaf5b849ea537f0e4b2406a006ba7be2f0cd61 --- engine/src/flutter/src/paragraph.cc | 12 ++-- .../flutter/tests/txt/paragraph_unittests.cc | 70 +++++++++---------- 2 files changed, 41 insertions(+), 41 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 54d5e8a7ca..4108503edc 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -443,10 +443,10 @@ void Paragraph::Layout(double width, bool force) { max_descent = temp_line_spacing; if (layout_end == next_break || is_newline) { - y += max_line_spacing + prev_max_descent; + y += roundf(max_line_spacing + prev_max_descent); line_heights_.push_back( (line_heights_.empty() ? 0 : line_heights_.back()) + - max_line_spacing + max_descent); + roundf(max_line_spacing + max_descent)); glyph_single_line_position_x.push_back( glyph_single_line_position_x.back() + prev_char_advance); glyph_single_line_position_x.push_back(FLT_MAX); @@ -476,13 +476,13 @@ void Paragraph::Layout(double width, bool force) { } } // Handle last line tasks. - y += max_line_spacing; - height_ = y + max_descent; + y += roundf(max_line_spacing + prev_max_descent); + height_ = y + roundf(max_descent); postprocess_line(); if (line_width != 0) line_widths_.push_back(line_width); line_heights_.push_back((line_heights_.empty() ? 0 : line_heights_.back()) + - max_line_spacing + max_descent); + roundf(max_line_spacing + max_descent)); glyph_single_line_position_x.push_back(glyph_single_line_position_x.back() + prev_char_advance); glyph_single_line_position_x.push_back(FLT_MAX); @@ -589,7 +589,7 @@ size_t Paragraph::TextSize() const { } double Paragraph::GetHeight() const { - return line_heights_[line_heights_.size() - 2]; + return height_; } double Paragraph::GetLayoutWidth() const { diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 103c49b7f9..0da17ca361 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -315,26 +315,26 @@ TEST_F(RenderTest, LeftAlignParagraph) { ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); - double expected_y = 24.12109375; + double expected_y = 24; ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().x(), 0); ASSERT_TRUE(paragraph->records_[1].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().x(), 0); ASSERT_TRUE(paragraph->records_[2].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 0); ASSERT_TRUE(paragraph->records_[3].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().y(), expected_y); - expected_y += 30.46875 * 10; + expected_y += 30 * 10; ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 0); ASSERT_TRUE(paragraph->records_[13].style().equals(text_style)); @@ -411,11 +411,11 @@ TEST_F(RenderTest, RightAlignParagraph) { ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); - double expected_y = 24.12109375; + double expected_y = 24; ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_DOUBLE_EQ( paragraph->records_[0].offset().x(), paragraph->width_ - @@ -423,7 +423,7 @@ TEST_F(RenderTest, RightAlignParagraph) { ASSERT_TRUE(paragraph->records_[1].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_DOUBLE_EQ( paragraph->records_[1].offset().x(), paragraph->width_ - @@ -431,7 +431,7 @@ TEST_F(RenderTest, RightAlignParagraph) { ASSERT_TRUE(paragraph->records_[2].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_DOUBLE_EQ( paragraph->records_[2].offset().x(), paragraph->width_ - @@ -439,7 +439,7 @@ TEST_F(RenderTest, RightAlignParagraph) { ASSERT_TRUE(paragraph->records_[3].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().y(), expected_y); - expected_y += 30.46875 * 10; + expected_y += 30 * 10; ASSERT_DOUBLE_EQ( paragraph->records_[3].offset().x(), paragraph->width_ - @@ -515,11 +515,11 @@ TEST_F(RenderTest, CenterAlignParagraph) { ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); - double expected_y = 24.12109375; + double expected_y = 24; ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_DOUBLE_EQ( paragraph->records_[0].offset().x(), (paragraph->width_ - @@ -528,7 +528,7 @@ TEST_F(RenderTest, CenterAlignParagraph) { ASSERT_TRUE(paragraph->records_[1].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_DOUBLE_EQ( paragraph->records_[1].offset().x(), (paragraph->width_ - @@ -537,7 +537,7 @@ TEST_F(RenderTest, CenterAlignParagraph) { ASSERT_TRUE(paragraph->records_[2].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_EQ(paragraph->records_[2].offset().x(), (paragraph->width_ - paragraph->breaker_.getWidths()[paragraph->records_[2].line()]) / @@ -545,7 +545,7 @@ TEST_F(RenderTest, CenterAlignParagraph) { ASSERT_TRUE(paragraph->records_[3].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().y(), expected_y); - expected_y += 30.46875 * 10; + expected_y += 30 * 10; ASSERT_DOUBLE_EQ( paragraph->records_[3].offset().x(), (paragraph->width_ - @@ -621,26 +621,26 @@ TEST_F(RenderTest, JustifyAlignParagraph) { ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); - double expected_y = 24.12109375; + double expected_y = 24; ASSERT_TRUE(paragraph->records_[0].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_DOUBLE_EQ(paragraph->records_[0].offset().x(), 0); ASSERT_TRUE(paragraph->records_[1].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_DOUBLE_EQ(paragraph->records_[1].offset().x(), 0); ASSERT_TRUE(paragraph->records_[2].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().y(), expected_y); - expected_y += 30.46875; + expected_y += 30; ASSERT_DOUBLE_EQ(paragraph->records_[2].offset().x(), 0); ASSERT_TRUE(paragraph->records_[3].style().equals(text_style)); ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().y(), expected_y); - expected_y += 30.46875 * 10; + expected_y += 30 * 10; ASSERT_DOUBLE_EQ(paragraph->records_[3].offset().x(), 0); ASSERT_TRUE(paragraph->records_[13].style().equals(text_style)); @@ -973,7 +973,7 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[0].left(), 0); EXPECT_FLOAT_EQ(rects[0].top(), 0); EXPECT_FLOAT_EQ(rects[0].right(), 28.417969); - EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); + EXPECT_FLOAT_EQ(rects[0].bottom(), 59); rects = paragraph->GetRectsForRange(0, 1); for (size_t i = 0; i < rects.size(); ++i) { @@ -983,7 +983,7 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[0].left(), 0); EXPECT_FLOAT_EQ(rects[0].top(), 0); EXPECT_FLOAT_EQ(rects[0].right(), 28.417969); - EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); + EXPECT_FLOAT_EQ(rects[0].bottom(), 59); paint.setColor(SK_ColorBLUE); rects = paragraph->GetRectsForRange(2, 8); @@ -994,17 +994,17 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[0].left(), 56.835938); EXPECT_FLOAT_EQ(rects[0].top(), 0); EXPECT_FLOAT_EQ(rects[0].right(), 153.07422); - EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); + EXPECT_FLOAT_EQ(rects[0].bottom(), 59); EXPECT_FLOAT_EQ(rects[1].left(), 153.07422); EXPECT_FLOAT_EQ(rects[1].top(), 0); EXPECT_FLOAT_EQ(rects[1].right(), 165.52344); - EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); + EXPECT_FLOAT_EQ(rects[1].bottom(), 59); EXPECT_FLOAT_EQ(rects[2].left(), 165.52344); EXPECT_FLOAT_EQ(rects[2].top(), 0); EXPECT_FLOAT_EQ(rects[2].right(), 177.97266); - EXPECT_FLOAT_EQ(rects[2].bottom(), 58.59375); + EXPECT_FLOAT_EQ(rects[2].bottom(), 59); paint.setColor(SK_ColorGREEN); rects = paragraph->GetRectsForRange(8, 21); @@ -1015,17 +1015,17 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[0].left(), 177.97266); EXPECT_FLOAT_EQ(rects[0].top(), 0); EXPECT_FLOAT_EQ(rects[0].right(), 352.48438); - EXPECT_FLOAT_EQ(rects[0].bottom(), 58.59375); + EXPECT_FLOAT_EQ(rects[0].bottom(), 59); EXPECT_FLOAT_EQ(rects[1].left(), 352.48438); EXPECT_FLOAT_EQ(rects[1].top(), 0); EXPECT_FLOAT_EQ(rects[1].right(), 364.93359); - EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); + EXPECT_FLOAT_EQ(rects[1].bottom(), 59); EXPECT_FLOAT_EQ(rects[2].left(), 364.93359); EXPECT_FLOAT_EQ(rects[2].top(), 0); EXPECT_FLOAT_EQ(rects[2].right(), 507.02344); - EXPECT_FLOAT_EQ(rects[2].bottom(), 58.59375); + EXPECT_FLOAT_EQ(rects[2].bottom(), 59); paint.setColor(SK_ColorRED); rects = paragraph->GetRectsForRange(30, 100); @@ -1034,16 +1034,16 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { } EXPECT_EQ(rects.size(), 17ull); EXPECT_FLOAT_EQ(rects[0].left(), 211.375); - EXPECT_FLOAT_EQ(rects[0].top(), 58.59375); + EXPECT_FLOAT_EQ(rects[0].top(), 59); EXPECT_FLOAT_EQ(rects[0].right(), 296.62891); - EXPECT_FLOAT_EQ(rects[0].bottom(), 117.1875); + EXPECT_FLOAT_EQ(rects[0].bottom(), 118); // TODO(garyq): The following set of vals are definetly wrong and // end of paragraph handling needs to be fixed in a later patch. EXPECT_FLOAT_EQ(rects[16].left(), 0); - EXPECT_FLOAT_EQ(rects[16].top(), 234.375); + EXPECT_FLOAT_EQ(rects[16].top(), 236); EXPECT_FLOAT_EQ(rects[16].right(), 142.08984); - EXPECT_FLOAT_EQ(rects[16].bottom(), 292.96875); + EXPECT_FLOAT_EQ(rects[16].bottom(), 295); paint.setColor(SK_ColorBLUE); rects = paragraph->GetRectsForRange(19, 22); @@ -1054,7 +1054,7 @@ TEST_F(RenderTest, GetRectsForRangeParagraph) { EXPECT_FLOAT_EQ(rects[1].left(), 507.02344); EXPECT_FLOAT_EQ(rects[1].top(), 0); EXPECT_FLOAT_EQ(rects[1].right(), 519.47266); - EXPECT_FLOAT_EQ(rects[1].bottom(), 58.59375); + EXPECT_FLOAT_EQ(rects[1].bottom(), 59); paint.setColor(SK_ColorRED); rects = paragraph->GetRectsForRange(21, 21); @@ -1390,8 +1390,8 @@ TEST_F(RenderTest, NewlineParagraph) { EXPECT_DOUBLE_EQ(paragraph->records_[6].offset().x(), 127.69921875); EXPECT_DOUBLE_EQ(paragraph->records_[7].offset().x(), 0); EXPECT_DOUBLE_EQ(paragraph->records_[8].offset().x(), 0); - EXPECT_DOUBLE_EQ(paragraph->records_[7].offset().y(), 336.9140625); - EXPECT_DOUBLE_EQ(paragraph->records_[8].offset().y(), 407.2265625); + EXPECT_DOUBLE_EQ(paragraph->records_[7].offset().y(), 336); + EXPECT_DOUBLE_EQ(paragraph->records_[8].offset().y(), 406); } TEST_F(RenderTest, EmojiParagraph) { From 9f1f39c29ed4442085959bd49de7c23de74225ba Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 8 Aug 2017 16:09:52 -0700 Subject: [PATCH 360/364] Remove redundant height_ variable and add Paragraph::Paint Benchmark. Change-Id: I82c4aee759f6ae8a869782f4fb9d979d1551eed9 --- .../benchmarks/paragraph_benchmarks.cc | 31 +++++++++++++++++++ engine/src/flutter/src/paragraph.cc | 4 +-- engine/src/flutter/src/paragraph.h | 1 - 3 files changed, 32 insertions(+), 4 deletions(-) diff --git a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc index e497168b08..ff8770b053 100644 --- a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc @@ -28,6 +28,8 @@ #include "lib/txt/src/paragraph_builder.h" #include "lib/txt/src/text_align.h" #include "third_party/icu/source/common/unicode/unistr.h" +#include "third_party/skia/include/core/SkBitmap.h" +#include "third_party/skia/include/core/SkCanvas.h" #include "third_party/skia/include/core/SkColor.h" #include "utils.h" @@ -223,6 +225,35 @@ BENCHMARK(BM_ParagraphStylesBigO) ->Range(1 << 3, 1 << 12) ->Complexity(benchmark::oN); +static void BM_ParagraphPaintSimple(benchmark::State& state) { + const char* text = "Hello world! This is a simple sentence to test drawing."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + builder.PushStyle(text_style); + builder.AddText(u16_text); + auto paragraph = builder.Build(); + paragraph->Layout(300, true); + + std::unique_ptr bitmap = std::make_unique(); + std::unique_ptr canvas = std::make_unique(*bitmap); + bitmap->allocN32Pixels(1000, 1000); + canvas->clear(SK_ColorWHITE); + int offset = 0; + while (state.KeepRunning()) { + paragraph->Paint(canvas.get(), offset % 700, 10); + offset++; + } +} +BENCHMARK(BM_ParagraphPaintSimple); + // ----------------------------------------------------------------------------- // // The following benchmarks break down the layout function and attempts to time diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 4108503edc..04b77f1488 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -221,7 +221,6 @@ void Paragraph::Layout(double width, bool force) { line_heights_ = std::vector(); line_heights_.push_back(0); records_ = std::vector(); - height_ = 0.0f; // Set padding elements to have a minimum point. glyph_position_x_ = std::vector>(); @@ -477,7 +476,6 @@ void Paragraph::Layout(double width, bool force) { } // Handle last line tasks. y += roundf(max_line_spacing + prev_max_descent); - height_ = y + roundf(max_descent); postprocess_line(); if (line_width != 0) line_widths_.push_back(line_width); @@ -589,7 +587,7 @@ size_t Paragraph::TextSize() const { } double Paragraph::GetHeight() const { - return height_; + return line_heights_[line_heights_.size() - 2]; } double Paragraph::GetLayoutWidth() const { diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 9fb8865056..614e50197b 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -187,7 +187,6 @@ class Paragraph { // The max width of the paragraph as provided in the most recent Layout() // call. double width_ = -1.0f; - SkScalar height_ = 0.0f; size_t lines_ = 0; double max_intrinsic_width_ = 0; double min_intrinsic_width_ = 0; From 653a763327c0d1de9108f23130da2c08b06b9d59 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Tue, 8 Aug 2017 17:46:09 -0700 Subject: [PATCH 361/364] Remove rounding x values option as a workaround since jitter has been fixed. Paint benchmarks. Change-Id: Ib74977f94768c096380a1cb9d6ec7d852fb52e4f --- .../benchmarks/paragraph_benchmarks.cc | 91 +++++++++++++++++++ engine/src/flutter/src/paragraph.cc | 3 +- engine/src/flutter/src/text_style.cc | 2 - engine/src/flutter/src/text_style.h | 10 -- 4 files changed, 92 insertions(+), 14 deletions(-) diff --git a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc index ff8770b053..389c6e5824 100644 --- a/engine/src/flutter/benchmarks/paragraph_benchmarks.cc +++ b/engine/src/flutter/benchmarks/paragraph_benchmarks.cc @@ -254,6 +254,97 @@ static void BM_ParagraphPaintSimple(benchmark::State& state) { } BENCHMARK(BM_ParagraphPaintSimple); +static void BM_ParagraphPaintLarge(benchmark::State& state) { + const char* text = + "Hello world! This is a simple sentence to test drawing. Hello world! " + "This is a simple sentence to test drawing. Hello world! This is a " + "simple sentence to test drawing.Hello world! This is a simple sentence " + "to test drawing. Hello world! " + "This is a simple sentence to test drawing. Hello world! This is a " + "simple sentence to test drawing.Hello world! This is a simple sentence " + "to test drawing. Hello world! " + "This is a simple sentence to test drawing. Hello world! This is a " + "simple sentence to test drawing.Hello world! This is a simple sentence " + "to test drawing. Hello world! " + "This is a simple sentence to test drawing. Hello world! This is a " + "simple sentence to test drawing.Hello world! This is a simple sentence " + "to test drawing. Hello world! " + "This is a simple sentence to test drawing. Hello world! This is a " + "simple sentence to test drawing.Hello world! This is a simple sentence " + "to test drawing. Hello world! " + "This is a simple sentence to test drawing. Hello world! This is a " + "simple sentence to test drawing."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + + txt::TextStyle text_style; + text_style.color = SK_ColorBLACK; + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + builder.PushStyle(text_style); + builder.AddText(u16_text); + auto paragraph = builder.Build(); + paragraph->Layout(300, true); + + std::unique_ptr bitmap = std::make_unique(); + std::unique_ptr canvas = std::make_unique(*bitmap); + bitmap->allocN32Pixels(1000, 1000); + canvas->clear(SK_ColorWHITE); + int offset = 0; + while (state.KeepRunning()) { + paragraph->Paint(canvas.get(), offset % 700, 10); + offset++; + } +} +BENCHMARK(BM_ParagraphPaintLarge); + +static void BM_ParagraphPaintDecoration(benchmark::State& state) { + const char* text = + "Hello world! This is a simple sentence to test drawing. Hello world! " + "This is a simple sentence to test drawing."; + auto icu_text = icu::UnicodeString::fromUTF8(text); + std::u16string u16_text(icu_text.getBuffer(), + icu_text.getBuffer() + icu_text.length()); + + txt::ParagraphStyle paragraph_style; + + txt::TextStyle text_style; + text_style.decoration = TextDecoration(0x1 | 0x2 | 0x4); + text_style.decoration_style = TextDecorationStyle(kSolid); + text_style.color = SK_ColorBLACK; + + auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); + txt::ParagraphBuilder builder(paragraph_style, &font_collection); + + builder.PushStyle(text_style); + builder.AddText(u16_text); + + text_style.decoration_style = TextDecorationStyle(kDotted); + builder.PushStyle(text_style); + builder.AddText(u16_text); + + text_style.decoration_style = TextDecorationStyle(kWavy); + builder.PushStyle(text_style); + builder.AddText(u16_text); + + auto paragraph = builder.Build(); + paragraph->Layout(300, true); + + std::unique_ptr bitmap = std::make_unique(); + std::unique_ptr canvas = std::make_unique(*bitmap); + bitmap->allocN32Pixels(1000, 1000); + canvas->clear(SK_ColorWHITE); + int offset = 0; + while (state.KeepRunning()) { + paragraph->Paint(canvas.get(), offset % 700, 10); + offset++; + } +} +BENCHMARK(BM_ParagraphPaintDecoration); + // ----------------------------------------------------------------------------- // // The following benchmarks break down the layout function and attempts to time diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 04b77f1488..9a0692ea0c 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -107,8 +107,7 @@ void GetFontAndMinikinPaint(const TextStyle& style, // Prevent spacing rounding in Minikin. This causes jitter when switching // between same text content with different runs composing it, however, it // also produces more accurate layouts. - paint->paintFlags |= - style.round_char_advances ? 0x00 : minikin::LinearTextFlag; + paint->paintFlags |= minikin::LinearTextFlag; } void GetPaint(const TextStyle& style, SkPaint* paint) { diff --git a/engine/src/flutter/src/text_style.cc b/engine/src/flutter/src/text_style.cc index 67da19a2a5..c902dcd1ac 100644 --- a/engine/src/flutter/src/text_style.cc +++ b/engine/src/flutter/src/text_style.cc @@ -44,8 +44,6 @@ bool TextStyle::equals(const TextStyle& other) const { return false; if (height != other.height) return false; - if (round_char_advances != other.round_char_advances) - return false; return true; } diff --git a/engine/src/flutter/src/text_style.h b/engine/src/flutter/src/text_style.h index bda359f028..74c112d60a 100644 --- a/engine/src/flutter/src/text_style.h +++ b/engine/src/flutter/src/text_style.h @@ -46,16 +46,6 @@ class TextStyle { double word_spacing = 0.0; double height = 1.0; - // When disabled, the x coordinates of glyphs will be rounded, eliminating - // potential mismatch between one long run and mutiple shorter runs of the - // same text. - // - // When set to false, there may be jitter when switching between same text - // content with different runs composing it, however, it also produces more - // accurate layouts. Setting to true removs this, but sacrifices layout - // accuracy. - bool round_char_advances = false; - bool equals(const TextStyle& other) const; }; From 1c108c04dddfe68539366b76fc3c7aca2f187f7b Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 9 Aug 2017 11:02:03 -0700 Subject: [PATCH 362/364] Use SkPath for wavy decorations for x5 improvements in performance. Change-Id: I371f525bb91c2d415d6af4f8ff047f43678e5ac3 --- engine/src/flutter/src/paragraph.cc | 293 ++++++++++++++-------------- engine/src/flutter/src/paragraph.h | 9 - 2 files changed, 144 insertions(+), 158 deletions(-) diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 9a0692ea0c..34bb122b77 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -630,162 +630,157 @@ void Paragraph::PaintDecorations(SkCanvas* canvas, double y, size_t record_index) { PaintRecord& record = records_[record_index]; - if (record.style().decoration != TextDecoration::kNone) { - const SkPaint::FontMetrics& metrics = record.metrics(); - SkPaint paint; - paint.setStyle(SkPaint::kStroke_Style); - if (record.style().decoration_color == SK_ColorTRANSPARENT) { - paint.setColor(record.style().color); - } else { - paint.setColor(record.style().decoration_color); + if (record.style().decoration == TextDecoration::kNone) + return; + + const SkPaint::FontMetrics& metrics = record.metrics(); + SkPaint paint; + paint.setStyle(SkPaint::kStroke_Style); + if (record.style().decoration_color == SK_ColorTRANSPARENT) { + paint.setColor(record.style().color); + } else { + paint.setColor(record.style().decoration_color); + } + paint.setAntiAlias(true); + + // This is set to 2 for the double line style + int decoration_count = 1; + + // Filled when drawing wavy decorations. + SkPath path; + + double width = 0; + if (paragraph_style_.text_align == TextAlign::justify && + record.line() != lines_ - 1) { + width = width_; + } else { + width = record.GetRunWidth(); + } + + paint.setStrokeWidth( + (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: + kUnderlineThicknessIsValid_Flag)) + ? metrics.fUnderlineThickness * + record.style().decoration_thickness_multiplier + // Backup value if the fUnderlineThickness metric is not available: + // Divide by 14pt as it is the default size. + : record.style().font_size / 14.0f * + record.style().decoration_thickness_multiplier); + + // Setup the decorations. + switch (record.style().decoration_style) { + case TextDecorationStyle::kSolid: { + break; } - paint.setAntiAlias(true); - - // This is set to 2 for the double line style - int decoration_count = 1; - - // Filled when drawing wavy decorations. - std::vector wave_coords; - - double width = 0; - if (paragraph_style_.text_align == TextAlign::justify && - record.line() != lines_ - 1) { - width = width_; - } else { - width = record.GetRunWidth(); + case TextDecorationStyle::kDouble: { + decoration_count = 2; + break; } - - paint.setStrokeWidth( - (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: - kUnderlineThicknessIsValid_Flag)) - ? metrics.fUnderlineThickness - // Backup value if the fUnderlineThickness metric is not available: - // Divide by 14pt as it is the default size. - : record.style().font_size / 14.0f * - record.style().decoration_thickness_multiplier); - - // Setup the decorations. - switch (record.style().decoration_style) { - case TextDecorationStyle::kSolid: { - break; - } - case TextDecorationStyle::kDouble: { - decoration_count = 2; - break; - } - // Note: the intervals are scaled by the thickness of the line, so it is - // possible to change spacing by changing the decoration_thickness - // property of TextStyle. - case TextDecorationStyle::kDotted: { - // Divide by 14pt as it is the default size. - const float scale = record.style().font_size / 14.0f; - const SkScalar intervals[] = {1.0f * scale, 1.5f * scale, 1.0f * scale, - 1.5f * scale}; - size_t count = sizeof(intervals) / sizeof(intervals[0]); - paint.setPathEffect(SkPathEffect::MakeCompose( - SkDashPathEffect::Make(intervals, count, 0.0f), - SkDiscretePathEffect::Make(0, 0))); - break; - } - // Note: the intervals are scaled by the thickness of the line, so it is - // possible to change spacing by changing the decoration_thickness - // property of TextStyle. - case TextDecorationStyle::kDashed: { - // Divide by 14pt as it is the default size. - const float scale = record.style().font_size / 14.0f; - const SkScalar intervals[] = {4.0f * scale, 2.0f * scale, 4.0f * scale, - 2.0f * scale}; - size_t count = sizeof(intervals) / sizeof(intervals[0]); - paint.setPathEffect(SkPathEffect::MakeCompose( - SkDashPathEffect::Make(intervals, count, 0.0f), - SkDiscretePathEffect::Make(0, 0))); - break; - } - case TextDecorationStyle::kWavy: { - int wave_count = 0; - double x_start = 0; - double y_top = -metrics.fUnderlineThickness; - double y_bottom = metrics.fUnderlineThickness; - while (x_start + metrics.fUnderlineThickness * 2 < width) { - wave_coords.push_back( - WaveCoordinates(x_start, wave_count % 2 == 0 ? y_bottom : y_top, - x_start + metrics.fUnderlineThickness * 2, - wave_count % 2 == 0 ? y_top : y_bottom)); - x_start += metrics.fUnderlineThickness * 2; - ++wave_count; - } - break; - } + // Note: the intervals are scaled by the thickness of the line, so it is + // possible to change spacing by changing the decoration_thickness + // property of TextStyle. + case TextDecorationStyle::kDotted: { + // Divide by 14pt as it is the default size. + const float scale = record.style().font_size / 14.0f; + const SkScalar intervals[] = {1.0f * scale, 1.5f * scale, 1.0f * scale, + 1.5f * scale}; + size_t count = sizeof(intervals) / sizeof(intervals[0]); + paint.setPathEffect(SkPathEffect::MakeCompose( + SkDashPathEffect::Make(intervals, count, 0.0f), + SkDiscretePathEffect::Make(0, 0))); + break; } - - // Draw the decorations. - // Use a for loop for "kDouble" decoration style - for (int i = 0; i < decoration_count; i++) { - double y_offset = - i * metrics.fUnderlineThickness * kDoubleDecorationSpacing; - double y_offset_original = y_offset; - // Underline - if (record.style().decoration & 0x1) { - y_offset += - (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: - kUnderlinePositionIsValid_Flag)) - ? metrics.fUnderlinePosition - : metrics.fUnderlineThickness; - if (record.style().decoration_style != TextDecorationStyle::kWavy) - canvas->drawLine(x, y + y_offset, x + width, y + y_offset, paint); - else - PaintWavyDecoration(canvas, wave_coords, paint, x, y, y_offset, - width); - y_offset = y_offset_original; - } - // Overline - if (record.style().decoration & 0x2) { - y_offset -= metrics.fAscent; - if (record.style().decoration_style != TextDecorationStyle::kWavy) - canvas->drawLine(x, y - y_offset, x + width, y - y_offset, paint); - else - PaintWavyDecoration(canvas, wave_coords, paint, x, y, -y_offset, - width); - y_offset = y_offset_original; - } - // Strikethrough - if (record.style().decoration & 0x4) { - if (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: - kStrikeoutThicknessIsValid_Flag)) - paint.setStrokeWidth(metrics.fStrikeoutThickness * - record.style().decoration_thickness_multiplier); - // Make sure the double line is "centered" vertically. - y_offset += (decoration_count - 1.0) * metrics.fUnderlineThickness * - kDoubleDecorationSpacing / -2.0; - y_offset += - (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: - kStrikeoutThicknessIsValid_Flag)) - ? metrics.fStrikeoutPosition - // Backup value if the strikeoutposition metric is not - // available: - : metrics.fXHeight / -2.0; - if (record.style().decoration_style != TextDecorationStyle::kWavy) - canvas->drawLine(x, y + y_offset, x + width, y + y_offset, paint); - else - PaintWavyDecoration(canvas, wave_coords, paint, x, y, y_offset, - width); - y_offset = y_offset_original; + // Note: the intervals are scaled by the thickness of the line, so it is + // possible to change spacing by changing the decoration_thickness + // property of TextStyle. + case TextDecorationStyle::kDashed: { + // Divide by 14pt as it is the default size. + const float scale = record.style().font_size / 14.0f; + const SkScalar intervals[] = {4.0f * scale, 2.0f * scale, 4.0f * scale, + 2.0f * scale}; + size_t count = sizeof(intervals) / sizeof(intervals[0]); + paint.setPathEffect(SkPathEffect::MakeCompose( + SkDashPathEffect::Make(intervals, count, 0.0f), + SkDiscretePathEffect::Make(0, 0))); + break; + } + case TextDecorationStyle::kWavy: { + int wave_count = 0; + double x_start = 0; + double wavelength = metrics.fUnderlineThickness * + record.style().decoration_thickness_multiplier; + path.moveTo(x, y); + while (x_start + wavelength * 2 < width) { + path.rQuadTo(wavelength, wave_count % 2 != 0 ? wavelength : -wavelength, + wavelength * 2, 0); + x_start += wavelength * 2; + ++wave_count; } + break; } } -} -void Paragraph::PaintWavyDecoration(SkCanvas* canvas, - std::vector wave_coords, - SkPaint paint, - double x, - double y, - double y_offset, - double width) { - for (size_t i = 0; i < wave_coords.size(); ++i) { - WaveCoordinates coords = wave_coords[i]; - canvas->drawLine(x + coords.x_start, y + y_offset + coords.y_start, - x + coords.x_end, y + y_offset + coords.y_end, paint); + // Draw the decorations. + // Use a for loop for "kDouble" decoration style + for (int i = 0; i < decoration_count; i++) { + double y_offset = + i * metrics.fUnderlineThickness * kDoubleDecorationSpacing; + double y_offset_original = y_offset; + // Underline + if (record.style().decoration & 0x1) { + y_offset += + (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: + kUnderlinePositionIsValid_Flag)) + ? metrics.fUnderlinePosition + : metrics.fUnderlineThickness; + if (record.style().decoration_style != TextDecorationStyle::kWavy) { + canvas->drawLine(x, y + y_offset, x + width, y + y_offset, paint); + } else { + SkPath offsetPath = path; + offsetPath.offset(0, y_offset); + canvas->drawPath(offsetPath, paint); + } + y_offset = y_offset_original; + } + // Overline + if (record.style().decoration & 0x2) { + // We subtract fAscent here because for double overlines, we want the + // second line to be above, not below the first. + y_offset -= metrics.fAscent; + if (record.style().decoration_style != TextDecorationStyle::kWavy) { + canvas->drawLine(x, y - y_offset, x + width, y - y_offset, paint); + } else { + SkPath offsetPath = path; + offsetPath.offset(0, -y_offset); + canvas->drawPath(offsetPath, paint); + } + y_offset = y_offset_original; + } + // Strikethrough + if (record.style().decoration & 0x4) { + if (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: + kStrikeoutThicknessIsValid_Flag)) + paint.setStrokeWidth(metrics.fStrikeoutThickness * + record.style().decoration_thickness_multiplier); + // Make sure the double line is "centered" vertically. + y_offset += (decoration_count - 1.0) * metrics.fUnderlineThickness * + kDoubleDecorationSpacing / -2.0; + y_offset += + (SkToBool(metrics.fFlags & SkPaint::FontMetrics::FontMetricsFlags:: + kStrikeoutThicknessIsValid_Flag)) + ? metrics.fStrikeoutPosition + // Backup value if the strikeoutposition metric is not + // available: + : metrics.fXHeight / -2.0; + if (record.style().decoration_style != TextDecorationStyle::kWavy) { + canvas->drawLine(x, y + y_offset, x + width, y + y_offset, paint); + } else { + SkPath offsetPath = path; + offsetPath.offset(0, y_offset); + canvas->drawPath(offsetPath, paint); + } + y_offset = y_offset_original; + } } } diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index 614e50197b..e62c4a1d29 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -242,15 +242,6 @@ class Paragraph { double y, size_t record_index); - // Calculates wavy decorations and Draws them onto the canvas. - void PaintWavyDecoration(SkCanvas* canvas, - std::vector wave_coords, - SkPaint paint, - double x, - double y, - double y_offset, - double width); - void CalculateIntrinsicWidths(); FTL_DISALLOW_COPY_AND_ASSIGN(Paragraph); From c67bfe8a84ae6f41d3d06ec8939561eb94740a8a Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 9 Aug 2017 14:55:01 -0700 Subject: [PATCH 363/364] Respect paragraphstyle defaults, slight font name discovery improvements, better italic tests. Change-Id: I4f032b315a68e2279087f701ab7bd920846cd723 --- engine/src/flutter/src/font_collection.cc | 18 ++-- engine/src/flutter/src/font_collection.h | 6 +- engine/src/flutter/src/paragraph.cc | 15 +-- engine/src/flutter/src/paragraph_builder.cc | 16 +++- engine/src/flutter/src/paragraph_style.h | 3 +- .../flutter/tests/txt/paragraph_unittests.cc | 96 +++++++++---------- 6 files changed, 82 insertions(+), 72 deletions(-) diff --git a/engine/src/flutter/src/font_collection.cc b/engine/src/flutter/src/font_collection.cc index fceb5fb527..33e45537a7 100644 --- a/engine/src/flutter/src/font_collection.cc +++ b/engine/src/flutter/src/font_collection.cc @@ -103,23 +103,27 @@ void FontCollection::AddFontMgr(std::string dir, bool rediscover_family_names) { #endif if (rediscover_family_names) - DiscoverFamilyNames(); + DiscoverFamilyNames(skia_font_managers_.back()); } void FontCollection::AddFontMgr(sk_sp font_mgr, bool rediscover_family_names) { skia_font_managers_.push_back(font_mgr); if (rediscover_family_names) - DiscoverFamilyNames(); + DiscoverFamilyNames(font_mgr); } void FontCollection::DiscoverFamilyNames() { - SkString str; for (sk_sp mgr : skia_font_managers_) { - for (int i = 0; i < mgr->countFamilies(); i++) { - mgr->getFamilyName(i, &str); - family_names_.insert(std::string{str.writable_str()}); - } + DiscoverFamilyNames(mgr); + } +} + +void FontCollection::DiscoverFamilyNames(sk_sp mgr) { + SkString str; + for (int i = 0; i < mgr->countFamilies(); i++) { + mgr->getFamilyName(i, &str); + family_names_.insert(std::string{str.writable_str()}); } } diff --git a/engine/src/flutter/src/font_collection.h b/engine/src/flutter/src/font_collection.h index 63c9ca1a38..6a8637da1f 100644 --- a/engine/src/flutter/src/font_collection.h +++ b/engine/src/flutter/src/font_collection.h @@ -129,9 +129,13 @@ class FontCollection { // when not found and reverting to the default name when no fallback is found. const std::string ProcessFamilyName(const std::string& family); - // Polls the SkFontMgrs to obtain a set of all available font family names. + // Polls all of the SkFontMgrs to obtain a set of all available font family + // names. void DiscoverFamilyNames(); + // Add the family names of mgr to set of available font family names. + void DiscoverFamilyNames(sk_sp mgr); + void TrimCache(); static const std::string GetDefaultFamilyName() { diff --git a/engine/src/flutter/src/paragraph.cc b/engine/src/flutter/src/paragraph.cc index 34bb122b77..d7031df9fc 100644 --- a/engine/src/flutter/src/paragraph.cc +++ b/engine/src/flutter/src/paragraph.cc @@ -478,6 +478,8 @@ void Paragraph::Layout(double width, bool force) { postprocess_line(); if (line_width != 0) line_widths_.push_back(line_width); + + // Finalize measurements line_heights_.push_back((line_heights_.empty() ? 0 : line_heights_.back()) + roundf(max_line_spacing + max_descent)); glyph_single_line_position_x.push_back(glyph_single_line_position_x.back() + @@ -489,11 +491,6 @@ void Paragraph::Layout(double width, bool force) { if (paragraph_style_.text_align == TextAlign::justify && buffer_sizes.size() > 0) { JustifyLine(buffers, buffer_sizes, word_count, justify_spacing, -1); - // Remove decoration extra width if the last line. - size_t i = records_.size() - 1; - while (records_[i].line() == lines_ - 1) { - --i; - } } line_widths_ = std::vector(breaker_.getWidths(), breaker_.getWidths() + lines_); @@ -543,24 +540,22 @@ const ParagraphStyle& Paragraph::GetParagraphStyle() const { } double Paragraph::GetAlphabeticBaseline() const { + // Currently -fAscent return alphabetic_baseline_; } double Paragraph::GetIdeographicBaseline() const { - // TODO(garyq): Currently fCapHeight + fUnderlinePosition. Verify this. + // TODO(garyq): Currently -fAscent + fUnderlinePosition. Verify this. return ideographic_baseline_; } void Paragraph::CalculateIntrinsicWidths() { - // TODO(garyq): Investigate correctness of the following implementation of max - // intrinsic width. This is currently the sum of all the widths of each line - // after layout. max_intrinsic_width_ = 0; for (size_t i = 0; i < line_widths_.size(); ++i) { max_intrinsic_width_ += line_widths_[i]; } - // TODO(garyq): Investigate correctness of the following implementation of max + // TODO(garyq): Investigate correctness of the following implementation of min // intrinsic width. This is currently the longest line in the text after // layout. min_intrinsic_width_ = 0; diff --git a/engine/src/flutter/src/paragraph_builder.cc b/engine/src/flutter/src/paragraph_builder.cc index 0cb1170965..a883e142a6 100644 --- a/engine/src/flutter/src/paragraph_builder.cc +++ b/engine/src/flutter/src/paragraph_builder.cc @@ -25,15 +25,25 @@ namespace txt { ParagraphBuilder::ParagraphBuilder(ParagraphStyle style, FontCollection* font_collection) - : paragraph_style_(style), font_collection_(font_collection) {} + : font_collection_(font_collection) { + SetParagraphStyle(style); +} -ParagraphBuilder::ParagraphBuilder(ParagraphStyle style) - : paragraph_style_(style) {} +ParagraphBuilder::ParagraphBuilder(ParagraphStyle style) { + SetParagraphStyle(style); +} ParagraphBuilder::ParagraphBuilder() {} void ParagraphBuilder::SetParagraphStyle(const ParagraphStyle& style) { paragraph_style_ = style; + // Keep a default style to fall back to. + TextStyle text_style; + text_style.font_weight = paragraph_style_.font_weight; + text_style.font_style = paragraph_style_.font_style; + text_style.font_family = paragraph_style_.font_family; + text_style.font_size = paragraph_style_.font_size; + PushStyle(text_style); } void ParagraphBuilder::SetFontCollection(FontCollection* font_collection) { diff --git a/engine/src/flutter/src/paragraph_style.h b/engine/src/flutter/src/paragraph_style.h index 38f1a2278a..9c299c594b 100644 --- a/engine/src/flutter/src/paragraph_style.h +++ b/engine/src/flutter/src/paragraph_style.h @@ -29,11 +29,12 @@ namespace txt { class ParagraphStyle { public: - TextAlign text_align = TextAlign::left; FontWeight font_weight = FontWeight::w400; FontStyle font_style = FontStyle::normal; std::string font_family = ""; double font_size = 14; + + TextAlign text_align = TextAlign::left; size_t max_lines = UINT_MAX; double line_height = 1.0; std::string ellipsis = "..."; diff --git a/engine/src/flutter/tests/txt/paragraph_unittests.cc b/engine/src/flutter/tests/txt/paragraph_unittests.cc index 0da17ca361..6120f5c1f3 100644 --- a/engine/src/flutter/tests/txt/paragraph_unittests.cc +++ b/engine/src/flutter/tests/txt/paragraph_unittests.cc @@ -54,8 +54,8 @@ TEST_F(RenderTest, SimpleParagraph) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_TRUE(Snapshot()); } @@ -88,8 +88,8 @@ TEST_F(RenderTest, SimpleRedParagraph) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_TRUE(Snapshot()); } @@ -176,11 +176,11 @@ TEST_F(RenderTest, RainbowParagraph) { } ASSERT_TRUE(Snapshot()); ASSERT_EQ(paragraph->runs_.runs_.size(), 4ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 4ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style1)); - ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style2)); - ASSERT_TRUE(paragraph->runs_.styles_[2].equals(text_style3)); - ASSERT_TRUE(paragraph->runs_.styles_[3].equals(text_style4)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 5ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style1)); + ASSERT_TRUE(paragraph->runs_.styles_[2].equals(text_style2)); + ASSERT_TRUE(paragraph->runs_.styles_[3].equals(text_style3)); + ASSERT_TRUE(paragraph->runs_.styles_[4].equals(text_style4)); ASSERT_EQ(paragraph->records_[0].style().color, text_style1.color); ASSERT_EQ(paragraph->records_[1].style().color, text_style2.color); ASSERT_EQ(paragraph->records_[2].style().color, text_style3.color); @@ -214,8 +214,8 @@ TEST_F(RenderTest, DefaultStyleParagraph) { for (size_t i = 0; i < u16_text.length(); i++) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } - ASSERT_EQ(paragraph->runs_.runs_.size(), 0ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 0ull); + ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); ASSERT_TRUE(Snapshot()); } @@ -251,8 +251,8 @@ TEST_F(RenderTest, BoldParagraph) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_TRUE(Snapshot()); } @@ -312,8 +312,8 @@ TEST_F(RenderTest, LeftAlignParagraph) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); double expected_y = 24; @@ -408,8 +408,8 @@ TEST_F(RenderTest, RightAlignParagraph) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); double expected_y = 24; @@ -512,8 +512,8 @@ TEST_F(RenderTest, CenterAlignParagraph) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); double expected_y = 24; @@ -618,8 +618,8 @@ TEST_F(RenderTest, JustifyAlignParagraph) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_.size(), paragraph_style.max_lines); double expected_y = 24; @@ -731,38 +731,34 @@ TEST_F(RenderTest, DecorationsParagraph) { } TEST_F(RenderTest, ItalicsParagraph) { - const char* text = "I am Italicized! "; - auto icu_text = icu::UnicodeString::fromUTF8(text); - std::u16string u16_text(icu_text.getBuffer(), - icu_text.getBuffer() + icu_text.length()); - txt::ParagraphStyle paragraph_style; auto font_collection = FontCollection::GetFontCollection(txt::GetFontDir()); txt::ParagraphBuilder builder(paragraph_style, &font_collection); txt::TextStyle text_style; text_style.color = SK_ColorRED; - text_style.font_style = txt::FontStyle::italic; - text_style.font_size = 35; + text_style.font_size = 10; builder.PushStyle(text_style); + builder.AddText("No italic "); - builder.AddText(u16_text); + text_style.font_style = txt::FontStyle::italic; + builder.PushStyle(text_style); + builder.AddText("Yes Italic "); builder.Pop(); + builder.AddText("No Italic again."); auto paragraph = builder.Build(); paragraph->Layout(GetTestCanvasWidth()); - paragraph->Paint(GetCanvas(), 10.0, 35.0); + paragraph->Paint(GetCanvas(), 0, 0); - ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); - for (size_t i = 0; i < u16_text.length(); i++) { - ASSERT_EQ(paragraph->text_[i], u16_text[i]); - } - ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); - ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); + ASSERT_EQ(paragraph->runs_.runs_.size(), 3ull); + ASSERT_EQ(paragraph->runs_.styles_.size(), 3ull); + ASSERT_EQ(paragraph->records_[1].style().color, text_style.color); + ASSERT_EQ(paragraph->records_[1].style().font_style, txt::FontStyle::italic); + ASSERT_EQ(paragraph->records_[2].style().font_style, txt::FontStyle::normal); + ASSERT_EQ(paragraph->records_[0].style().font_style, txt::FontStyle::normal); ASSERT_TRUE(Snapshot()); } @@ -803,8 +799,8 @@ TEST_F(RenderTest, ChineseParagraph) { paragraph->Paint(GetCanvas(), 0, 0); ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_EQ(paragraph->records_.size(), 7ull); @@ -849,8 +845,8 @@ TEST_F(RenderTest, DISABLED_ArabicParagraph) { ASSERT_EQ(paragraph->text_.size(), std::string{text}.length()); ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_EQ(paragraph->records_.size(), 2ull); ASSERT_EQ(paragraph->paragraph_style_.rtl, true); @@ -1289,8 +1285,8 @@ TEST_F(RenderTest, LongWordParagraph) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_EQ(paragraph->GetLineCount(), 4); ASSERT_TRUE(Snapshot()); @@ -1477,8 +1473,8 @@ TEST_F(RenderTest, HyphenBreakParagraph) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_EQ(paragraph->GetLineCount(), 5); ASSERT_TRUE(Snapshot()); @@ -1522,8 +1518,8 @@ TEST_F(RenderTest, RepeatLayoutParagraph) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_EQ(paragraph->GetLineCount(), 12); @@ -1538,8 +1534,8 @@ TEST_F(RenderTest, RepeatLayoutParagraph) { ASSERT_EQ(paragraph->text_[i], u16_text[i]); } ASSERT_EQ(paragraph->runs_.runs_.size(), 1ull); - ASSERT_EQ(paragraph->runs_.styles_.size(), 1ull); - ASSERT_TRUE(paragraph->runs_.styles_[0].equals(text_style)); + ASSERT_EQ(paragraph->runs_.styles_.size(), 2ull); + ASSERT_TRUE(paragraph->runs_.styles_[1].equals(text_style)); ASSERT_EQ(paragraph->records_[0].style().color, text_style.color); ASSERT_EQ(paragraph->GetLineCount(), 6); ASSERT_TRUE(Snapshot()); From 19426206958a432405c0d4b77102a67dde4d2fa1 Mon Sep 17 00:00:00 2001 From: Gary Qian Date: Wed, 9 Aug 2017 17:56:33 -0700 Subject: [PATCH 364/364] Add ParagraphBuilder::PeekStyle() to allow Flutter style inheritance. Change-Id: Ia198778d9a7cfd7053390e6195bf8e03245add77 --- engine/src/flutter/src/paragraph.h | 2 +- engine/src/flutter/src/paragraph_builder.cc | 4 ++++ engine/src/flutter/src/paragraph_builder.h | 3 +++ engine/src/flutter/src/styled_runs.cc | 4 ++++ engine/src/flutter/src/styled_runs.h | 3 +++ 5 files changed, 15 insertions(+), 1 deletion(-) diff --git a/engine/src/flutter/src/paragraph.h b/engine/src/flutter/src/paragraph.h index e62c4a1d29..8b4936bac7 100644 --- a/engine/src/flutter/src/paragraph.h +++ b/engine/src/flutter/src/paragraph.h @@ -52,7 +52,7 @@ class Paragraph { ~Paragraph(); - // NOTE: Minikin Layout doLayout() and LineBreaker addStyleRun() has an + // Minikin Layout doLayout() and LineBreaker addStyleRun() has an // O(N^2) (according to benchmarks) time complexity where N is the total // number of characters. However, this is not significant for reasonably sized // paragraphs. It is currently recommended to break up very long paragraphs diff --git a/engine/src/flutter/src/paragraph_builder.cc b/engine/src/flutter/src/paragraph_builder.cc index a883e142a6..964a202211 100644 --- a/engine/src/flutter/src/paragraph_builder.cc +++ b/engine/src/flutter/src/paragraph_builder.cc @@ -72,6 +72,10 @@ void ParagraphBuilder::Pop() { runs_.StartRun(style_index, text_index); } +const TextStyle& ParagraphBuilder::PeekStyle() const { + return runs_.PeekStyle(); +} + void ParagraphBuilder::AddText(const std::u16string& text) { text_.insert(text_.end(), text.begin(), text.end()); } diff --git a/engine/src/flutter/src/paragraph_builder.h b/engine/src/flutter/src/paragraph_builder.h index df756672a7..8290850683 100644 --- a/engine/src/flutter/src/paragraph_builder.h +++ b/engine/src/flutter/src/paragraph_builder.h @@ -56,6 +56,9 @@ class ParagraphBuilder { // builder.AddText(" Back to normal again."); void Pop(); + // Returns the last TextStyle on the stack. + const TextStyle& PeekStyle() const; + // Adds text to the builder. Forms the proper runs to use the upper-most style // on the style_stack_; void AddText(const std::u16string& text); diff --git a/engine/src/flutter/src/styled_runs.cc b/engine/src/flutter/src/styled_runs.cc index 7e64460c18..67e7ec1eb2 100644 --- a/engine/src/flutter/src/styled_runs.cc +++ b/engine/src/flutter/src/styled_runs.cc @@ -46,6 +46,10 @@ size_t StyledRuns::AddStyle(const TextStyle& style) { return style_index; } +const TextStyle& StyledRuns::PeekStyle() const { + return styles_.back(); +} + void StyledRuns::StartRun(size_t style_index, size_t start) { runs_.push_back(IndexedRun{style_index, start, start}); } diff --git a/engine/src/flutter/src/styled_runs.h b/engine/src/flutter/src/styled_runs.h index ff3d58aaba..94931989fd 100644 --- a/engine/src/flutter/src/styled_runs.h +++ b/engine/src/flutter/src/styled_runs.h @@ -49,6 +49,9 @@ class StyledRuns { size_t AddStyle(const TextStyle& style); + // Returns the last TextStyle on the stack. + const TextStyle& PeekStyle() const; + void StartRun(size_t style_index, size_t start); void EndRunIfNeeded(size_t end);

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%0AyI_?;`PoF{*?etGdS;l3 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