blob: 4773286e44a278d6e7b7cef6a43c8dbf82b1fa25 [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,
Vishnu Nair6b7c5c92020-09-29 17:27:05 -070073 nsecs_t desiredPresentTime, const client_cache_t& clientCacheId,
74 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;
Valerie Haubc6ddb12019-03-08 11:10:15 -0800103
Marissa Wall61c58622018-07-18 10:12:20 -0700104 // -----------------------------------------------------------------------
105
106 // -----------------------------------------------------------------------
107 // Interface implementation for BufferLayer
108 // -----------------------------------------------------------------------
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800109 bool fenceHasSignaled() const override;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700110 bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;
Valerie Hau871d6352020-01-29 08:44:02 -0800111 bool onPreComposition(nsecs_t refreshStartTime) override;
Robert Carr916b0362020-10-06 13:53:03 -0700112 uint32_t getEffectiveScalingMode() const override;
Marissa Wall61c58622018-07-18 10:12:20 -0700113
chaviw4244e032019-09-04 11:27:49 -0700114protected:
115 void gatherBufferInfo() override;
Robert Carrfe1209c2020-02-11 12:25:35 -0800116 uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;
Marissa Wall61c58622018-07-18 10:12:20 -0700117
chaviw4244e032019-09-04 11:27:49 -0700118private:
Peiyong Linf243e5e2020-08-22 17:40:59 -0700119 friend class SlotGenerationTest;
120
Valerie Haubf784642020-01-29 07:25:23 -0800121 bool updateFrameEventHistory(const sp<Fence>& acquireFence, nsecs_t postedTime,
122 nsecs_t requestedPresentTime);
123
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700124 uint64_t getFrameNumber(nsecs_t expectedPresentTime) const override;
Marissa Wall61c58622018-07-18 10:12:20 -0700125
126 bool getAutoRefresh() const override;
127 bool getSidebandStreamChanged() const override;
128
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
142 Rect computeCrop(const State& s);
143
Marissa Walle2ffb422018-10-12 11:33:52 -0700144 bool willPresentCurrentTransaction() const;
Marissa Wall61c58622018-07-18 10:12:20 -0700145
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700146 static const std::array<float, 16> IDENTITY_MATRIX;
147
Peiyong Lin833074a2018-08-28 11:53:54 -0700148 std::unique_ptr<renderengine::Image> mTextureImage;
Marissa Wall61c58622018-07-18 10:12:20 -0700149
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700150 std::atomic<bool> mSidebandStreamChanged{false};
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
Lloyd Piquef5275482019-01-29 18:42:42 -0800159 mutable bool mCurrentStateModified = false;
Marissa Wallfda30bb2018-10-12 11:34:28 -0700160 bool mReleasePreviousBuffer = false;
161 nsecs_t mCallbackHandleAcquireTime = -1;
Marissa Wall024a1912018-08-13 13:55:35 -0700162
Marissa Wall61c58622018-07-18 10:12:20 -0700163 // TODO(marissaw): support sticky transform for LEGACY camera mode
Marissa Wall947d34e2019-03-29 14:03:53 -0700164
165 class HwcSlotGenerator : public ClientCache::ErasedRecipient {
166 public:
167 HwcSlotGenerator() {
168 for (uint32_t i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
169 mFreeHwcCacheSlots.push(i);
170 }
171 }
172
173 void bufferErased(const client_cache_t& clientCacheId);
174
175 uint32_t getHwcCacheSlot(const client_cache_t& clientCacheId);
176
177 private:
Valerie Hau64499682019-04-10 11:04:29 -0700178 friend class SlotGenerationTest;
Marissa Wall947d34e2019-03-29 14:03:53 -0700179 uint32_t addCachedBuffer(const client_cache_t& clientCacheId) REQUIRES(mMutex);
180 uint32_t getFreeHwcCacheSlot() REQUIRES(mMutex);
181 void evictLeastRecentlyUsed() REQUIRES(mMutex);
182 void eraseBufferLocked(const client_cache_t& clientCacheId) REQUIRES(mMutex);
183
184 struct CachedBufferHash {
185 std::size_t operator()(const client_cache_t& clientCacheId) const {
186 return std::hash<uint64_t>{}(clientCacheId.id);
187 }
188 };
189
190 std::mutex mMutex;
191
192 std::unordered_map<client_cache_t,
193 std::pair<uint32_t /*HwcCacheSlot*/, uint32_t /*counter*/>,
194 CachedBufferHash>
195 mCachedBuffers GUARDED_BY(mMutex);
196 std::stack<uint32_t /*HwcCacheSlot*/> mFreeHwcCacheSlots GUARDED_BY(mMutex);
197
198 // The cache increments this counter value when a slot is updated or used.
199 // Used to track the least recently-used buffer
200 uint64_t mCounter = 0;
201 };
202
203 sp<HwcSlotGenerator> mHwcSlotGenerator;
Marissa Wall61c58622018-07-18 10:12:20 -0700204};
205
206} // namespace android