FontRenderer.h revision c15008e72ec00ca20a271c3006dac649fd07533b 
1/*
2 * Copyright (C) 2010 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_FONT_RENDERER_H
18#define ANDROID_HWUI_FONT_RENDERER_H
19
20#include <utils/String8.h>
21#include <utils/String16.h>
22#include <utils/Vector.h>
23#include <utils/KeyedVector.h>
24
25#include <SkScalerContext.h>
26#include <SkPaint.h>
27
28#include <GLES2/gl2.h>
29
30#include "Rect.h"
31#include "Properties.h"
32
33namespace android {
34namespace uirenderer {
35
36class FontRenderer;
37
38/**
39 * Represents a font, defined by a Skia font id and a font size. A font is used
40 * to generate glyphs and cache them in the FontState.
41 */
42class Font {
43public:
44    ~Font();
45
46    /**
47     * Renders the specified string of text.
48     * If bitmap is specified, it will be used as the render target
49     */
50    void renderUTF(SkPaint* paint, const char *text, uint32_t start, uint32_t len,
51                     int numGlyphs, int x, int y,
52                     uint8_t *bitmap = NULL, uint32_t bitmapW = 0, uint32_t bitmapH = 0);
53    /**
54     * Creates a new font associated with the specified font state.
55     */
56    static Font* create(FontRenderer* state, uint32_t fontId, float fontSize);
57
58protected:
59    friend class FontRenderer;
60
61    enum RenderMode {
62        FRAMEBUFFER,
63        BITMAP,
64        MEASURE,
65    };
66
67    void renderUTF(SkPaint* paint, const char *text, uint32_t start, uint32_t len,
68                     int numGlyphs, int x, int y, RenderMode mode,
69                     uint8_t *bitmap, uint32_t bitmapW, uint32_t bitmapH,
70                     Rect *bounds);
71
72    void measureUTF(SkPaint* paint, const char* text, uint32_t start, uint32_t len,
73                      int numGlyphs, Rect *bounds);
74
75    struct CachedGlyphInfo {
76        // Has the cache been invalidated?
77        bool mIsValid;
78        // Location of the cached glyph in the bitmap
79        // in case we need to resize the texture or
80        // render to bitmap
81        uint32_t mStartX;
82        uint32_t mStartY;
83        uint32_t mBitmapWidth;
84        uint32_t mBitmapHeight;
85        // Also cache texture coords for the quad
86        float mBitmapMinU;
87        float mBitmapMinV;
88        float mBitmapMaxU;
89        float mBitmapMaxV;
90        // Minimize how much we call freetype
91        uint32_t mGlyphIndex;
92        uint32_t mAdvanceX;
93        uint32_t mAdvanceY;
94        // Values below contain a glyph's origin in the bitmap
95        int32_t mBitmapLeft;
96        int32_t mBitmapTop;
97        // Auto-kerning
98        SkFixed mLsbDelta;
99        SkFixed mRsbDelta;
100    };
101
102    Font(FontRenderer* state, uint32_t fontId, float fontSize);
103
104    DefaultKeyedVector<int32_t, CachedGlyphInfo*> mCachedGlyphs;
105
106    void invalidateTextureCache();
107
108    CachedGlyphInfo* cacheGlyph(SkPaint* paint, int32_t glyph);
109    void updateGlyphCache(SkPaint* paint, const SkGlyph& skiaGlyph, CachedGlyphInfo *glyph);
110    void measureCachedGlyph(CachedGlyphInfo *glyph, int x, int y, Rect *bounds);
111    void drawCachedGlyph(CachedGlyphInfo *glyph, int x, int y);
112    void drawCachedGlyph(CachedGlyphInfo *glyph, int x, int y,
113                          uint8_t *bitmap, uint32_t bitmapW, uint32_t bitmapH);
114
115    CachedGlyphInfo* getCachedUTFChar(SkPaint* paint, int32_t utfChar);
116
117    FontRenderer* mState;
118    uint32_t mFontId;
119    float mFontSize;
120};
121
122class FontRenderer {
123public:
124    FontRenderer();
125    ~FontRenderer();
126
127    void init();
128    void deinit();
129
130    void setGammaTable(const uint8_t* gammaTable) {
131        mGammaTable = gammaTable;
132    }
133
134    void setFont(SkPaint* paint, uint32_t fontId, float fontSize);
135    bool renderText(SkPaint* paint, const Rect* clip, const char *text, uint32_t startIndex,
136            uint32_t len, int numGlyphs, int x, int y, Rect* bounds);
137
138    struct DropShadow {
139        DropShadow() { };
140
141        DropShadow(const DropShadow& dropShadow):
142            width(dropShadow.width), height(dropShadow.height),
143            image(dropShadow.image), penX(dropShadow.penX),
144            penY(dropShadow.penY) {
145        }
146
147        uint32_t width;
148        uint32_t height;
149        uint8_t* image;
150        int32_t penX;
151        int32_t penY;
152    };
153
154    // After renderDropShadow returns, the called owns the memory in DropShadow.image
155    // and is responsible for releasing it when it's done with it
156    DropShadow renderDropShadow(SkPaint* paint, const char *text, uint32_t startIndex,
157            uint32_t len, int numGlyphs, uint32_t radius);
158
159    GLuint getTexture(bool linearFiltering = false) {
160        checkInit();
161        if (linearFiltering != mLinearFiltering) {
162            mLinearFiltering = linearFiltering;
163            const GLenum filtering = linearFiltering ? GL_LINEAR : GL_NEAREST;
164
165            glBindTexture(GL_TEXTURE_2D, mTextureId);
166            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
167            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
168        }
169        return mTextureId;
170    }
171
172    uint32_t getCacheWidth() const {
173        return mCacheWidth;
174    }
175
176    uint32_t getCacheHeight() const {
177        return mCacheHeight;
178    }
179
180protected:
181    friend class Font;
182
183    const uint8_t* mGammaTable;
184
185    struct CacheTextureLine {
186        uint16_t mMaxHeight;
187        uint16_t mMaxWidth;
188        uint32_t mCurrentRow;
189        uint32_t mCurrentCol;
190        bool mDirty;
191
192        CacheTextureLine(uint16_t maxWidth, uint16_t maxHeight, uint32_t currentRow,
193                uint32_t currentCol):
194                    mMaxHeight(maxHeight),
195                    mMaxWidth(maxWidth),
196                    mCurrentRow(currentRow),
197                    mCurrentCol(currentCol),
198                    mDirty(false) {
199        }
200
201        bool fitBitmap(const SkGlyph& glyph, uint32_t *retOriginX, uint32_t *retOriginY) {
202            if (glyph.fHeight + 2 > mMaxHeight) {
203                return false;
204            }
205
206            if (mCurrentCol + glyph.fWidth + 2 < mMaxWidth) {
207                *retOriginX = mCurrentCol + 1;
208                *retOriginY = mCurrentRow + 1;
209                mCurrentCol += glyph.fWidth + 2;
210                mDirty = true;
211                return true;
212            }
213
214            return false;
215        }
216    };
217
218    void initTextTexture();
219    bool cacheBitmap(const SkGlyph& glyph, uint32_t *retOriginX, uint32_t *retOriginY);
220
221    void flushAllAndInvalidate();
222    void initVertexArrayBuffers();
223
224    void checkInit();
225
226    String16 mLatinPrecache;
227    void precacheLatin(SkPaint* paint);
228
229    void issueDrawCommand();
230    void appendMeshQuad(float x1, float y1, float z1, float u1, float v1, float x2, float y2,
231            float z2, float u2, float v2, float x3, float y3, float z3, float u3, float v3,
232            float x4, float y4, float z4, float u4, float v4);
233
234    uint32_t mCacheWidth;
235    uint32_t mCacheHeight;
236
237    Vector<CacheTextureLine*> mCacheLines;
238    uint32_t getRemainingCacheCapacity();
239
240    Font* mCurrentFont;
241    Vector<Font*> mActiveFonts;
242
243    // Texture to cache glyph bitmaps
244    uint8_t* mTextTexture;
245    const uint8_t* getTextTextureData() const {
246        return mTextTexture;
247    }
248    GLuint mTextureId;
249    void checkTextureUpdate();
250    bool mUploadTexture;
251
252    // Pointer to vertex data to speed up frame to frame work
253    float *mTextMeshPtr;
254    uint32_t mCurrentQuadIndex;
255    uint32_t mMaxNumberOfQuads;
256
257    uint32_t mIndexBufferID;
258
259    const Rect* mClip;
260    Rect* mBounds;
261    bool mDrawn;
262
263    bool mInitialized;
264
265    bool mLinearFiltering;
266
267    void computeGaussianWeights(float* weights, int32_t radius);
268    void horizontalBlur(float* weights, int32_t radius, const uint8_t *source, uint8_t *dest,
269            int32_t width, int32_t height);
270    void verticalBlur(float* weights, int32_t radius, const uint8_t *source, uint8_t *dest,
271            int32_t width, int32_t height);
272    void blurImage(uint8_t* image, int32_t width, int32_t height, int32_t radius);
273};
274
275}; // namespace uirenderer
276}; // namespace android
277
278#endif // ANDROID_HWUI_FONT_RENDERER_H
279