| /* |
| * Copyright (C) 2020 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef MINIKIN_BOUNDS_CACHE_H |
| #define MINIKIN_BOUNDS_CACHE_H |
| |
| #include "minikin/LayoutCache.h" |
| |
| #include <mutex> |
| |
| #include <utils/LruCache.h> |
| |
| #include "minikin/BoundsCache.h" |
| #include "minikin/FontCollection.h" |
| #include "minikin/Hasher.h" |
| #include "minikin/MinikinPaint.h" |
| |
| namespace minikin { |
| |
| // Cache entry |
| struct BoundsValue { |
| MinikinRect rect; |
| float advance; |
| }; |
| |
| // Used for callback for LayoutCache. |
| struct ValueExtractor { |
| void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& paint); |
| std::unique_ptr<BoundsValue> value; |
| }; |
| |
| class BoundsCache : private android::OnEntryRemoved<LayoutCacheKey, BoundsValue*> { |
| public: |
| void clear() { |
| std::lock_guard<std::mutex> lock(mMutex); |
| mCache.clear(); |
| } |
| |
| // Do not use BoundsCache inside the callback function, otherwise dead-lock may happen. |
| template <typename F> |
| void getOrCreate(const U16StringPiece& text, const Range& range, const MinikinPaint& paint, |
| bool dir, StartHyphenEdit startHyphen, EndHyphenEdit endHyphen, F& f) { |
| LayoutCacheKey key(text, range, paint, dir, startHyphen, endHyphen); |
| if (paint.skipCache() || range.getLength() >= LENGTH_LIMIT_CACHE) { |
| LayoutPiece piece = LayoutPiece(text, range, dir, paint, startHyphen, endHyphen); |
| f(getBounds(piece, paint), piece.advance()); |
| return; |
| } |
| { |
| std::lock_guard<std::mutex> lock(mMutex); |
| BoundsValue* value = mCache.get(key); |
| if (value != nullptr) { |
| f(value->rect, value->advance); |
| return; |
| } |
| } |
| // Doing text layout takes long time, so releases the mutex during doing layout. |
| // Don't care even if we do the same layout in other thread. |
| key.copyText(); |
| ValueExtractor ve; |
| LayoutCache::getInstance().getOrCreate(text, range, paint, dir, startHyphen, endHyphen, ve); |
| f(ve.value->rect, ve.value->advance); |
| { |
| std::lock_guard<std::mutex> lock(mMutex); |
| mCache.put(key, ve.value.release()); |
| } |
| } |
| |
| static BoundsCache& getInstance() { |
| static BoundsCache cache(kMaxEntries); |
| return cache; |
| } |
| |
| // Compute new bounding box for the layout piece. |
| static MinikinRect getBounds(const LayoutPiece& layoutPiece, const MinikinPaint& paint); |
| |
| protected: |
| BoundsCache(uint32_t maxEntries) : mCache(maxEntries) { |
| mCache.setOnEntryRemovedListener(this); |
| } |
| |
| private: |
| // callback for OnEntryRemoved |
| void operator()(LayoutCacheKey& key, BoundsValue*& value) { |
| key.freeText(); |
| delete value; |
| } |
| |
| std::mutex mMutex; |
| android::LruCache<LayoutCacheKey, BoundsValue*> mCache GUARDED_BY(mMutex) GUARDED_BY(mMutex); |
| // LRU cache capacity. Should be fine to be less than LayoutCache#kMaxEntries since bbox |
| // calculation happens less than layout calculation. |
| static const size_t kMaxEntries = 500; |
| }; |
| |
| } // namespace minikin |
| #endif // MINIKIN_BOUNDS_CACHE_H |