blob: 734f647b01e0f6d104a18d3eacfe86c588fcc4a2 [file] [log] [blame]
Marissa Wall61c58622018-07-18 10:12:20 -07001/*
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
Marissa Wall61c58622018-07-18 10:12:20 -070019#include "BufferLayer.h"
20#include "Layer.h"
21
Peiyong Lincbc184f2018-08-22 13:24:10 -070022#include <renderengine/Image.h>
23#include <renderengine/RenderEngine.h>
Marissa Wall61c58622018-07-18 10:12:20 -070024#include <system/window.h>
25#include <utils/String8.h>
26
Marissa Wall947d34e2019-03-29 14:03:53 -070027#include <stack>
28
Marissa Wall61c58622018-07-18 10:12:20 -070029namespace android {
30
Valerie Hau64499682019-04-10 11:04:29 -070031class SlotGenerationTest;
32
Marissa Wall61c58622018-07-18 10:12:20 -070033class BufferStateLayer : public BufferLayer {
34public:
Lloyd Pique42ab75e2018-09-12 20:46:03 -070035 explicit BufferStateLayer(const LayerCreationArgs&);
Marissa Wall61c58622018-07-18 10:12:20 -070036
Alec Mouri4545a8a2019-08-08 20:05:32 -070037 ~BufferStateLayer() override;
38
Peiyong Linf243e5e2020-08-22 17:40:59 -070039 // Implements Layer.
chaviw8a01fa42019-08-19 12:39:31 -070040 const char* getType() const override { return "BufferStateLayer"; }
41
Marissa Wall61c58622018-07-18 10:12:20 -070042 void onLayerDisplayed(const sp<Fence>& releaseFence) override;
Marissa Wall61c58622018-07-18 10:12:20 -070043 void releasePendingBuffer(nsecs_t dequeueReadyTime) override;
44
Valerie Hau871d6352020-01-29 08:44:02 -080045 void finalizeFrameEventHistory(const std::shared_ptr<FenceTime>& glDoneFence,
46 const CompositorTiming& compositorTiming) override;
47
Ana Krulec010d2192018-10-08 06:29:54 -070048 bool shouldPresentNow(nsecs_t expectedPresentTime) const override;
Marissa Wall61c58622018-07-18 10:12:20 -070049
Marissa Wall61c58622018-07-18 10:12:20 -070050 uint32_t doTransactionResize(uint32_t flags, Layer::State* /*stateToCommit*/) override {
51 return flags;
52 }
Valerie Hau3282b3c2020-02-03 15:37:27 -080053 /*TODO:vhau return to using BufferStateLayer override once WM
54 * has removed deferred transactions!
55 void pushPendingState() override;*/
Lloyd Pique0449b0f2018-12-20 16:23:45 -080056 bool applyPendingStates(Layer::State* stateToCommit) override;
Marissa Wall61c58622018-07-18 10:12:20 -070057
58 uint32_t getActiveWidth(const Layer::State& s) const override { return s.active.w; }
59 uint32_t getActiveHeight(const Layer::State& s) const override { return s.active.h; }
Peiyong Linefefaac2018-08-17 12:27:51 -070060 ui::Transform getActiveTransform(const Layer::State& s) const override {
Marissa Wall61c58622018-07-18 10:12:20 -070061 return s.active.transform;
62 }
63 Region getActiveTransparentRegion(const Layer::State& s) const override {
64 return s.transparentRegionHint;
65 }
66 Rect getCrop(const Layer::State& s) const;
Marissa Wall61c58622018-07-18 10:12:20 -070067
Lloyd Pique0449b0f2018-12-20 16:23:45 -080068 bool setTransform(uint32_t transform) override;
69 bool setTransformToDisplayInverse(bool transformToDisplayInverse) override;
70 bool setCrop(const Rect& crop) override;
71 bool setFrame(const Rect& frame) override;
Valerie Haubf784642020-01-29 07:25:23 -080072 bool setBuffer(const sp<GraphicBuffer>& buffer, const sp<Fence>& acquireFence, nsecs_t postTime,
Ady Abrahamf0c56492020-12-17 18:04:15 -080073 nsecs_t desiredPresentTime, bool isAutoTimestamp,
74 const client_cache_t& clientCacheId, uint64_t frameNumber) override;
Lloyd Pique0449b0f2018-12-20 16:23:45 -080075 bool setAcquireFence(const sp<Fence>& fence) override;
76 bool setDataspace(ui::Dataspace dataspace) override;
77 bool setHdrMetadata(const HdrMetadata& hdrMetadata) override;
78 bool setSurfaceDamageRegion(const Region& surfaceDamage) override;
79 bool setApi(int32_t api) override;
80 bool setSidebandStream(const sp<NativeHandle>& sidebandStream) override;
81 bool setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& handles) override;
Valerie Hau7618b232020-01-09 16:03:08 -080082 void forceSendCallbacks() override;
Valerie Hau871d6352020-01-29 08:44:02 -080083 bool addFrameEvent(const sp<Fence>& acquireFence, nsecs_t postedTime,
84 nsecs_t requestedPresentTime) override;
Marissa Wall61c58622018-07-18 10:12:20 -070085
Marissa Wall61c58622018-07-18 10:12:20 -070086 // Override to ignore legacy layer state properties that are not used by BufferStateLayer
Marissa Wall861616d2018-10-22 12:52:23 -070087 bool setSize(uint32_t /*w*/, uint32_t /*h*/) override { return false; }
chaviw214c89d2019-09-04 16:03:53 -070088 bool setPosition(float /*x*/, float /*y*/) override { return false; }
Marissa Wall861616d2018-10-22 12:52:23 -070089 bool setTransparentRegionHint(const Region& transparent) override;
90 bool setMatrix(const layer_state_t::matrix22_t& /*matrix*/,
91 bool /*allowNonRectPreservingTransforms*/) override {
92 return false;
93 }
chaviw214c89d2019-09-04 16:03:53 -070094 bool setCrop_legacy(const Rect& /*crop*/) override { return false; }
Marissa Wall61c58622018-07-18 10:12:20 -070095 void deferTransactionUntil_legacy(const sp<IBinder>& /*barrierHandle*/,
96 uint64_t /*frameNumber*/) override {}
97 void deferTransactionUntil_legacy(const sp<Layer>& /*barrierLayer*/,
98 uint64_t /*frameNumber*/) override {}
Marissa Wall861616d2018-10-22 12:52:23 -070099
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800100 Rect getBufferSize(const State& s) const override;
Vishnu Nair4351ad52019-02-11 14:13:02 -0800101 FloatRect computeSourceBounds(const FloatRect& parentBounds) const override;
Valerie Hau92bf5482020-02-10 09:49:08 -0800102 Layer::RoundedCornerState getRoundedCornerState() const override;
Vishnu Naircf26a0a2020-11-13 12:56:20 -0800103 void setAutoRefresh(bool autoRefresh) override;
Valerie Haubc6ddb12019-03-08 11:10:15 -0800104
Marissa Wall61c58622018-07-18 10:12:20 -0700105 // -----------------------------------------------------------------------
106
107 // -----------------------------------------------------------------------
108 // Interface implementation for BufferLayer
109 // -----------------------------------------------------------------------
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800110 bool fenceHasSignaled() const override;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700111 bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;
Valerie Hau871d6352020-01-29 08:44:02 -0800112 bool onPreComposition(nsecs_t refreshStartTime) override;
Robert Carr916b0362020-10-06 13:53:03 -0700113 uint32_t getEffectiveScalingMode() const override;
Marissa Wall61c58622018-07-18 10:12:20 -0700114
Robert Carr7121caf2020-12-15 13:07:32 -0800115 // See mPendingBufferTransactions
116 void incrementPendingBufferCount() override;
117 void decrementPendingBufferCount();
118 uint32_t doTransaction(uint32_t flags) override;
119
chaviw4244e032019-09-04 11:27:49 -0700120protected:
121 void gatherBufferInfo() override;
Robert Carrfe1209c2020-02-11 12:25:35 -0800122 uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100123 void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame);
Marissa Wall61c58622018-07-18 10:12:20 -0700124
chaviw4244e032019-09-04 11:27:49 -0700125private:
Peiyong Linf243e5e2020-08-22 17:40:59 -0700126 friend class SlotGenerationTest;
Robert Carr7121caf2020-12-15 13:07:32 -0800127 inline void tracePendingBufferCount();
Peiyong Linf243e5e2020-08-22 17:40:59 -0700128
Valerie Haubf784642020-01-29 07:25:23 -0800129 bool updateFrameEventHistory(const sp<Fence>& acquireFence, nsecs_t postedTime,
130 nsecs_t requestedPresentTime);
131
Robert Carr8d958532020-11-10 14:09:16 -0800132 status_t addReleaseFence(const sp<CallbackHandle>& ch, const sp<Fence>& releaseFence);
133
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700134 uint64_t getFrameNumber(nsecs_t expectedPresentTime) const override;
Marissa Wall61c58622018-07-18 10:12:20 -0700135
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800136 bool latchSidebandStream(bool& recomputeVisibleRegions) override;
Marissa Wall61c58622018-07-18 10:12:20 -0700137
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800138 bool hasFrameUpdate() const override;
Marissa Wall61c58622018-07-18 10:12:20 -0700139
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700140 status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
141 nsecs_t expectedPresentTime) override;
Marissa Wall61c58622018-07-18 10:12:20 -0700142
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800143 status_t updateActiveBuffer() override;
Marissa Wall61c58622018-07-18 10:12:20 -0700144 status_t updateFrameNumber(nsecs_t latchTime) override;
145
chaviwb4c6e582019-08-16 14:35:07 -0700146 sp<Layer> createClone() override;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700147
chaviw4244e032019-09-04 11:27:49 -0700148 // Crop that applies to the buffer
149 Rect computeCrop(const State& s);
150
Marissa Walle2ffb422018-10-12 11:33:52 -0700151 bool willPresentCurrentTransaction() const;
Marissa Wall61c58622018-07-18 10:12:20 -0700152
Vishnu Naire7f79c52020-10-29 14:45:03 -0700153 bool bufferNeedsFiltering() const override;
154
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700155 static const std::array<float, 16> IDENTITY_MATRIX;
156
Peiyong Lin833074a2018-08-28 11:53:54 -0700157 std::unique_ptr<renderengine::Image> mTextureImage;
Marissa Wall61c58622018-07-18 10:12:20 -0700158
Valerie Hauda032562020-01-22 12:22:57 -0800159 mutable uint64_t mFrameNumber{0};
Valerie Hau2f54d642020-01-22 09:37:03 -0800160 uint64_t mFrameCounter{0};
Marissa Wall61c58622018-07-18 10:12:20 -0700161
Marissa Wallfda30bb2018-10-12 11:34:28 -0700162 sp<Fence> mPreviousReleaseFence;
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700163 uint64_t mPreviousBufferId = 0;
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700164 uint64_t mPreviousReleasedFrameNumber = 0;
Marissa Wallfda30bb2018-10-12 11:34:28 -0700165
Lloyd Piquef5275482019-01-29 18:42:42 -0800166 mutable bool mCurrentStateModified = false;
Marissa Wallfda30bb2018-10-12 11:34:28 -0700167 bool mReleasePreviousBuffer = false;
168 nsecs_t mCallbackHandleAcquireTime = -1;
Marissa Wall024a1912018-08-13 13:55:35 -0700169
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100170 std::deque<std::shared_ptr<android::frametimeline::SurfaceFrame>> mPendingJankClassifications;
171
Robert Carr7121caf2020-12-15 13:07:32 -0800172 const std::string mBlastTransactionName{"BufferTX - " + mName};
173 // This integer is incremented everytime a buffer arrives at the server for this layer,
174 // and decremented when a buffer is dropped or latched. When changed the integer is exported
175 // to systrace with ATRACE_INT and mBlastTransactionName. This way when debugging perf it is
176 // possible to see when a buffer arrived at the server, and in which frame it latched.
177 //
178 // You can understand the trace this way:
179 // - If the integer increases, a buffer arrived at the server.
180 // - If the integer decreases in latchBuffer, that buffer was latched
181 // - If the integer decreases in setBuffer or doTransaction, a buffer was dropped
182 uint64_t mPendingBufferTransactions{0};
183
Marissa Wall61c58622018-07-18 10:12:20 -0700184 // TODO(marissaw): support sticky transform for LEGACY camera mode
Marissa Wall947d34e2019-03-29 14:03:53 -0700185
186 class HwcSlotGenerator : public ClientCache::ErasedRecipient {
187 public:
188 HwcSlotGenerator() {
189 for (uint32_t i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
190 mFreeHwcCacheSlots.push(i);
191 }
192 }
193
194 void bufferErased(const client_cache_t& clientCacheId);
195
196 uint32_t getHwcCacheSlot(const client_cache_t& clientCacheId);
197
198 private:
Valerie Hau64499682019-04-10 11:04:29 -0700199 friend class SlotGenerationTest;
Marissa Wall947d34e2019-03-29 14:03:53 -0700200 uint32_t addCachedBuffer(const client_cache_t& clientCacheId) REQUIRES(mMutex);
201 uint32_t getFreeHwcCacheSlot() REQUIRES(mMutex);
202 void evictLeastRecentlyUsed() REQUIRES(mMutex);
203 void eraseBufferLocked(const client_cache_t& clientCacheId) REQUIRES(mMutex);
204
205 struct CachedBufferHash {
206 std::size_t operator()(const client_cache_t& clientCacheId) const {
207 return std::hash<uint64_t>{}(clientCacheId.id);
208 }
209 };
210
211 std::mutex mMutex;
212
213 std::unordered_map<client_cache_t,
214 std::pair<uint32_t /*HwcCacheSlot*/, uint32_t /*counter*/>,
215 CachedBufferHash>
216 mCachedBuffers GUARDED_BY(mMutex);
217 std::stack<uint32_t /*HwcCacheSlot*/> mFreeHwcCacheSlots GUARDED_BY(mMutex);
218
219 // The cache increments this counter value when a slot is updated or used.
220 // Used to track the least recently-used buffer
221 uint64_t mCounter = 0;
222 };
223
224 sp<HwcSlotGenerator> mHwcSlotGenerator;
Marissa Wall61c58622018-07-18 10:12:20 -0700225};
226
227} // namespace android