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#ifndef ANDROID_HWUI_CACHE_TEXTURE_H
18#define ANDROID_HWUI_CACHE_TEXTURE_H
19
20#include "PixelBuffer.h"
21#include "Rect.h"
22#include "Texture.h"
23#include "Vertex.h"
24
25#include <GLES3/gl3.h>
26#include <SkGlyph.h>
27#include <utils/Log.h>
28
29namespace android {
30namespace uirenderer {
31
32class Caches;
33
34/**
35 * CacheBlock is a node in a linked list of current free space areas in a CacheTexture.
36 * Using CacheBlocks enables us to pack the cache from top to bottom as well as left to right.
37 * When we add a glyph to the cache, we see if it fits within one of the existing columns that
38 * have already been started (this is the case if the glyph fits vertically as well as
39 * horizontally, and if its width is sufficiently close to the column width to avoid
40 * sub-optimal packing of small glyphs into wide columns). If there is no column in which the
41 * glyph fits, we check the final node, which is the remaining space in the cache, creating
42 * a new column as appropriate.
43 *
44 * As columns fill up, we remove their CacheBlock from the list to avoid having to check
45 * small blocks in the future.
46 */
47struct CacheBlock {
48    uint16_t mX;
49    uint16_t mY;
50    uint16_t mWidth;
51    uint16_t mHeight;
52    CacheBlock* mNext;
53    CacheBlock* mPrev;
54
55    CacheBlock(uint16_t x, uint16_t y, uint16_t width, uint16_t height)
56            : mX(x), mY(y), mWidth(width), mHeight(height), mNext(nullptr), mPrev(nullptr) {}
57
58    static CacheBlock* insertBlock(CacheBlock* head, CacheBlock* newBlock);
59    static CacheBlock* removeBlock(CacheBlock* head, CacheBlock* blockToRemove);
60
61    void output() {
62        CacheBlock* currBlock = this;
63        while (currBlock) {
64            ALOGD("Block: this, x, y, w, h = %p, %d, %d, %d, %d", currBlock, currBlock->mX,
65                  currBlock->mY, currBlock->mWidth, currBlock->mHeight);
66            currBlock = currBlock->mNext;
67        }
68    }
69};
70
71class CacheTexture {
72public:
73    CacheTexture(uint16_t width, uint16_t height, GLenum format, uint32_t maxQuadCount);
74    ~CacheTexture();
75
76    void reset();
77    void init();
78
79    void releaseMesh();
80    void releasePixelBuffer();
81
82    void allocatePixelBuffer();
83    void allocateMesh();
84
85    // Returns true if glPixelStorei(GL_UNPACK_ROW_LENGTH) must be reset
86    // This method will also call setDirty(false)
87    bool upload();
88
89    bool fitBitmap(const SkGlyph& glyph, uint32_t* retOriginX, uint32_t* retOriginY);
90
91    inline uint16_t getWidth() const { return mWidth; }
92
93    inline uint16_t getHeight() const { return mHeight; }
94
95    inline GLenum getFormat() const { return mFormat; }
96
97    inline uint32_t getOffset(uint16_t x, uint16_t y) const {
98        return (y * getWidth() + x) * PixelBuffer::formatSize(mFormat);
99    }
100
101    inline const Rect* getDirtyRect() const { return &mDirtyRect; }
102
103    inline PixelBuffer* getPixelBuffer() const { return mPixelBuffer; }
104
105    Texture& getTexture() {
106        allocatePixelBuffer();
107        return mTexture;
108    }
109
110    GLuint getTextureId() {
111        allocatePixelBuffer();
112        return mTexture.id();
113    }
114
115    inline bool isDirty() const { return mDirty; }
116
117    inline bool getLinearFiltering() const { return mLinearFiltering; }
118
119    /**
120     * This method assumes that the proper texture unit is active.
121     */
122    void setLinearFiltering(bool linearFiltering);
123
124    inline uint16_t getGlyphCount() const { return mNumGlyphs; }
125
126    TextureVertex* mesh() const { return mMesh; }
127
128    uint32_t meshElementCount() const { return mCurrentQuad * 6; }
129
130    uint16_t* indices() const { return (uint16_t*)nullptr; }
131
132    void resetMesh() { mCurrentQuad = 0; }
133
134    inline void addQuad(float x1, float y1, float u1, float v1, float x2, float y2, float u2,
135                        float v2, float x3, float y3, float u3, float v3, float x4, float y4,
136                        float u4, float v4) {
137        TextureVertex* mesh = mMesh + mCurrentQuad * 4;
138        TextureVertex::set(mesh++, x2, y2, u2, v2);
139        TextureVertex::set(mesh++, x3, y3, u3, v3);
140        TextureVertex::set(mesh++, x1, y1, u1, v1);
141        TextureVertex::set(mesh++, x4, y4, u4, v4);
142        mCurrentQuad++;
143    }
144
145    bool canDraw() const { return mCurrentQuad > 0; }
146
147    bool endOfMesh() const { return mCurrentQuad == mMaxQuadCount; }
148
149    uint32_t calculateFreeMemory() const;
150
151private:
152    void setDirty(bool dirty);
153
154    PixelBuffer* mPixelBuffer = nullptr;
155    Texture mTexture;
156    uint32_t mWidth, mHeight;
157    GLenum mFormat;
158    bool mLinearFiltering = false;
159    bool mDirty = false;
160    uint16_t mNumGlyphs = 0;
161    TextureVertex* mMesh = nullptr;
162    uint32_t mCurrentQuad = 0;
163    uint32_t mMaxQuadCount;
164    Caches& mCaches;
165    CacheBlock* mCacheBlocks;
166    bool mHasUnpackRowLength;
167    Rect mDirtyRect;
168};
169
170};  // namespace uirenderer
171};  // namespace android
172
173#endif  // ANDROID_HWUI_CACHE_TEXTURE_H
174