blob: eea700cf7b561ea92ffa2f9739451686bc61ba48 [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
Sally Qi59a9f502021-10-12 18:53:23 +000042 void onLayerDisplayed(
43 std::shared_future<renderengine::RenderEngineResult> futureRenderEngineResult) override;
44
Marissa Wall61c58622018-07-18 10:12:20 -070045 void releasePendingBuffer(nsecs_t dequeueReadyTime) override;
46
Valerie Hau871d6352020-01-29 08:44:02 -080047 void finalizeFrameEventHistory(const std::shared_ptr<FenceTime>& glDoneFence,
48 const CompositorTiming& compositorTiming) override;
49
Ady Abraham63a3e592021-01-06 10:47:15 -080050 bool isBufferDue(nsecs_t /*expectedPresentTime*/) const override { return true; }
Marissa Wall61c58622018-07-18 10:12:20 -070051
Marissa Wall61c58622018-07-18 10:12:20 -070052 Region getActiveTransparentRegion(const Layer::State& s) const override {
53 return s.transparentRegionHint;
54 }
55 Rect getCrop(const Layer::State& s) const;
Marissa Wall61c58622018-07-18 10:12:20 -070056
Lloyd Pique0449b0f2018-12-20 16:23:45 -080057 bool setTransform(uint32_t transform) override;
58 bool setTransformToDisplayInverse(bool transformToDisplayInverse) override;
59 bool setCrop(const Rect& crop) override;
chaviwba4320c2021-09-15 15:20:53 -050060 bool setBuffer(const BufferData& bufferData, nsecs_t postTime, nsecs_t desiredPresentTime,
61 bool isAutoTimestamp, std::optional<nsecs_t> dequeueTime,
62 const FrameTimelineInfo& info) override;
Lloyd Pique0449b0f2018-12-20 16:23:45 -080063 bool setDataspace(ui::Dataspace dataspace) override;
64 bool setHdrMetadata(const HdrMetadata& hdrMetadata) override;
65 bool setSurfaceDamageRegion(const Region& surfaceDamage) override;
66 bool setApi(int32_t api) override;
67 bool setSidebandStream(const sp<NativeHandle>& sidebandStream) override;
Jiakai Zhanga5505cb2021-11-09 11:46:30 +000068 bool setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& handles) override;
Valerie Hau871d6352020-01-29 08:44:02 -080069 bool addFrameEvent(const sp<Fence>& acquireFence, nsecs_t postedTime,
70 nsecs_t requestedPresentTime) override;
Chavi Weingartena5aedbd2021-04-09 13:37:33 +000071 bool setPosition(float /*x*/, float /*y*/) override;
72 bool setMatrix(const layer_state_t::matrix22_t& /*matrix*/,
73 bool /*allowNonRectPreservingTransforms*/);
Marissa Wall61c58622018-07-18 10:12:20 -070074
Marissa Wall61c58622018-07-18 10:12:20 -070075 // Override to ignore legacy layer state properties that are not used by BufferStateLayer
Marissa Wall861616d2018-10-22 12:52:23 -070076 bool setSize(uint32_t /*w*/, uint32_t /*h*/) override { return false; }
Marissa Wall861616d2018-10-22 12:52:23 -070077 bool setTransparentRegionHint(const Region& transparent) override;
Marissa Wall861616d2018-10-22 12:52:23 -070078
Lloyd Pique0449b0f2018-12-20 16:23:45 -080079 Rect getBufferSize(const State& s) const override;
Vishnu Nair4351ad52019-02-11 14:13:02 -080080 FloatRect computeSourceBounds(const FloatRect& parentBounds) const override;
Vishnu Naircf26a0a2020-11-13 12:56:20 -080081 void setAutoRefresh(bool autoRefresh) override;
Valerie Haubc6ddb12019-03-08 11:10:15 -080082
chaviwf3f40fe2021-04-27 15:54:02 -050083 bool setBufferCrop(const Rect& bufferCrop) override;
Vishnu Nair6bdec7d2021-05-10 15:01:13 -070084 bool setDestinationFrame(const Rect& destinationFrame) override;
Robert Carr6a160312021-05-17 12:08:20 -070085 bool updateGeometry() override;
chaviwf3f40fe2021-04-27 15:54:02 -050086
Marissa Wall61c58622018-07-18 10:12:20 -070087 // -----------------------------------------------------------------------
88
89 // -----------------------------------------------------------------------
90 // Interface implementation for BufferLayer
91 // -----------------------------------------------------------------------
Lloyd Pique0449b0f2018-12-20 16:23:45 -080092 bool fenceHasSignaled() const override;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -070093 bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;
Valerie Hau871d6352020-01-29 08:44:02 -080094 bool onPreComposition(nsecs_t refreshStartTime) override;
Robert Carr916b0362020-10-06 13:53:03 -070095 uint32_t getEffectiveScalingMode() const override;
Marissa Wall61c58622018-07-18 10:12:20 -070096
Robert Carr7121caf2020-12-15 13:07:32 -080097 // See mPendingBufferTransactions
Robert Carr7121caf2020-12-15 13:07:32 -080098 void decrementPendingBufferCount();
Vishnu Nair8eda69e2021-02-26 10:42:10 -080099 std::atomic<int32_t>* getPendingBufferCounter() override { return &mPendingBufferTransactions; }
100 std::string getPendingBufferCounterName() override { return mBlastTransactionName; }
Robert Carr7121caf2020-12-15 13:07:32 -0800101
Robert Carr6a5dc1f2021-03-11 12:36:40 -0800102 bool shouldPresentNow(nsecs_t /*expectedPresentTime*/) const override { return true; }
103
chaviw4244e032019-09-04 11:27:49 -0700104protected:
105 void gatherBufferInfo() override;
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100106 void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame);
chaviw39d01472021-04-08 14:26:24 -0500107 ui::Transform getInputTransform() const override;
108 Rect getInputBounds() const override;
Marissa Wall61c58622018-07-18 10:12:20 -0700109
chaviw4244e032019-09-04 11:27:49 -0700110private:
Peiyong Linf243e5e2020-08-22 17:40:59 -0700111 friend class SlotGenerationTest;
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000112 friend class TransactionFrameTracerTest;
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000113 friend class TransactionSurfaceFrameTest;
114
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800115 inline void tracePendingBufferCount(int32_t pendingBuffers);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700116
Valerie Haubf784642020-01-29 07:25:23 -0800117 bool updateFrameEventHistory(const sp<Fence>& acquireFence, nsecs_t postedTime,
118 nsecs_t requestedPresentTime);
119
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800120 bool latchSidebandStream(bool& recomputeVisibleRegions) override;
Marissa Wall61c58622018-07-18 10:12:20 -0700121
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800122 bool hasFrameUpdate() const override;
Marissa Wall61c58622018-07-18 10:12:20 -0700123
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700124 status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
125 nsecs_t expectedPresentTime) override;
Marissa Wall61c58622018-07-18 10:12:20 -0700126
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800127 status_t updateActiveBuffer() override;
Marissa Wall61c58622018-07-18 10:12:20 -0700128 status_t updateFrameNumber(nsecs_t latchTime) override;
129
chaviwb4c6e582019-08-16 14:35:07 -0700130 sp<Layer> createClone() override;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700131
chaviw4244e032019-09-04 11:27:49 -0700132 // Crop that applies to the buffer
Vishnu Nair5cc9ac02021-04-19 13:23:38 -0700133 Rect computeBufferCrop(const State& s);
chaviw4244e032019-09-04 11:27:49 -0700134
Marissa Walle2ffb422018-10-12 11:33:52 -0700135 bool willPresentCurrentTransaction() const;
Marissa Wall61c58622018-07-18 10:12:20 -0700136
Vishnu Naire7f79c52020-10-29 14:45:03 -0700137 bool bufferNeedsFiltering() const override;
138
chaviwba4320c2021-09-15 15:20:53 -0500139 std::shared_ptr<renderengine::ExternalTexture> getBufferFromBufferData(
140 const BufferData& bufferData);
141
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700142 ReleaseCallbackId mPreviousReleaseCallbackId = ReleaseCallbackId::INVALID_ID;
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700143 uint64_t mPreviousReleasedFrameNumber = 0;
Marissa Wallfda30bb2018-10-12 11:34:28 -0700144
Marissa Wallfda30bb2018-10-12 11:34:28 -0700145 bool mReleasePreviousBuffer = false;
Vishnu Nair1506b182021-02-22 14:35:15 -0800146
147 // Stores the last set acquire fence signal time used to populate the callback handle's acquire
148 // time.
Marissa Wallfda30bb2018-10-12 11:34:28 -0700149 nsecs_t mCallbackHandleAcquireTime = -1;
Marissa Wall024a1912018-08-13 13:55:35 -0700150
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100151 std::deque<std::shared_ptr<android::frametimeline::SurfaceFrame>> mPendingJankClassifications;
Adithya Srinivasand17c7da2021-03-05 20:43:32 +0000152 // An upper bound on the number of SurfaceFrames in the pending classifications deque.
153 static constexpr int kPendingClassificationMaxSurfaceFrames = 25;
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100154
Robert Carr7121caf2020-12-15 13:07:32 -0800155 const std::string mBlastTransactionName{"BufferTX - " + mName};
156 // This integer is incremented everytime a buffer arrives at the server for this layer,
157 // and decremented when a buffer is dropped or latched. When changed the integer is exported
158 // to systrace with ATRACE_INT and mBlastTransactionName. This way when debugging perf it is
159 // possible to see when a buffer arrived at the server, and in which frame it latched.
160 //
161 // You can understand the trace this way:
162 // - If the integer increases, a buffer arrived at the server.
163 // - If the integer decreases in latchBuffer, that buffer was latched
164 // - If the integer decreases in setBuffer or doTransaction, a buffer was dropped
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800165 std::atomic<int32_t> mPendingBufferTransactions{0};
Robert Carr7121caf2020-12-15 13:07:32 -0800166
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700167 // Contains requested position and matrix updates. This will be applied if the client does
168 // not specify a destination frame.
169 ui::Transform mRequestedTransform;
170
Marissa Wall61c58622018-07-18 10:12:20 -0700171 // TODO(marissaw): support sticky transform for LEGACY camera mode
Marissa Wall947d34e2019-03-29 14:03:53 -0700172
173 class HwcSlotGenerator : public ClientCache::ErasedRecipient {
174 public:
175 HwcSlotGenerator() {
rnleeed20fa42021-08-10 18:00:03 -0700176 for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
Marissa Wall947d34e2019-03-29 14:03:53 -0700177 mFreeHwcCacheSlots.push(i);
178 }
179 }
180
181 void bufferErased(const client_cache_t& clientCacheId);
182
rnleeed20fa42021-08-10 18:00:03 -0700183 int getHwcCacheSlot(const client_cache_t& clientCacheId);
Marissa Wall947d34e2019-03-29 14:03:53 -0700184
185 private:
Valerie Hau64499682019-04-10 11:04:29 -0700186 friend class SlotGenerationTest;
rnleeed20fa42021-08-10 18:00:03 -0700187 int addCachedBuffer(const client_cache_t& clientCacheId) REQUIRES(mMutex);
188 int getFreeHwcCacheSlot() REQUIRES(mMutex);
Marissa Wall947d34e2019-03-29 14:03:53 -0700189 void evictLeastRecentlyUsed() REQUIRES(mMutex);
190 void eraseBufferLocked(const client_cache_t& clientCacheId) REQUIRES(mMutex);
191
192 struct CachedBufferHash {
193 std::size_t operator()(const client_cache_t& clientCacheId) const {
194 return std::hash<uint64_t>{}(clientCacheId.id);
195 }
196 };
197
198 std::mutex mMutex;
199
rnleeed20fa42021-08-10 18:00:03 -0700200 std::unordered_map<client_cache_t, std::pair<int /*HwcCacheSlot*/, uint64_t /*counter*/>,
Marissa Wall947d34e2019-03-29 14:03:53 -0700201 CachedBufferHash>
202 mCachedBuffers GUARDED_BY(mMutex);
rnleeed20fa42021-08-10 18:00:03 -0700203 std::stack<int /*HwcCacheSlot*/> mFreeHwcCacheSlots GUARDED_BY(mMutex);
Marissa Wall947d34e2019-03-29 14:03:53 -0700204
205 // The cache increments this counter value when a slot is updated or used.
206 // Used to track the least recently-used buffer
207 uint64_t mCounter = 0;
208 };
209
210 sp<HwcSlotGenerator> mHwcSlotGenerator;
Marissa Wall61c58622018-07-18 10:12:20 -0700211};
212
213} // namespace android