DisplayListRenderer.h revision 13631f3da855f200a151e7837ed9f6b079622b58 
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_DISPLAY_LIST_RENDERER_H
18#define ANDROID_HWUI_DISPLAY_LIST_RENDERER_H
19
20#include <SkChunkAlloc.h>
21#include <SkFlattenable.h>
22#include <SkMatrix.h>
23#include <SkPaint.h>
24#include <SkPath.h>
25#include <SkRefCnt.h>
26#include <SkTDArray.h>
27#include <SkTSearch.h>
28
29#include <cutils/compiler.h>
30
31#include <utils/String8.h>
32
33#include "DisplayListLogBuffer.h"
34#include "OpenGLRenderer.h"
35#include "utils/Functor.h"
36
37namespace android {
38namespace uirenderer {
39
40///////////////////////////////////////////////////////////////////////////////
41// Defines
42///////////////////////////////////////////////////////////////////////////////
43
44#define MIN_WRITER_SIZE 4096
45
46// Debug
47#if DEBUG_DISPLAY_LIST
48    #define DISPLAY_LIST_LOGD(...) ALOGD(__VA_ARGS__)
49#else
50    #define DISPLAY_LIST_LOGD(...)
51#endif
52
53///////////////////////////////////////////////////////////////////////////////
54// Display list
55///////////////////////////////////////////////////////////////////////////////
56
57class DisplayListRenderer;
58
59/**
60 * Replays recorded drawing commands.
61 */
62class DisplayList {
63public:
64    DisplayList(const DisplayListRenderer& recorder);
65    ANDROID_API ~DisplayList();
66
67    // IMPORTANT: Update the intialization of OP_NAMES in the .cpp file
68    //            when modifying this file
69    enum Op {
70        // Non-drawing operations
71        Save = 0,
72        Restore,
73        RestoreToCount,
74        SaveLayer,
75        SaveLayerAlpha,
76        Translate,
77        Rotate,
78        Scale,
79        Skew,
80        SetMatrix,
81        ConcatMatrix,
82        ClipRect,
83        // Drawing operations
84        DrawDisplayList,
85        DrawLayer,
86        DrawBitmap,
87        DrawBitmapMatrix,
88        DrawBitmapRect,
89        DrawBitmapMesh,
90        DrawPatch,
91        DrawColor,
92        DrawRect,
93        DrawRoundRect,
94        DrawCircle,
95        DrawOval,
96        DrawArc,
97        DrawPath,
98        DrawLines,
99        DrawPoints,
100        DrawText,
101        DrawPosText,
102        ResetShader,
103        SetupShader,
104        ResetColorFilter,
105        SetupColorFilter,
106        ResetShadow,
107        SetupShadow,
108        ResetPaintFilter,
109        SetupPaintFilter,
110        DrawGLFunction,
111    };
112
113    static const char* OP_NAMES[];
114
115    void initFromDisplayListRenderer(const DisplayListRenderer& recorder, bool reusing = false);
116
117    ANDROID_API size_t getSize();
118
119    bool replay(OpenGLRenderer& renderer, Rect& dirty, uint32_t level = 0);
120
121    void output(OpenGLRenderer& renderer, uint32_t level = 0);
122
123    ANDROID_API static void outputLogBuffer(int fd);
124
125    void setRenderable(bool renderable) {
126        mIsRenderable = renderable;
127    }
128
129    bool isRenderable() const {
130        return mIsRenderable;
131    }
132
133    void setName(const char* name) {
134        if (name) {
135            mName.setTo(name);
136        }
137    }
138
139private:
140    void init();
141
142    void clearResources();
143
144    class TextContainer {
145    public:
146        size_t length() const {
147            return mByteLength;
148        }
149
150        const char* text() const {
151            return (const char*) mText;
152        }
153
154        size_t mByteLength;
155        const char* mText;
156    };
157
158    SkBitmap* getBitmap() {
159        return (SkBitmap*) getInt();
160    }
161
162    SkiaShader* getShader() {
163        return (SkiaShader*) getInt();
164    }
165
166    SkiaColorFilter* getColorFilter() {
167        return (SkiaColorFilter*) getInt();
168    }
169
170    inline int getIndex() {
171        return mReader.readInt();
172    }
173
174    inline int getInt() {
175        return mReader.readInt();
176    }
177
178    inline uint32_t getUInt() {
179        return mReader.readU32();
180    }
181
182    SkMatrix* getMatrix() {
183        return (SkMatrix*) getInt();
184    }
185
186    SkPath* getPath() {
187        return (SkPath*) getInt();
188    }
189
190    SkPaint* getPaint(OpenGLRenderer& renderer) {
191        return renderer.filterPaint((SkPaint*) getInt());
192    }
193
194    DisplayList* getDisplayList() {
195        return (DisplayList*) getInt();
196    }
197
198    inline float getFloat() {
199        return mReader.readScalar();
200    }
201
202    int32_t* getInts(uint32_t& count) {
203        count = getInt();
204        return (int32_t*) mReader.skip(count * sizeof(int32_t));
205    }
206
207    uint32_t* getUInts(int8_t& count) {
208        count = getInt();
209        return (uint32_t*) mReader.skip(count * sizeof(uint32_t));
210    }
211
212    float* getFloats(int& count) {
213        count = getInt();
214        return (float*) mReader.skip(count * sizeof(float));
215    }
216
217    void getText(TextContainer* text) {
218        size_t length = text->mByteLength = getInt();
219        text->mText = (const char*) mReader.skip(length);
220    }
221
222    Vector<SkBitmap*> mBitmapResources;
223    Vector<SkiaColorFilter*> mFilterResources;
224
225    Vector<SkPaint*> mPaints;
226    Vector<SkPath*> mPaths;
227    Vector<SkMatrix*> mMatrices;
228    Vector<SkiaShader*> mShaders;
229
230    mutable SkFlattenableReadBuffer mReader;
231
232    size_t mSize;
233
234    bool mIsRenderable;
235
236    String8 mName;
237};
238
239///////////////////////////////////////////////////////////////////////////////
240// Renderer
241///////////////////////////////////////////////////////////////////////////////
242
243/**
244 * Records drawing commands in a display list for latter playback.
245 */
246class DisplayListRenderer: public OpenGLRenderer {
247public:
248    ANDROID_API DisplayListRenderer();
249    virtual ~DisplayListRenderer();
250
251    ANDROID_API DisplayList* getDisplayList(DisplayList* displayList);
252
253    virtual void setViewport(int width, int height);
254    virtual void prepareDirty(float left, float top, float right, float bottom, bool opaque);
255    virtual void finish();
256
257    virtual bool callDrawGLFunction(Functor *functor, Rect& dirty);
258
259    virtual void interrupt();
260    virtual void resume();
261
262    virtual int save(int flags);
263    virtual void restore();
264    virtual void restoreToCount(int saveCount);
265
266    virtual int saveLayer(float left, float top, float right, float bottom,
267            SkPaint* p, int flags);
268    virtual int saveLayerAlpha(float left, float top, float right, float bottom,
269                int alpha, int flags);
270
271    virtual void translate(float dx, float dy);
272    virtual void rotate(float degrees);
273    virtual void scale(float sx, float sy);
274    virtual void skew(float sx, float sy);
275
276    virtual void setMatrix(SkMatrix* matrix);
277    virtual void concatMatrix(SkMatrix* matrix);
278
279    virtual bool clipRect(float left, float top, float right, float bottom, SkRegion::Op op);
280
281    virtual bool drawDisplayList(DisplayList* displayList, uint32_t width, uint32_t height,
282            Rect& dirty, uint32_t level = 0);
283    virtual void drawLayer(Layer* layer, float x, float y, SkPaint* paint);
284    virtual void drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint);
285    virtual void drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint);
286    virtual void drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop,
287            float srcRight, float srcBottom, float dstLeft, float dstTop,
288            float dstRight, float dstBottom, SkPaint* paint);
289    virtual void drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight,
290            float* vertices, int* colors, SkPaint* paint);
291    virtual void drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs,
292            const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors,
293            float left, float top, float right, float bottom, SkPaint* paint);
294    virtual void drawColor(int color, SkXfermode::Mode mode);
295    virtual void drawRect(float left, float top, float right, float bottom, SkPaint* paint);
296    virtual void drawRoundRect(float left, float top, float right, float bottom,
297            float rx, float ry, SkPaint* paint);
298    virtual void drawCircle(float x, float y, float radius, SkPaint* paint);
299    virtual void drawOval(float left, float top, float right, float bottom, SkPaint* paint);
300    virtual void drawArc(float left, float top, float right, float bottom,
301            float startAngle, float sweepAngle, bool useCenter, SkPaint* paint);
302    virtual void drawPath(SkPath* path, SkPaint* paint);
303    virtual void drawLines(float* points, int count, SkPaint* paint);
304    virtual void drawPoints(float* points, int count, SkPaint* paint);
305    virtual void drawText(const char* text, int bytesCount, int count, float x, float y,
306            SkPaint* paint, float length = 1.0f);
307    virtual void drawPosText(const char* text, int bytesCount, int count, const float* positions,
308            SkPaint* paint);
309
310    virtual void resetShader();
311    virtual void setupShader(SkiaShader* shader);
312
313    virtual void resetColorFilter();
314    virtual void setupColorFilter(SkiaColorFilter* filter);
315
316    virtual void resetShadow();
317    virtual void setupShadow(float radius, float dx, float dy, int color);
318
319    virtual void resetPaintFilter();
320    virtual void setupPaintFilter(int clearBits, int setBits);
321
322    ANDROID_API void reset();
323
324    const SkWriter32& writeStream() const {
325        return mWriter;
326    }
327
328    const Vector<SkBitmap*>& getBitmapResources() const {
329        return mBitmapResources;
330    }
331
332    const Vector<SkiaColorFilter*>& getFilterResources() const {
333        return mFilterResources;
334    }
335
336    const Vector<SkiaShader*>& getShaders() const {
337        return mShaders;
338    }
339
340    const Vector<SkPaint*>& getPaints() const {
341        return mPaints;
342    }
343
344    const Vector<SkPath*>& getPaths() const {
345        return mPaths;
346    }
347
348    const Vector<SkMatrix*>& getMatrices() const {
349        return mMatrices;
350    }
351
352private:
353    void insertRestoreToCount() {
354        if (mRestoreSaveCount >= 0) {
355            mWriter.writeInt(DisplayList::RestoreToCount);
356            addInt(mRestoreSaveCount);
357            mRestoreSaveCount = -1;
358        }
359    }
360
361    inline void addOp(DisplayList::Op drawOp) {
362        insertRestoreToCount();
363        mWriter.writeInt(drawOp);
364        mHasDrawOps = mHasDrawOps || drawOp >= DisplayList::DrawDisplayList;
365    }
366
367    inline void addInt(int value) {
368        mWriter.writeInt(value);
369    }
370
371    inline void addSize(uint32_t w, uint32_t h) {
372        mWriter.writeInt(w);
373        mWriter.writeInt(h);
374    }
375
376    void addInts(const int32_t* values, uint32_t count) {
377        mWriter.writeInt(count);
378        for (uint32_t i = 0; i < count; i++) {
379            mWriter.writeInt(values[i]);
380        }
381    }
382
383    void addUInts(const uint32_t* values, int8_t count) {
384        mWriter.writeInt(count);
385        for (int8_t i = 0; i < count; i++) {
386            mWriter.writeInt(values[i]);
387        }
388    }
389
390    inline void addFloat(float value) {
391        mWriter.writeScalar(value);
392    }
393
394    void addFloats(const float* values, int count) {
395        mWriter.writeInt(count);
396        for (int i = 0; i < count; i++) {
397            mWriter.writeScalar(values[i]);
398        }
399    }
400
401    inline void addPoint(float x, float y) {
402        mWriter.writeScalar(x);
403        mWriter.writeScalar(y);
404    }
405
406    inline void addBounds(float left, float top, float right, float bottom) {
407        mWriter.writeScalar(left);
408        mWriter.writeScalar(top);
409        mWriter.writeScalar(right);
410        mWriter.writeScalar(bottom);
411    }
412
413    inline void addText(const void* text, size_t byteLength) {
414        mWriter.writeInt(byteLength);
415        mWriter.writePad(text, byteLength);
416    }
417
418    inline void addPath(SkPath* path) {
419        if (!path) {
420            addInt((int) NULL);
421            return;
422        }
423
424        SkPath* pathCopy = mPathMap.valueFor(path);
425        if (pathCopy == NULL || pathCopy->getGenerationID() != path->getGenerationID()) {
426            pathCopy = new SkPath(*path);
427            mPathMap.add(path, pathCopy);
428            mPaths.add(pathCopy);
429        }
430
431        addInt((int) pathCopy);
432    }
433
434    inline void addPaint(SkPaint* paint) {
435        if (!paint) {
436            addInt((int) NULL);
437            return;
438        }
439
440        SkPaint* paintCopy = mPaintMap.valueFor(paint);
441        if (paintCopy == NULL || paintCopy->getGenerationID() != paint->getGenerationID()) {
442            paintCopy = new SkPaint(*paint);
443            mPaintMap.add(paint, paintCopy);
444            mPaints.add(paintCopy);
445        }
446
447        addInt((int) paintCopy);
448    }
449
450    inline void addDisplayList(DisplayList* displayList) {
451        // TODO: To be safe, the display list should be ref-counted in the
452        //       resources cache, but we rely on the caller (UI toolkit) to
453        //       do the right thing for now
454        addInt((int) displayList);
455    }
456
457    inline void addMatrix(SkMatrix* matrix) {
458        // Copying the matrix is cheap and prevents against the user changing the original
459        // matrix before the operation that uses it
460        SkMatrix* copy = new SkMatrix(*matrix);
461        addInt((int) copy);
462        mMatrices.add(copy);
463    }
464
465    inline void addBitmap(SkBitmap* bitmap) {
466        // Note that this assumes the bitmap is immutable. There are cases this won't handle
467        // correctly, such as creating the bitmap from scratch, drawing with it, changing its
468        // contents, and drawing again. The only fix would be to always copy it the first time,
469        // which doesn't seem worth the extra cycles for this unlikely case.
470        addInt((int) bitmap);
471        mBitmapResources.add(bitmap);
472        Caches::getInstance().resourceCache.incrementRefcount(bitmap);
473    }
474
475    inline void addShader(SkiaShader* shader) {
476        if (!shader) {
477            addInt((int) NULL);
478            return;
479        }
480
481        SkiaShader* shaderCopy = mShaderMap.valueFor(shader);
482        // TODO: We also need to handle generation ID changes in compose shaders
483        if (shaderCopy == NULL || shaderCopy->getGenerationId() != shader->getGenerationId()) {
484            shaderCopy = shader->copy();
485            mShaderMap.add(shader, shaderCopy);
486            mShaders.add(shaderCopy);
487            Caches::getInstance().resourceCache.incrementRefcount(shaderCopy);
488        }
489
490        addInt((int) shaderCopy);
491    }
492
493    inline void addColorFilter(SkiaColorFilter* colorFilter) {
494        addInt((int) colorFilter);
495        mFilterResources.add(colorFilter);
496        Caches::getInstance().resourceCache.incrementRefcount(colorFilter);
497    }
498
499    Vector<SkBitmap*> mBitmapResources;
500    Vector<SkiaColorFilter*> mFilterResources;
501
502    Vector<SkPaint*> mPaints;
503    DefaultKeyedVector<SkPaint*, SkPaint*> mPaintMap;
504
505    Vector<SkPath*> mPaths;
506    DefaultKeyedVector<SkPath*, SkPath*> mPathMap;
507
508    Vector<SkiaShader*> mShaders;
509    DefaultKeyedVector<SkiaShader*, SkiaShader*> mShaderMap;
510
511    Vector<SkMatrix*> mMatrices;
512
513    SkWriter32 mWriter;
514
515    int mRestoreSaveCount;
516    bool mHasDrawOps;
517
518    friend class DisplayList;
519
520}; // class DisplayListRenderer
521
522}; // namespace uirenderer
523}; // namespace android
524
525#endif // ANDROID_HWUI_DISPLAY_LIST_RENDERER_H
526