Merge "Support skipping CachedSet rendering based on invalidate() proximity" into sc-dev

    // The earliest time to send the present command to the HAL

    std::chrono::steady_clock::time_point earliestPresentTime;

    // The predicted next invalidation time

    std::optional<std::chrono::steady_clock::time_point> nextInvalidateTime;

};

} // namespace android::compositionengine

    virtual std::optional<base::unique_fd> composeSurfaces(

            const Region&, const compositionengine::CompositionRefreshArgs& refreshArgs) = 0;

    virtual void postFramebuffer() = 0;

    virtual void renderCachedSets() = 0;

    virtual void renderCachedSets(const CompositionRefreshArgs&) = 0;

    virtual void chooseCompositionStrategy() = 0;

    virtual bool getSkipColorTransform() const = 0;

    virtual FrameFences presentAndGetFrameFences() = 0;

    std::optional<base::unique_fd> composeSurfaces(

            const Region&, const compositionengine::CompositionRefreshArgs& refreshArgs) override;

    void postFramebuffer() override;

    void renderCachedSets() override;

    void renderCachedSets(const CompositionRefreshArgs&) override;

    void cacheClientCompositionRequests(uint32_t) override;

    // Testing

        mDrawFence = nullptr;

        mBlurLayer = nullptr;

        mHolePunchLayer = nullptr;

        mSkipCount = 0;

        mLayers.insert(mLayers.end(), other.mLayers.cbegin(), other.mLayers.cend());

        Region boundingRegion;

        mVisibleRegion.orSelf(other.mVisibleRegion);

    }

    void incrementAge() { ++mAge; }

    void incrementSkipCount() { mSkipCount++; }

    size_t getSkipCount() { return mSkipCount; }

    // Renders the cached set with the supplied output composition state.

    void render(renderengine::RenderEngine& re, TexturePool& texturePool,

    Rect mBounds = Rect::EMPTY_RECT;

    Region mVisibleRegion;

    size_t mAge = 0;

    size_t mSkipCount = 0;

    // TODO(b/190411067): This is a shared pointer only because CachedSets are copied into different

    // containers in the Flattener. Logically this should have unique ownership otherwise.

#include <compositionengine/impl/planner/CachedSet.h>

#include <compositionengine/impl/planner/LayerState.h>

#include <chrono>

#include <numeric>

#include <vector>

class Flattener {

public:

    Flattener(renderengine::RenderEngine& renderEngine, bool enableHolePunch = false);

    struct CachedSetRenderSchedulingTunables {

        // This default assumes that rendering a cached set takes about 3ms. That time is then cut

        // in half - the next frame using the cached set would have the same workload, meaning that

        // composition cost is the same. This is best illustrated with the following example:

        //

        // Suppose we're at a 120hz cadence so SurfaceFlinger is budgeted 8.3ms per-frame. If

        // renderCachedSets costs 3ms, then two consecutive frames have timings:

        //

        // First frame: Start at 0ms, end at 6.8ms.

        // renderCachedSets: Start at 6.8ms, end at 9.8ms.

        // Second frame: Start at 9.8ms, end at 16.6ms.

        //

        // Now the second frame won't render a cached set afterwards, but the first frame didn't

        // really steal time from the second frame.

        static const constexpr std::chrono::nanoseconds kDefaultCachedSetRenderDuration = 1500us;

        static const constexpr size_t kDefaultMaxDeferRenderAttempts = 240;

        // Duration allocated for rendering a cached set. If we don't have enough time for rendering

        // a cached set, then rendering is deferred to another frame.

        const std::chrono::nanoseconds cachedSetRenderDuration;

        // Maximum of times that we defer rendering a cached set. If we defer rendering a cached set

        // too many times, then render it anyways so that future frames would benefit from the

        // flattened cached set.

        const size_t maxDeferRenderAttempts;

    };

    Flattener(renderengine::RenderEngine& renderEngine, bool enableHolePunch = false,

              std::optional<CachedSetRenderSchedulingTunables> cachedSetRenderSchedulingTunables =

                      std::nullopt);

    void setDisplaySize(ui::Size size) {

        mDisplaySize = size;

                                std::chrono::steady_clock::time_point now);

    // Renders the newest cached sets with the supplied output composition state

    void renderCachedSets(const OutputCompositionState& outputState);

    void renderCachedSets(const OutputCompositionState& outputState,

                          std::optional<std::chrono::steady_clock::time_point> renderDeadline);

    void dump(std::string& result) const;

    void dumpLayers(std::string& result) const;

    const std::optional<CachedSet>& getNewCachedSetForTesting() const { return mNewCachedSet; }

protected:

    std::optional<CachedSet> mNewCachedSet;

private:

    size_t calculateDisplayCost(const std::vector<const LayerState*>& layers) const;

    renderengine::RenderEngine& mRenderEngine;

    const bool mEnableHolePunch;

    const std::optional<CachedSetRenderSchedulingTunables> mCachedSetRenderSchedulingTunables;

    TexturePool mTexturePool;

protected:

    // mNewCachedSet must be destroyed before mTexturePool is.

    std::optional<CachedSet> mNewCachedSet;

private:

    ui::Size mDisplaySize;

    NonBufferHash mCurrentGeometry;