1 /*
2  * Copyright (C) 2012 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <SkGlyph.h>
18 
19 #include "CacheTexture.h"
20 #include "FontUtil.h"
21 #include "../Caches.h"
22 #include "../Debug.h"
23 #include "../Extensions.h"
24 #include "../PixelBuffer.h"
25 
26 namespace android {
27 namespace uirenderer {
28 
29 ///////////////////////////////////////////////////////////////////////////////
30 // CacheBlock
31 ///////////////////////////////////////////////////////////////////////////////
32 
33 /**
34  * Insert new block into existing linked list of blocks. Blocks are sorted in increasing-width
35  * order, except for the final block (the remainder space at the right, since we fill from the
36  * left).
37  */
insertBlock(CacheBlock * head,CacheBlock * newBlock)38 CacheBlock* CacheBlock::insertBlock(CacheBlock* head, CacheBlock* newBlock) {
39 #if DEBUG_FONT_RENDERER
40     ALOGD("insertBlock: this, x, y, w, h = %p, %d, %d, %d, %d",
41             newBlock, newBlock->mX, newBlock->mY,
42             newBlock->mWidth, newBlock->mHeight);
43 #endif
44 
45     CacheBlock* currBlock = head;
46     CacheBlock* prevBlock = nullptr;
47 
48     while (currBlock && currBlock->mY != TEXTURE_BORDER_SIZE) {
49         if (newBlock->mWidth < currBlock->mWidth) {
50             newBlock->mNext = currBlock;
51             newBlock->mPrev = prevBlock;
52             currBlock->mPrev = newBlock;
53 
54             if (prevBlock) {
55                 prevBlock->mNext = newBlock;
56                 return head;
57             } else {
58                 return newBlock;
59             }
60         }
61 
62         prevBlock = currBlock;
63         currBlock = currBlock->mNext;
64     }
65 
66     // new block larger than all others - insert at end (but before the remainder space, if there)
67     newBlock->mNext = currBlock;
68     newBlock->mPrev = prevBlock;
69 
70     if (currBlock) {
71         currBlock->mPrev = newBlock;
72     }
73 
74     if (prevBlock) {
75         prevBlock->mNext = newBlock;
76         return head;
77     } else {
78         return newBlock;
79     }
80 }
81 
removeBlock(CacheBlock * head,CacheBlock * blockToRemove)82 CacheBlock* CacheBlock::removeBlock(CacheBlock* head, CacheBlock* blockToRemove) {
83 #if DEBUG_FONT_RENDERER
84     ALOGD("removeBlock: this, x, y, w, h = %p, %d, %d, %d, %d",
85             blockToRemove, blockToRemove->mX, blockToRemove->mY,
86             blockToRemove->mWidth, blockToRemove->mHeight);
87 #endif
88 
89     CacheBlock* newHead = head;
90     CacheBlock* nextBlock = blockToRemove->mNext;
91     CacheBlock* prevBlock = blockToRemove->mPrev;
92 
93     if (prevBlock) {
94         prevBlock->mNext = nextBlock;
95     } else {
96         newHead = nextBlock;
97     }
98 
99     if (nextBlock) {
100         nextBlock->mPrev = prevBlock;
101     }
102 
103     delete blockToRemove;
104 
105     return newHead;
106 }
107 
108 ///////////////////////////////////////////////////////////////////////////////
109 // CacheTexture
110 ///////////////////////////////////////////////////////////////////////////////
111 
CacheTexture(uint16_t width,uint16_t height,GLenum format,uint32_t maxQuadCount)112 CacheTexture::CacheTexture(uint16_t width, uint16_t height, GLenum format, uint32_t maxQuadCount)
113         : mTexture(Caches::getInstance())
114         , mFormat(format)
115         , mMaxQuadCount(maxQuadCount)
116         , mCaches(Caches::getInstance()) {
117     mTexture.width = width;
118     mTexture.height = height;
119     mTexture.blend = true;
120 
121     mCacheBlocks = new CacheBlock(TEXTURE_BORDER_SIZE, TEXTURE_BORDER_SIZE,
122             getWidth() - TEXTURE_BORDER_SIZE, getHeight() - TEXTURE_BORDER_SIZE);
123 
124     // OpenGL ES 3.0+ lets us specify the row length for unpack operations such
125     // as glTexSubImage2D(). This allows us to upload a sub-rectangle of a texture.
126     // With OpenGL ES 2.0 we have to upload entire stripes instead.
127     mHasUnpackRowLength = mCaches.extensions().hasUnpackRowLength();
128 }
129 
~CacheTexture()130 CacheTexture::~CacheTexture() {
131     releaseMesh();
132     releasePixelBuffer();
133     reset();
134 }
135 
reset()136 void CacheTexture::reset() {
137     // Delete existing cache blocks
138     while (mCacheBlocks != nullptr) {
139         CacheBlock* tmpBlock = mCacheBlocks;
140         mCacheBlocks = mCacheBlocks->mNext;
141         delete tmpBlock;
142     }
143     mNumGlyphs = 0;
144     mCurrentQuad = 0;
145 }
146 
init()147 void CacheTexture::init() {
148     // reset, then create a new remainder space to start again
149     reset();
150     mCacheBlocks = new CacheBlock(TEXTURE_BORDER_SIZE, TEXTURE_BORDER_SIZE,
151             getWidth() - TEXTURE_BORDER_SIZE, getHeight() - TEXTURE_BORDER_SIZE);
152 }
153 
releaseMesh()154 void CacheTexture::releaseMesh() {
155     delete[] mMesh;
156 }
157 
releasePixelBuffer()158 void CacheTexture::releasePixelBuffer() {
159     if (mPixelBuffer) {
160         delete mPixelBuffer;
161         mPixelBuffer = nullptr;
162     }
163     if (mTexture.id) {
164         mCaches.textureState().deleteTexture(mTexture.id);
165         mTexture.id = 0;
166     }
167     mDirty = false;
168     mCurrentQuad = 0;
169 }
170 
setLinearFiltering(bool linearFiltering)171 void CacheTexture::setLinearFiltering(bool linearFiltering) {
172     mTexture.setFilter(linearFiltering ? GL_LINEAR : GL_NEAREST);
173 }
174 
allocateMesh()175 void CacheTexture::allocateMesh() {
176     if (!mMesh) {
177         mMesh = new TextureVertex[mMaxQuadCount * 4];
178     }
179 }
180 
allocatePixelBuffer()181 void CacheTexture::allocatePixelBuffer() {
182     if (!mPixelBuffer) {
183         mPixelBuffer = PixelBuffer::create(mFormat, getWidth(), getHeight());
184     }
185 
186     if (!mTexture.id) {
187         glGenTextures(1, &mTexture.id);
188 
189         mCaches.textureState().bindTexture(mTexture.id);
190         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
191         // Initialize texture dimensions
192         glTexImage2D(GL_TEXTURE_2D, 0, mFormat, getWidth(), getHeight(), 0,
193                 mFormat, GL_UNSIGNED_BYTE, nullptr);
194 
195         const GLenum filtering = getLinearFiltering() ? GL_LINEAR : GL_NEAREST;
196         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
197         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
198 
199         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
200         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
201     }
202 }
203 
upload()204 bool CacheTexture::upload() {
205     const Rect& dirtyRect = mDirtyRect;
206 
207     uint32_t x = mHasUnpackRowLength ? dirtyRect.left : 0;
208     uint32_t y = dirtyRect.top;
209     uint32_t width = mHasUnpackRowLength ? dirtyRect.getWidth() : getWidth();
210     uint32_t height = dirtyRect.getHeight();
211 
212     // The unpack row length only needs to be specified when a new
213     // texture is bound
214     if (mHasUnpackRowLength) {
215         glPixelStorei(GL_UNPACK_ROW_LENGTH, getWidth());
216     }
217 
218     mPixelBuffer->upload(x, y, width, height);
219     setDirty(false);
220 
221     return mHasUnpackRowLength;
222 }
223 
setDirty(bool dirty)224 void CacheTexture::setDirty(bool dirty) {
225     mDirty = dirty;
226     if (!dirty) {
227         mDirtyRect.setEmpty();
228     }
229 }
230 
fitBitmap(const SkGlyph & glyph,uint32_t * retOriginX,uint32_t * retOriginY)231 bool CacheTexture::fitBitmap(const SkGlyph& glyph, uint32_t* retOriginX, uint32_t* retOriginY) {
232     switch (glyph.fMaskFormat) {
233         case SkMask::kA8_Format:
234         case SkMask::kBW_Format:
235             if (mFormat != GL_ALPHA) {
236 #if DEBUG_FONT_RENDERER
237                 ALOGD("fitBitmap: texture format %x is inappropriate for monochromatic glyphs",
238                         mFormat);
239 #endif
240                 return false;
241             }
242             break;
243         case SkMask::kARGB32_Format:
244             if (mFormat != GL_RGBA) {
245 #if DEBUG_FONT_RENDERER
246                 ALOGD("fitBitmap: texture format %x is inappropriate for colour glyphs", mFormat);
247 #endif
248                 return false;
249             }
250             break;
251         default:
252 #if DEBUG_FONT_RENDERER
253             ALOGD("fitBitmap: unknown glyph format %x encountered", glyph.fMaskFormat);
254 #endif
255             return false;
256     }
257 
258     if (glyph.fHeight + TEXTURE_BORDER_SIZE * 2 > getHeight()) {
259         return false;
260     }
261 
262     uint16_t glyphW = glyph.fWidth + TEXTURE_BORDER_SIZE;
263     uint16_t glyphH = glyph.fHeight + TEXTURE_BORDER_SIZE;
264 
265     // roundedUpW equals glyphW to the next multiple of CACHE_BLOCK_ROUNDING_SIZE.
266     // This columns for glyphs that are close but not necessarily exactly the same size. It trades
267     // off the loss of a few pixels for some glyphs against the ability to store more glyphs
268     // of varying sizes in one block.
269     uint16_t roundedUpW = (glyphW + CACHE_BLOCK_ROUNDING_SIZE - 1) & -CACHE_BLOCK_ROUNDING_SIZE;
270 
271     CacheBlock* cacheBlock = mCacheBlocks;
272     while (cacheBlock) {
273         // Store glyph in this block iff: it fits the block's remaining space and:
274         // it's the remainder space (mY == 0) or there's only enough height for this one glyph
275         // or it's within ROUNDING_SIZE of the block width
276         if (roundedUpW <= cacheBlock->mWidth && glyphH <= cacheBlock->mHeight &&
277                 (cacheBlock->mY == TEXTURE_BORDER_SIZE ||
278                         (cacheBlock->mWidth - roundedUpW < CACHE_BLOCK_ROUNDING_SIZE))) {
279             if (cacheBlock->mHeight - glyphH < glyphH) {
280                 // Only enough space for this glyph - don't bother rounding up the width
281                 roundedUpW = glyphW;
282             }
283 
284             *retOriginX = cacheBlock->mX;
285             *retOriginY = cacheBlock->mY;
286 
287             // If this is the remainder space, create a new cache block for this column. Otherwise,
288             // adjust the info about this column.
289             if (cacheBlock->mY == TEXTURE_BORDER_SIZE) {
290                 uint16_t oldX = cacheBlock->mX;
291                 // Adjust remainder space dimensions
292                 cacheBlock->mWidth -= roundedUpW;
293                 cacheBlock->mX += roundedUpW;
294 
295                 if (getHeight() - glyphH >= glyphH) {
296                     // There's enough height left over to create a new CacheBlock
297                     CacheBlock* newBlock = new CacheBlock(oldX, glyphH + TEXTURE_BORDER_SIZE,
298                             roundedUpW, getHeight() - glyphH - TEXTURE_BORDER_SIZE);
299 #if DEBUG_FONT_RENDERER
300                     ALOGD("fitBitmap: Created new block: this, x, y, w, h = %p, %d, %d, %d, %d",
301                             newBlock, newBlock->mX, newBlock->mY,
302                             newBlock->mWidth, newBlock->mHeight);
303 #endif
304                     mCacheBlocks = CacheBlock::insertBlock(mCacheBlocks, newBlock);
305                 }
306             } else {
307                 // Insert into current column and adjust column dimensions
308                 cacheBlock->mY += glyphH;
309                 cacheBlock->mHeight -= glyphH;
310 #if DEBUG_FONT_RENDERER
311                 ALOGD("fitBitmap: Added to existing block: this, x, y, w, h = %p, %d, %d, %d, %d",
312                         cacheBlock, cacheBlock->mX, cacheBlock->mY,
313                         cacheBlock->mWidth, cacheBlock->mHeight);
314 #endif
315             }
316 
317             if (cacheBlock->mHeight < std::min(glyphH, glyphW)) {
318                 // If remaining space in this block is too small to be useful, remove it
319                 mCacheBlocks = CacheBlock::removeBlock(mCacheBlocks, cacheBlock);
320             }
321 
322             mDirty = true;
323             const Rect r(*retOriginX - TEXTURE_BORDER_SIZE, *retOriginY - TEXTURE_BORDER_SIZE,
324                     *retOriginX + glyphW, *retOriginY + glyphH);
325             mDirtyRect.unionWith(r);
326             mNumGlyphs++;
327 
328 #if DEBUG_FONT_RENDERER
329             ALOGD("fitBitmap: current block list:");
330             mCacheBlocks->output();
331 #endif
332 
333             return true;
334         }
335         cacheBlock = cacheBlock->mNext;
336     }
337 #if DEBUG_FONT_RENDERER
338     ALOGD("fitBitmap: returning false for glyph of size %d, %d", glyphW, glyphH);
339 #endif
340     return false;
341 }
342 
343 }; // namespace uirenderer
344 }; // namespace android
345