Home | History | Annotate | Download | only in hwui 
      1 /*
      2  * Copyright (C) 2013 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_H
     18 #define ANDROID_HWUI_DISPLAY_LIST_H
     19 
     20 #include <SkCamera.h>
     21 #include <SkMatrix.h>
     22 
     23 #include <private/hwui/DrawGlInfo.h>
     24 
     25 #include <utils/KeyedVector.h>
     26 #include <utils/LinearAllocator.h>
     27 #include <utils/RefBase.h>
     28 #include <utils/SortedVector.h>
     29 #include <utils/String8.h>
     30 
     31 #include <cutils/compiler.h>
     32 
     33 #include <androidfw/ResourceTypes.h>
     34 
     35 #include "Debug.h"
     36 #include "CanvasProperty.h"
     37 #include "DeferredDisplayList.h"
     38 #include "GlFunctorLifecycleListener.h"
     39 #include "Matrix.h"
     40 #include "RenderProperties.h"
     41 
     42 #include <vector>
     43 
     44 class SkBitmap;
     45 class SkPaint;
     46 class SkPath;
     47 class SkRegion;
     48 
     49 namespace android {
     50 namespace uirenderer {
     51 
     52 class DeferredDisplayList;
     53 class DisplayListOp;
     54 class DisplayListCanvas;
     55 class OpenGLRenderer;
     56 class Rect;
     57 class Layer;
     58 
     59 #if HWUI_NEW_OPS
     60 struct RecordedOp;
     61 struct RenderNodeOp;
     62 
     63 typedef RecordedOp BaseOpType;
     64 typedef RenderNodeOp NodeOpType;
     65 #else
     66 class DrawRenderNodeOp;
     67 
     68 typedef DisplayListOp BaseOpType;
     69 typedef DrawRenderNodeOp NodeOpType;
     70 #endif
     71 
     72 namespace VectorDrawable {
     73 class Tree;
     74 };
     75 typedef uirenderer::VectorDrawable::Tree VectorDrawableRoot;
     76 
     77 /**
     78  * Holds data used in the playback a tree of DisplayLists.
     79  */
     80 struct PlaybackStateStruct {
     81 protected:
     82     PlaybackStateStruct(OpenGLRenderer& renderer, int replayFlags, LinearAllocator* allocator)
     83             : mRenderer(renderer)
     84             , mReplayFlags(replayFlags)
     85             , mAllocator(allocator) {}
     86 
     87 public:
     88     OpenGLRenderer& mRenderer;
     89     const int mReplayFlags;
     90 
     91     // Allocator with the lifetime of a single frame. replay uses an Allocator owned by the struct,
     92     // while defer shares the DeferredDisplayList's Allocator
     93     // TODO: move this allocator to be owned by object with clear frame lifecycle
     94     LinearAllocator * const mAllocator;
     95 
     96     SkPath* allocPathForFrame() {
     97         return mRenderer.allocPathForFrame();
     98     }
     99 };
    100 
    101 struct DeferStateStruct : public PlaybackStateStruct {
    102     DeferStateStruct(DeferredDisplayList& deferredList, OpenGLRenderer& renderer, int replayFlags)
    103             : PlaybackStateStruct(renderer, replayFlags, &(deferredList.mAllocator)),
    104             mDeferredList(deferredList) {}
    105 
    106     DeferredDisplayList& mDeferredList;
    107 };
    108 
    109 struct ReplayStateStruct : public PlaybackStateStruct {
    110     ReplayStateStruct(OpenGLRenderer& renderer, Rect& dirty, int replayFlags)
    111             : PlaybackStateStruct(renderer, replayFlags, &mReplayAllocator),
    112             mDirty(dirty) {}
    113 
    114     Rect& mDirty;
    115     LinearAllocator mReplayAllocator;
    116 };
    117 
    118 struct FunctorContainer {
    119     Functor* functor;
    120     GlFunctorLifecycleListener* listener;
    121 };
    122 
    123 /**
    124  * Data structure that holds the list of commands used in display list stream
    125  */
    126 class DisplayList {
    127     friend class DisplayListCanvas;
    128     friend class RecordingCanvas;
    129 public:
    130     struct Chunk {
    131         // range of included ops in DisplayList::ops()
    132         size_t beginOpIndex;
    133         size_t endOpIndex;
    134 
    135         // range of included children in DisplayList::children()
    136         size_t beginChildIndex;
    137         size_t endChildIndex;
    138 
    139         // whether children with non-zero Z in the chunk should be reordered
    140         bool reorderChildren;
    141 #if HWUI_NEW_OPS
    142         const ClipBase* reorderClip;
    143 #endif
    144     };
    145 
    146     DisplayList();
    147     ~DisplayList();
    148 
    149     // index of DisplayListOp restore, after which projected descendants should be drawn
    150     int projectionReceiveIndex;
    151 
    152     const LsaVector<Chunk>& getChunks() const { return chunks; }
    153     const LsaVector<BaseOpType*>& getOps() const { return ops; }
    154 
    155     const LsaVector<NodeOpType*>& getChildren() const { return children; }
    156 
    157     const LsaVector<const SkBitmap*>& getBitmapResources() const { return bitmapResources; }
    158     const LsaVector<FunctorContainer>& getFunctors() const { return functors; }
    159     const LsaVector<VectorDrawableRoot*>& getVectorDrawables() { return vectorDrawables; }
    160 
    161     size_t addChild(NodeOpType* childOp);
    162 
    163 
    164     void ref(VirtualLightRefBase* prop) {
    165         referenceHolders.push_back(prop);
    166     }
    167 
    168     size_t getUsedSize() {
    169         return allocator.usedSize();
    170     }
    171     bool isEmpty() {
    172 #if HWUI_NEW_OPS
    173         return ops.empty();
    174 #else
    175         return !hasDrawOps;
    176 #endif
    177     }
    178 
    179 private:
    180     // allocator into which all ops and LsaVector arrays allocated
    181     LinearAllocator allocator;
    182     LinearStdAllocator<void*> stdAllocator;
    183 
    184     LsaVector<Chunk> chunks;
    185     LsaVector<BaseOpType*> ops;
    186 
    187     // list of Ops referring to RenderNode children for quick, non-drawing traversal
    188     LsaVector<NodeOpType*> children;
    189 
    190     // Resources - Skia objects + 9 patches referred to by this DisplayList
    191     LsaVector<const SkBitmap*> bitmapResources;
    192     LsaVector<const SkPath*> pathResources;
    193     LsaVector<const Res_png_9patch*> patchResources;
    194     LsaVector<std::unique_ptr<const SkPaint>> paints;
    195     LsaVector<std::unique_ptr<const SkRegion>> regions;
    196     LsaVector< sp<VirtualLightRefBase> > referenceHolders;
    197 
    198     // List of functors
    199     LsaVector<FunctorContainer> functors;
    200 
    201     // List of VectorDrawables that need to be notified of pushStaging. Note that this list gets nothing
    202     // but a callback during sync DisplayList, unlike the list of functors defined above, which
    203     // gets special treatment exclusive for webview.
    204     LsaVector<VectorDrawableRoot*> vectorDrawables;
    205 
    206     bool hasDrawOps; // only used if !HWUI_NEW_OPS
    207 
    208     void cleanupResources();
    209 };
    210 
    211 }; // namespace uirenderer
    212 }; // namespace android
    213 
    214 #endif // ANDROID_HWUI_OPENGL_RENDERER_H
    215