Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d9d7f127 authored by John Reck's avatar John Reck
Browse files

Delete a bunch of code 

This removes the duality of DisplayList, removing a small amount of
overhead

Test: buids & hwuiunit passes

Change-Id: I8bb3a20e9ead1caec4b4a8a3e9f2c08f717a7096
parent ba720d09

libs/hwui/Android.bp

+0 −4
Original line number Diff line number Diff line
@@ -210,8 +210,6 @@ cc_defaults { 
        "DamageAccumulator.cpp",

        "DeferredLayerUpdater.cpp",

        "DeviceInfo.cpp",

        "DisplayList.cpp",

        "FrameBuilder.cpp",

        "FrameInfo.cpp",

        "FrameInfoVisualizer.cpp",

        "GlLayer.cpp",
@@ -237,7 +235,6 @@ cc_defaults { 
        "Properties.cpp",

        "PropertyValuesAnimatorSet.cpp",

        "PropertyValuesHolder.cpp",

        "RecordingCanvas.cpp",

        "RenderNode.cpp",

        "RenderProperties.cpp",

        "ResourceCache.cpp",
@@ -399,7 +396,6 @@ cc_benchmark { 
    srcs: [

        "tests/microbench/main.cpp",

        "tests/microbench/DisplayListCanvasBench.cpp",

        "tests/microbench/FrameBuilderBench.cpp",

        "tests/microbench/LinearAllocatorBench.cpp",

        "tests/microbench/PathParserBench.cpp",

        "tests/microbench/RenderNodeBench.cpp",

libs/hwui/Animator.h

+2 −2
Original line number Diff line number Diff line
@@ -16,6 +16,8 @@ 
#ifndef ANIMATOR_H

#define ANIMATOR_H



#include "CanvasProperty.h"



#include <cutils/compiler.h>

#include <utils/RefBase.h>

#include <utils/StrongPointer.h>
@@ -31,8 +33,6 @@ namespace uirenderer { 


class AnimationContext;

class BaseRenderNodeAnimator;

class CanvasPropertyPrimitive;

class CanvasPropertyPaint;

class Interpolator;

class RenderNode;

class RenderProperties;

libs/hwui/BakedOpRenderer.h

+1 −10
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#pragma once



#include "BakedOpState.h"

#include "Lighting.h"

#include "Matrix.h"

#include "utils/Macros.h"
@@ -42,16 +43,6 @@ struct ClipBase; 
class BakedOpRenderer {

public:

    typedef void (*GlopReceiver)(BakedOpRenderer&, const Rect*, const ClipBase*, const Glop&);

    /**

     * Position agnostic shadow lighting info. Used with all shadow ops in scene.

     */

    struct LightInfo {

        LightInfo() : LightInfo(0, 0) {}

        LightInfo(uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha)

                : ambientShadowAlpha(ambientShadowAlpha), spotShadowAlpha(spotShadowAlpha) {}

        uint8_t ambientShadowAlpha;

        uint8_t spotShadowAlpha;

    };



    BakedOpRenderer(Caches& caches, RenderState& renderState, bool opaque, bool wideColorGamut,

                    const LightInfo& lightInfo)

libs/hwui/DisplayList.cpp

deleted100644 → 0
+0 −142
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2013 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <SkCanvas.h>

#include <algorithm>



#include <utils/Trace.h>



#include "DamageAccumulator.h"

#include "Debug.h"

#include "DisplayList.h"

#include "OpDumper.h"

#include "RecordedOp.h"

#include "RenderNode.h"

#include "VectorDrawable.h"

#include "renderthread/CanvasContext.h"



namespace android {

namespace uirenderer {



DisplayList::DisplayList()

        : projectionReceiveIndex(-1)

        , stdAllocator(allocator)

        , chunks(stdAllocator)

        , ops(stdAllocator)

        , children(stdAllocator)

        , bitmapResources(stdAllocator)

        , pathResources(stdAllocator)

        , patchResources(stdAllocator)

        , paints(stdAllocator)

        , regions(stdAllocator)

        , referenceHolders(stdAllocator)

        , functors(stdAllocator)

        , vectorDrawables(stdAllocator) {}



DisplayList::~DisplayList() {

    cleanupResources();

}



void DisplayList::cleanupResources() {

    if (CC_UNLIKELY(patchResources.size())) {

        ResourceCache& resourceCache = ResourceCache::getInstance();

        resourceCache.lock();



        for (size_t i = 0; i < patchResources.size(); i++) {

            resourceCache.decrementRefcountLocked(patchResources[i]);

        }



        resourceCache.unlock();

    }



    for (size_t i = 0; i < pathResources.size(); i++) {

        const SkPath* path = pathResources[i];

        delete path;

    }



    for (auto& iter : functors) {

        if (iter.listener) {

            iter.listener->onGlFunctorReleased(iter.functor);

        }

    }



    patchResources.clear();

    pathResources.clear();

    paints.clear();

    regions.clear();

}



size_t DisplayList::addChild(NodeOpType* op) {

    referenceHolders.push_back(op->renderNode);

    size_t index = children.size();

    children.push_back(op);

    return index;

}



void DisplayList::syncContents() {

    for (auto& iter : functors) {

        (*iter.functor)(DrawGlInfo::kModeSync, nullptr);

    }

    for (auto& vectorDrawable : vectorDrawables) {

        vectorDrawable->syncProperties();

    }

}



void DisplayList::updateChildren(std::function<void(RenderNode*)> updateFn) {

    for (auto&& child : children) {

        updateFn(child->renderNode);

    }

}



bool DisplayList::prepareListAndChildren(

        TreeObserver& observer, TreeInfo& info, bool functorsNeedLayer,

        std::function<void(RenderNode*, TreeObserver&, TreeInfo&, bool)> childFn) {

    info.prepareTextures = info.canvasContext.pinImages(bitmapResources);



    for (auto&& op : children) {

        RenderNode* childNode = op->renderNode;

        info.damageAccumulator->pushTransform(&op->localMatrix);

        bool childFunctorsNeedLayer =

                functorsNeedLayer;  // TODO! || op->mRecordedWithPotentialStencilClip;

        childFn(childNode, observer, info, childFunctorsNeedLayer);

        info.damageAccumulator->popTransform();

    }



    bool isDirty = false;

    for (auto& vectorDrawable : vectorDrawables) {

        // If any vector drawable in the display list needs update, damage the node.

        if (vectorDrawable->isDirty()) {

            isDirty = true;

        }

        vectorDrawable->setPropertyChangeWillBeConsumed(true);

    }

    return isDirty;

}



void DisplayList::output(std::ostream& output, uint32_t level) {

    for (auto&& op : getOps()) {

        OpDumper::dump(*op, output, level + 1);

        if (op->opId == RecordedOpId::RenderNodeOp) {

            auto rnOp = reinterpret_cast<const RenderNodeOp*>(op);

            rnOp->renderNode->output(output, level + 1);

        } else {

            output << std::endl;

        }

    }

}



};  // namespace uirenderer

};  // namespace android

libs/hwui/DisplayList.h

+2 −131
Original line number Diff line number Diff line
@@ -16,149 +16,20 @@ 


#pragma once



#include <SkCamera.h>

#include <SkDrawable.h>

#include <SkMatrix.h>



#include <private/hwui/DrawGlInfo.h>



#include <utils/KeyedVector.h>

#include <utils/LinearAllocator.h>

#include <utils/RefBase.h>

#include <utils/SortedVector.h>

#include <utils/String8.h>



#include <cutils/compiler.h>



#include <androidfw/ResourceTypes.h>



#include "CanvasProperty.h"

#include "Debug.h"

#include "GlFunctorLifecycleListener.h"

#include "Matrix.h"

#include "RenderProperties.h"

#include "TreeInfo.h"

#include "hwui/Bitmap.h"



#include <vector>



class SkBitmap;

class SkPaint;

class SkPath;

class SkRegion;

#include "pipeline/skia/SkiaDisplayList.h"



namespace android {

namespace uirenderer {



struct ClipBase;

class Rect;

class Layer;



struct RecordedOp;

struct RenderNodeOp;



typedef RecordedOp BaseOpType;

typedef RenderNodeOp NodeOpType;



namespace VectorDrawable {

class Tree;

};

typedef uirenderer::VectorDrawable::Tree VectorDrawableRoot;



struct FunctorContainer {

    Functor* functor;

    GlFunctorLifecycleListener* listener;

};



/**

 * Data structure that holds the list of commands used in display list stream

 */

class DisplayList {

    friend class RecordingCanvas;



public:

    struct Chunk {

        // range of included ops in DisplayList::ops()

        size_t beginOpIndex;

        size_t endOpIndex;



        // range of included children in DisplayList::children()

        size_t beginChildIndex;

        size_t endChildIndex;



        // whether children with non-zero Z in the chunk should be reordered

        bool reorderChildren;



        // clip at the beginning of a reorder section, applied to reordered children

        const ClipBase* reorderClip;

    };



    DisplayList();

    virtual ~DisplayList();



    // index of DisplayListOp restore, after which projected descendants should be drawn

    int projectionReceiveIndex;



    const LsaVector<Chunk>& getChunks() const { return chunks; }

    const LsaVector<BaseOpType*>& getOps() const { return ops; }



    const LsaVector<NodeOpType*>& getChildren() const { return children; }



    const LsaVector<sk_sp<Bitmap>>& getBitmapResources() const { return bitmapResources; }



    size_t addChild(NodeOpType* childOp);



    void ref(VirtualLightRefBase* prop) { referenceHolders.push_back(prop); }



    size_t getUsedSize() { return allocator.usedSize(); }



    virtual bool isEmpty() const { return ops.empty(); }

    virtual bool hasFunctor() const { return !functors.empty(); }

    virtual bool hasVectorDrawables() const { return !vectorDrawables.empty(); }

    virtual bool isSkiaDL() const { return false; }

    virtual bool reuseDisplayList(RenderNode* node, renderthread::CanvasContext* context) {

        return false;

    }



    virtual void syncContents();

    virtual void updateChildren(std::function<void(RenderNode*)> updateFn);

    virtual bool prepareListAndChildren(

            TreeObserver& observer, TreeInfo& info, bool functorsNeedLayer,

            std::function<void(RenderNode*, TreeObserver&, TreeInfo&, bool)> childFn);



    virtual void output(std::ostream& output, uint32_t level);



protected:

    // allocator into which all ops and LsaVector arrays allocated

    LinearAllocator allocator;

    LinearStdAllocator<void*> stdAllocator;



private:

    LsaVector<Chunk> chunks;

    LsaVector<BaseOpType*> ops;



    // list of Ops referring to RenderNode children for quick, non-drawing traversal

    LsaVector<NodeOpType*> children;



    // Resources - Skia objects + 9 patches referred to by this DisplayList

    LsaVector<sk_sp<Bitmap>> bitmapResources;

    LsaVector<const SkPath*> pathResources;

    LsaVector<const Res_png_9patch*> patchResources;

    LsaVector<std::unique_ptr<const SkPaint>> paints;

    LsaVector<std::unique_ptr<const SkRegion>> regions;

    LsaVector<sp<VirtualLightRefBase>> referenceHolders;



    // List of functors

    LsaVector<FunctorContainer> functors;



    // List of VectorDrawables that need to be notified of pushStaging. Note that this list gets

    // nothing

    // but a callback during sync DisplayList, unlike the list of functors defined above, which

    // gets special treatment exclusive for webview.

    LsaVector<VectorDrawableRoot*> vectorDrawables;



    void cleanupResources();

};

using DisplayList = skiapipeline::SkiaDisplayList;



};  // namespace uirenderer

};  // namespace android