blob: a273230cc8788434e10382436f983b87a1579f0d [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
Ady Abraham63a3e592021-01-06 10:47:15 -080048 bool isBufferDue(nsecs_t /*expectedPresentTime*/) const override { return true; }
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 }
Marissa Wall61c58622018-07-18 10:12:20 -070053
Marissa Wall61c58622018-07-18 10:12:20 -070054 Region getActiveTransparentRegion(const Layer::State& s) const override {
55 return s.transparentRegionHint;
56 }
57 Rect getCrop(const Layer::State& s) const;
Marissa Wall61c58622018-07-18 10:12:20 -070058
Lloyd Pique0449b0f2018-12-20 16:23:45 -080059 bool setTransform(uint32_t transform) override;
60 bool setTransformToDisplayInverse(bool transformToDisplayInverse) override;
61 bool setCrop(const Rect& crop) override;
Alec Mouria90a5702021-04-16 16:36:21 +000062 bool setBuffer(const std::shared_ptr<renderengine::ExternalTexture>& buffer,
63 const sp<Fence>& acquireFence, nsecs_t postTime, nsecs_t desiredPresentTime,
64 bool isAutoTimestamp, const client_cache_t& clientCacheId, uint64_t frameNumber,
Vishnu Nair1506b182021-02-22 14:35:15 -080065 std::optional<nsecs_t> dequeueTime, const FrameTimelineInfo& info,
66 const sp<ITransactionCompletedListener>& transactionListener) override;
Lloyd Pique0449b0f2018-12-20 16:23:45 -080067 bool setAcquireFence(const sp<Fence>& fence) override;
68 bool setDataspace(ui::Dataspace dataspace) override;
69 bool setHdrMetadata(const HdrMetadata& hdrMetadata) override;
70 bool setSurfaceDamageRegion(const Region& surfaceDamage) override;
71 bool setApi(int32_t api) override;
72 bool setSidebandStream(const sp<NativeHandle>& sidebandStream) override;
73 bool setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& handles) override;
Valerie Hau871d6352020-01-29 08:44:02 -080074 bool addFrameEvent(const sp<Fence>& acquireFence, nsecs_t postedTime,
75 nsecs_t requestedPresentTime) override;
Chavi Weingartena5aedbd2021-04-09 13:37:33 +000076 bool setPosition(float /*x*/, float /*y*/) override;
77 bool setMatrix(const layer_state_t::matrix22_t& /*matrix*/,
78 bool /*allowNonRectPreservingTransforms*/);
Marissa Wall61c58622018-07-18 10:12:20 -070079
Marissa Wall61c58622018-07-18 10:12:20 -070080 // Override to ignore legacy layer state properties that are not used by BufferStateLayer
Marissa Wall861616d2018-10-22 12:52:23 -070081 bool setSize(uint32_t /*w*/, uint32_t /*h*/) override { return false; }
Marissa Wall861616d2018-10-22 12:52:23 -070082 bool setTransparentRegionHint(const Region& transparent) override;
Marissa Wall861616d2018-10-22 12:52:23 -070083
Lloyd Pique0449b0f2018-12-20 16:23:45 -080084 Rect getBufferSize(const State& s) const override;
Vishnu Nair4351ad52019-02-11 14:13:02 -080085 FloatRect computeSourceBounds(const FloatRect& parentBounds) const override;
Vishnu Naircf26a0a2020-11-13 12:56:20 -080086 void setAutoRefresh(bool autoRefresh) override;
Valerie Haubc6ddb12019-03-08 11:10:15 -080087
chaviwf3f40fe2021-04-27 15:54:02 -050088 bool setBufferCrop(const Rect& bufferCrop) override;
89
Marissa Wall61c58622018-07-18 10:12:20 -070090 // -----------------------------------------------------------------------
91
92 // -----------------------------------------------------------------------
93 // Interface implementation for BufferLayer
94 // -----------------------------------------------------------------------
Lloyd Pique0449b0f2018-12-20 16:23:45 -080095 bool fenceHasSignaled() const override;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -070096 bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;
Valerie Hau871d6352020-01-29 08:44:02 -080097 bool onPreComposition(nsecs_t refreshStartTime) override;
Robert Carr916b0362020-10-06 13:53:03 -070098 uint32_t getEffectiveScalingMode() const override;
Marissa Wall61c58622018-07-18 10:12:20 -070099
Robert Carr7121caf2020-12-15 13:07:32 -0800100 // See mPendingBufferTransactions
Robert Carr7121caf2020-12-15 13:07:32 -0800101 void decrementPendingBufferCount();
Alec Mouria90a5702021-04-16 16:36:21 +0000102 void bufferMayChange(const sp<GraphicBuffer>& newBuffer) override;
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800103 std::atomic<int32_t>* getPendingBufferCounter() override { return &mPendingBufferTransactions; }
104 std::string getPendingBufferCounterName() override { return mBlastTransactionName; }
Robert Carr7121caf2020-12-15 13:07:32 -0800105
Robert Carr6a5dc1f2021-03-11 12:36:40 -0800106 bool shouldPresentNow(nsecs_t /*expectedPresentTime*/) const override { return true; }
107
chaviw4244e032019-09-04 11:27:49 -0700108protected:
109 void gatherBufferInfo() override;
Robert Carrfe1209c2020-02-11 12:25:35 -0800110 uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100111 void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame);
chaviw39d01472021-04-08 14:26:24 -0500112 ui::Transform getInputTransform() const override;
113 Rect getInputBounds() const override;
Marissa Wall61c58622018-07-18 10:12:20 -0700114
chaviw4244e032019-09-04 11:27:49 -0700115private:
Peiyong Linf243e5e2020-08-22 17:40:59 -0700116 friend class SlotGenerationTest;
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000117 friend class TransactionFrameTracerTest;
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000118 friend class TransactionSurfaceFrameTest;
119
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800120 inline void tracePendingBufferCount(int32_t pendingBuffers);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700121
Valerie Haubf784642020-01-29 07:25:23 -0800122 bool updateFrameEventHistory(const sp<Fence>& acquireFence, nsecs_t postedTime,
123 nsecs_t requestedPresentTime);
124
Robert Carr8d958532020-11-10 14:09:16 -0800125 status_t addReleaseFence(const sp<CallbackHandle>& ch, const sp<Fence>& releaseFence);
126
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700127 uint64_t getFrameNumber(nsecs_t expectedPresentTime) const override;
Marissa Wall61c58622018-07-18 10:12:20 -0700128
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800129 bool latchSidebandStream(bool& recomputeVisibleRegions) override;
Marissa Wall61c58622018-07-18 10:12:20 -0700130
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800131 bool hasFrameUpdate() const override;
Marissa Wall61c58622018-07-18 10:12:20 -0700132
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700133 status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
134 nsecs_t expectedPresentTime) override;
Marissa Wall61c58622018-07-18 10:12:20 -0700135
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800136 status_t updateActiveBuffer() override;
Marissa Wall61c58622018-07-18 10:12:20 -0700137 status_t updateFrameNumber(nsecs_t latchTime) override;
138
chaviwb4c6e582019-08-16 14:35:07 -0700139 sp<Layer> createClone() override;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700140
chaviw4244e032019-09-04 11:27:49 -0700141 // Crop that applies to the buffer
Vishnu Nair5cc9ac02021-04-19 13:23:38 -0700142 Rect computeBufferCrop(const State& s);
chaviw4244e032019-09-04 11:27:49 -0700143
Marissa Walle2ffb422018-10-12 11:33:52 -0700144 bool willPresentCurrentTransaction() const;
Marissa Wall61c58622018-07-18 10:12:20 -0700145
Vishnu Naire7f79c52020-10-29 14:45:03 -0700146 bool bufferNeedsFiltering() const override;
147
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700148 static const std::array<float, 16> IDENTITY_MATRIX;
149
Peiyong Lin833074a2018-08-28 11:53:54 -0700150 std::unique_ptr<renderengine::Image> mTextureImage;
Marissa Wall61c58622018-07-18 10:12:20 -0700151
Valerie Hauda032562020-01-22 12:22:57 -0800152 mutable uint64_t mFrameNumber{0};
Valerie Hau2f54d642020-01-22 09:37:03 -0800153 uint64_t mFrameCounter{0};
Marissa Wall61c58622018-07-18 10:12:20 -0700154
Marissa Wallfda30bb2018-10-12 11:34:28 -0700155 sp<Fence> mPreviousReleaseFence;
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700156 uint64_t mPreviousBufferId = 0;
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700157 uint64_t mPreviousReleasedFrameNumber = 0;
Marissa Wallfda30bb2018-10-12 11:34:28 -0700158
Marissa Wallfda30bb2018-10-12 11:34:28 -0700159 bool mReleasePreviousBuffer = false;
Vishnu Nair1506b182021-02-22 14:35:15 -0800160
161 // Stores the last set acquire fence signal time used to populate the callback handle's acquire
162 // time.
Marissa Wallfda30bb2018-10-12 11:34:28 -0700163 nsecs_t mCallbackHandleAcquireTime = -1;
Marissa Wall024a1912018-08-13 13:55:35 -0700164
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100165 std::deque<std::shared_ptr<android::frametimeline::SurfaceFrame>> mPendingJankClassifications;
Adithya Srinivasand17c7da2021-03-05 20:43:32 +0000166 // An upper bound on the number of SurfaceFrames in the pending classifications deque.
167 static constexpr int kPendingClassificationMaxSurfaceFrames = 25;
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100168
Robert Carr7121caf2020-12-15 13:07:32 -0800169 const std::string mBlastTransactionName{"BufferTX - " + mName};
170 // This integer is incremented everytime a buffer arrives at the server for this layer,
171 // and decremented when a buffer is dropped or latched. When changed the integer is exported
172 // to systrace with ATRACE_INT and mBlastTransactionName. This way when debugging perf it is
173 // possible to see when a buffer arrived at the server, and in which frame it latched.
174 //
175 // You can understand the trace this way:
176 // - If the integer increases, a buffer arrived at the server.
177 // - If the integer decreases in latchBuffer, that buffer was latched
178 // - If the integer decreases in setBuffer or doTransaction, a buffer was dropped
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800179 std::atomic<int32_t> mPendingBufferTransactions{0};
Robert Carr7121caf2020-12-15 13:07:32 -0800180
Marissa Wall61c58622018-07-18 10:12:20 -0700181 // TODO(marissaw): support sticky transform for LEGACY camera mode
Marissa Wall947d34e2019-03-29 14:03:53 -0700182
183 class HwcSlotGenerator : public ClientCache::ErasedRecipient {
184 public:
185 HwcSlotGenerator() {
186 for (uint32_t i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
187 mFreeHwcCacheSlots.push(i);
188 }
189 }
190
191 void bufferErased(const client_cache_t& clientCacheId);
192
193 uint32_t getHwcCacheSlot(const client_cache_t& clientCacheId);
194
195 private:
Valerie Hau64499682019-04-10 11:04:29 -0700196 friend class SlotGenerationTest;
Marissa Wall947d34e2019-03-29 14:03:53 -0700197 uint32_t addCachedBuffer(const client_cache_t& clientCacheId) REQUIRES(mMutex);
198 uint32_t getFreeHwcCacheSlot() REQUIRES(mMutex);
199 void evictLeastRecentlyUsed() REQUIRES(mMutex);
200 void eraseBufferLocked(const client_cache_t& clientCacheId) REQUIRES(mMutex);
201
202 struct CachedBufferHash {
203 std::size_t operator()(const client_cache_t& clientCacheId) const {
204 return std::hash<uint64_t>{}(clientCacheId.id);
205 }
206 };
207
208 std::mutex mMutex;
209
210 std::unordered_map<client_cache_t,
211 std::pair<uint32_t /*HwcCacheSlot*/, uint32_t /*counter*/>,
212 CachedBufferHash>
213 mCachedBuffers GUARDED_BY(mMutex);
214 std::stack<uint32_t /*HwcCacheSlot*/> mFreeHwcCacheSlots GUARDED_BY(mMutex);
215
216 // The cache increments this counter value when a slot is updated or used.
217 // Used to track the least recently-used buffer
218 uint64_t mCounter = 0;
219 };
220
221 sp<HwcSlotGenerator> mHwcSlotGenerator;
Marissa Wall61c58622018-07-18 10:12:20 -0700222};
223
224} // namespace android