1 /*
2  * Copyright (C) 2018 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 #pragma once
18 
19 #include "BufferLayer.h"
20 #include "Layer.h"
21 
22 #include <renderengine/Image.h>
23 #include <renderengine/RenderEngine.h>
24 #include <system/window.h>
25 #include <utils/String8.h>
26 
27 #include <stack>
28 
29 namespace android {
30 
31 class SlotGenerationTest;
32 
33 class BufferStateLayer : public BufferLayer {
34 public:
35     explicit BufferStateLayer(const LayerCreationArgs&);
36 
37     ~BufferStateLayer() override;
38 
39     // Implements Layer.
getType()40     const char* getType() const override { return "BufferStateLayer"; }
41 
42     void onLayerDisplayed(const sp<Fence>& releaseFence) override;
43     void releasePendingBuffer(nsecs_t dequeueReadyTime) override;
44 
45     void finalizeFrameEventHistory(const std::shared_ptr<FenceTime>& glDoneFence,
46                                    const CompositorTiming& compositorTiming) override;
47 
isBufferDue(nsecs_t)48     bool isBufferDue(nsecs_t /*expectedPresentTime*/) const override { return true; }
49 
getActiveTransparentRegion(const Layer::State & s)50     Region getActiveTransparentRegion(const Layer::State& s) const override {
51         return s.transparentRegionHint;
52     }
53     Rect getCrop(const Layer::State& s) const;
54 
55     bool setTransform(uint32_t transform) override;
56     bool setTransformToDisplayInverse(bool transformToDisplayInverse) override;
57     bool setCrop(const Rect& crop) override;
58     bool setBuffer(const std::shared_ptr<renderengine::ExternalTexture>& buffer,
59                    const sp<Fence>& acquireFence, nsecs_t postTime, nsecs_t desiredPresentTime,
60                    bool isAutoTimestamp, const client_cache_t& clientCacheId, uint64_t frameNumber,
61                    std::optional<nsecs_t> dequeueTime, const FrameTimelineInfo& info,
62                    const sp<ITransactionCompletedListener>& transactionListener,
63                    const sp<IBinder>& releaseBufferEndpoint) override;
64     bool setAcquireFence(const sp<Fence>& fence) override;
65     bool setDataspace(ui::Dataspace dataspace) override;
66     bool setHdrMetadata(const HdrMetadata& hdrMetadata) override;
67     bool setSurfaceDamageRegion(const Region& surfaceDamage) override;
68     bool setApi(int32_t api) override;
69     bool setSidebandStream(const sp<NativeHandle>& sidebandStream) override;
70     bool setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& handles) override;
71     bool addFrameEvent(const sp<Fence>& acquireFence, nsecs_t postedTime,
72                        nsecs_t requestedPresentTime) override;
73     bool setPosition(float /*x*/, float /*y*/) override;
74     bool setMatrix(const layer_state_t::matrix22_t& /*matrix*/,
75                    bool /*allowNonRectPreservingTransforms*/);
76 
77     // Override to ignore legacy layer state properties that are not used by BufferStateLayer
setSize(uint32_t,uint32_t)78     bool setSize(uint32_t /*w*/, uint32_t /*h*/) override { return false; }
79     bool setTransparentRegionHint(const Region& transparent) override;
80 
81     Rect getBufferSize(const State& s) const override;
82     FloatRect computeSourceBounds(const FloatRect& parentBounds) const override;
83     void setAutoRefresh(bool autoRefresh) override;
84 
85     bool setBufferCrop(const Rect& bufferCrop) override;
86     bool setDestinationFrame(const Rect& destinationFrame) override;
87     bool updateGeometry() override;
88 
89     // -----------------------------------------------------------------------
90 
91     // -----------------------------------------------------------------------
92     // Interface implementation for BufferLayer
93     // -----------------------------------------------------------------------
94     bool fenceHasSignaled() const override;
95     bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;
96     bool onPreComposition(nsecs_t refreshStartTime) override;
97     uint32_t getEffectiveScalingMode() const override;
98 
99     // See mPendingBufferTransactions
100     void decrementPendingBufferCount();
getPendingBufferCounter()101     std::atomic<int32_t>* getPendingBufferCounter() override { return &mPendingBufferTransactions; }
getPendingBufferCounterName()102     std::string getPendingBufferCounterName() override { return mBlastTransactionName; }
103 
shouldPresentNow(nsecs_t)104     bool shouldPresentNow(nsecs_t /*expectedPresentTime*/) const override { return true; }
105 
106 protected:
107     void gatherBufferInfo() override;
108     uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;
109     void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame);
110     ui::Transform getInputTransform() const override;
111     Rect getInputBounds() const override;
112 
113 private:
114     friend class SlotGenerationTest;
115     friend class TransactionFrameTracerTest;
116     friend class TransactionSurfaceFrameTest;
117 
118     inline void tracePendingBufferCount(int32_t pendingBuffers);
119 
120     bool updateFrameEventHistory(const sp<Fence>& acquireFence, nsecs_t postedTime,
121                                  nsecs_t requestedPresentTime);
122 
123     status_t addReleaseFence(const sp<CallbackHandle>& ch, const sp<Fence>& releaseFence);
124 
125     uint64_t getFrameNumber(nsecs_t expectedPresentTime) const override;
126 
127     bool latchSidebandStream(bool& recomputeVisibleRegions) override;
128 
129     bool hasFrameUpdate() const override;
130 
131     status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
132                             nsecs_t expectedPresentTime) override;
133 
134     status_t updateActiveBuffer() override;
135     status_t updateFrameNumber(nsecs_t latchTime) override;
136 
137     sp<Layer> createClone() override;
138 
139     // Crop that applies to the buffer
140     Rect computeBufferCrop(const State& s);
141 
142     bool willPresentCurrentTransaction() const;
143 
144     bool bufferNeedsFiltering() const override;
145 
146     sp<Fence> mPreviousReleaseFence;
147     ReleaseCallbackId mPreviousReleaseCallbackId = ReleaseCallbackId::INVALID_ID;
148     uint64_t mPreviousReleasedFrameNumber = 0;
149 
150     bool mReleasePreviousBuffer = false;
151 
152     // Stores the last set acquire fence signal time used to populate the callback handle's acquire
153     // time.
154     nsecs_t mCallbackHandleAcquireTime = -1;
155 
156     std::deque<std::shared_ptr<android::frametimeline::SurfaceFrame>> mPendingJankClassifications;
157     // An upper bound on the number of SurfaceFrames in the pending classifications deque.
158     static constexpr int kPendingClassificationMaxSurfaceFrames = 25;
159 
160     const std::string mBlastTransactionName{"BufferTX - " + mName};
161     // This integer is incremented everytime a buffer arrives at the server for this layer,
162     // and decremented when a buffer is dropped or latched. When changed the integer is exported
163     // to systrace with ATRACE_INT and mBlastTransactionName. This way when debugging perf it is
164     // possible to see when a buffer arrived at the server, and in which frame it latched.
165     //
166     // You can understand the trace this way:
167     //     - If the integer increases, a buffer arrived at the server.
168     //     - If the integer decreases in latchBuffer, that buffer was latched
169     //     - If the integer decreases in setBuffer or doTransaction, a buffer was dropped
170     std::atomic<int32_t> mPendingBufferTransactions{0};
171 
172     // Contains requested position and matrix updates. This will be applied if the client does
173     // not specify a destination frame.
174     ui::Transform mRequestedTransform;
175 
176     // TODO(marissaw): support sticky transform for LEGACY camera mode
177 
178     class HwcSlotGenerator : public ClientCache::ErasedRecipient {
179     public:
HwcSlotGenerator()180         HwcSlotGenerator() {
181             for (uint32_t i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
182                 mFreeHwcCacheSlots.push(i);
183             }
184         }
185 
186         void bufferErased(const client_cache_t& clientCacheId);
187 
188         uint32_t getHwcCacheSlot(const client_cache_t& clientCacheId);
189 
190     private:
191         friend class SlotGenerationTest;
192         uint32_t addCachedBuffer(const client_cache_t& clientCacheId) REQUIRES(mMutex);
193         uint32_t getFreeHwcCacheSlot() REQUIRES(mMutex);
194         void evictLeastRecentlyUsed() REQUIRES(mMutex);
195         void eraseBufferLocked(const client_cache_t& clientCacheId) REQUIRES(mMutex);
196 
197         struct CachedBufferHash {
operatorCachedBufferHash198             std::size_t operator()(const client_cache_t& clientCacheId) const {
199                 return std::hash<uint64_t>{}(clientCacheId.id);
200             }
201         };
202 
203         std::mutex mMutex;
204 
205         std::unordered_map<client_cache_t,
206                            std::pair<uint32_t /*HwcCacheSlot*/, uint32_t /*counter*/>,
207                            CachedBufferHash>
208                 mCachedBuffers GUARDED_BY(mMutex);
209         std::stack<uint32_t /*HwcCacheSlot*/> mFreeHwcCacheSlots GUARDED_BY(mMutex);
210 
211         // The cache increments this counter value when a slot is updated or used.
212         // Used to track the least recently-used buffer
213         uint64_t mCounter = 0;
214     };
215 
216     sp<HwcSlotGenerator> mHwcSlotGenerator;
217 };
218 
219 } // namespace android
220