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_DEFERRED_DISPLAY_LIST_H
     18 #define ANDROID_HWUI_DEFERRED_DISPLAY_LIST_H
     19 
     20 #include <utils/Errors.h>
     21 #include <utils/Vector.h>
     22 
     23 #include "Matrix.h"
     24 #include "Rect.h"
     25 #include "utils/TinyHashMap.h"
     26 
     27 class SkBitmap;
     28 
     29 namespace android {
     30 namespace uirenderer {
     31 
     32 class ClipOp;
     33 class DrawOp;
     34 class SaveOp;
     35 class SaveLayerOp;
     36 class StateOp;
     37 class OpenGLRenderer;
     38 
     39 class Batch;
     40 class DrawBatch;
     41 class MergingDrawBatch;
     42 
     43 typedef void* mergeid_t;
     44 
     45 class DeferredDisplayList {
     46 public:
     47     DeferredDisplayList() { clear(); }
     48     ~DeferredDisplayList() { clear(); }
     49 
     50     enum OpBatchId {
     51         kOpBatch_None = 0, // Don't batch
     52         kOpBatch_Bitmap,
     53         kOpBatch_Patch,
     54         kOpBatch_AlphaVertices,
     55         kOpBatch_Vertices,
     56         kOpBatch_AlphaMaskTexture,
     57         kOpBatch_Text,
     58         kOpBatch_ColorText,
     59 
     60         kOpBatch_Count, // Add other batch ids before this
     61     };
     62 
     63     bool isEmpty() { return mBatches.isEmpty(); }
     64 
     65     /**
     66      * Plays back all of the draw ops recorded into batches to the renderer.
     67      * Adjusts the state of the renderer as necessary, and restores it when complete
     68      */
     69     status_t flush(OpenGLRenderer& renderer, Rect& dirty);
     70 
     71     void addClip(OpenGLRenderer& renderer, ClipOp* op);
     72     void addSaveLayer(OpenGLRenderer& renderer, SaveLayerOp* op, int newSaveCount);
     73     void addSave(OpenGLRenderer& renderer, SaveOp* op, int newSaveCount);
     74     void addRestoreToCount(OpenGLRenderer& renderer, StateOp* op, int newSaveCount);
     75 
     76     /**
     77      * Add a draw op into the DeferredDisplayList, reordering as needed (for performance) if
     78      * disallowReorder is false, respecting draw order when overlaps occur
     79      */
     80     void addDrawOp(OpenGLRenderer& renderer, DrawOp* op);
     81 
     82 private:
     83     /**
     84      * Resets the batching back-pointers, creating a barrier in the operation stream so that no ops
     85      * added in the future will be inserted into a batch that already exist.
     86      */
     87     void resetBatchingState();
     88 
     89     void clear();
     90 
     91     void storeStateOpBarrier(OpenGLRenderer& renderer, StateOp* op);
     92     void storeRestoreToCountBarrier(OpenGLRenderer& renderer, StateOp* op, int newSaveCount);
     93 
     94     bool recordingComplexClip() const { return mComplexClipStackStart >= 0; }
     95 
     96     int getStateOpDeferFlags() const;
     97     int getDrawOpDeferFlags() const;
     98 
     99     /**
    100      * At defer time, stores the *defer time* savecount of save/saveLayer ops that were deferred, so
    101      * that when an associated restoreToCount is deferred, it can be recorded as a
    102      * RestoreToCountBatch
    103      */
    104     Vector<int> mSaveStack;
    105     int mComplexClipStackStart;
    106 
    107     Vector<Batch*> mBatches;
    108 
    109     // Maps batch ids to the most recent *non-merging* batch of that id
    110     Batch* mBatchLookup[kOpBatch_Count];
    111 
    112     // Points to the index after the most recent barrier
    113     int mEarliestBatchIndex;
    114 
    115     /**
    116      * Maps the mergeid_t returned by an op's getMergeId() to the most recently seen
    117      * MergingDrawBatch of that id. These ids are unique per draw type and guaranteed to not
    118      * collide, which avoids the need to resolve mergeid collisions.
    119      */
    120     TinyHashMap<mergeid_t, DrawBatch*> mMergingBatches[kOpBatch_Count];
    121 };
    122 
    123 }; // namespace uirenderer
    124 }; // namespace android
    125 
    126 #endif // ANDROID_HWUI_DEFERRED_DISPLAY_LIST_H
    127