blob: dd39214aff1c94f687cfd10c86cbd008c4b26089 [file] [log] [blame]
Chia-I Wuf1405182017-11-27 11:29:21 -08001/*
2 * Copyright (C) 2010 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#ifndef ANDROID_BUFFERLAYERCONSUMER_H
18#define ANDROID_BUFFERLAYERCONSUMER_H
19
Alec Mourid7b3a8b2019-03-21 11:44:18 -070020#include <android-base/thread_annotations.h>
Chia-I Wuf1405182017-11-27 11:29:21 -080021#include <gui/BufferQueueDefs.h>
22#include <gui/ConsumerBase.h>
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -070023#include <gui/HdrMetadata.h>
Alec Mouri617752f2021-04-15 16:27:01 +000024
Chia-I Wuf1405182017-11-27 11:29:21 -080025#include <ui/FenceTime.h>
26#include <ui/GraphicBuffer.h>
Peiyong Lin34beb7a2018-03-28 11:57:12 -070027#include <ui/GraphicTypes.h>
Chia-I Wu67dcc692017-11-27 14:51:06 -080028#include <ui/Region.h>
Alec Mouri617752f2021-04-15 16:27:01 +000029
Chia-I Wuf1405182017-11-27 11:29:21 -080030#include <utils/String8.h>
31#include <utils/Vector.h>
32#include <utils/threads.h>
33
34namespace android {
35// ----------------------------------------------------------------------------
36
Chia-I Wuc75c44d2017-11-27 14:32:57 -080037class Layer;
Chia-I Wuf1405182017-11-27 11:29:21 -080038class String8;
39
Peiyong Lin833074a2018-08-28 11:53:54 -070040namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -080041class RenderEngine;
Alec Mouri617752f2021-04-15 16:27:01 +000042class Image;
Peiyong Lin833074a2018-08-28 11:53:54 -070043} // namespace renderengine
Lloyd Pique144e1162017-12-20 16:44:52 -080044
Chia-I Wuf1405182017-11-27 11:29:21 -080045/*
46 * BufferLayerConsumer consumes buffers of graphics data from a BufferQueue,
Chia-I Wu221b5922017-12-14 13:59:16 -080047 * and makes them available to RenderEngine as a texture.
Chia-I Wuf1405182017-11-27 11:29:21 -080048 *
Chia-I Wu221b5922017-12-14 13:59:16 -080049 * A typical usage pattern is to call updateTexImage() when a new frame is
50 * desired. If a new frame is available, the frame is latched. If not, the
51 * previous contents are retained. The texture is attached and updated after
52 * bindTextureImage() is called.
Chia-I Wuf1405182017-11-27 11:29:21 -080053 *
Chia-I Wu221b5922017-12-14 13:59:16 -080054 * All calls to updateTexImage must be made with RenderEngine being current.
55 * The texture is attached to the TEXTURE_EXTERNAL texture target.
Chia-I Wuf1405182017-11-27 11:29:21 -080056 */
57class BufferLayerConsumer : public ConsumerBase {
58public:
Chia-I Wuda5c7302017-11-27 14:51:06 -080059 static const status_t BUFFER_REJECTED = UNKNOWN_ERROR + 8;
60
61 class BufferRejecter {
62 friend class BufferLayerConsumer;
63 virtual bool reject(const sp<GraphicBuffer>& buf, const BufferItem& item) = 0;
64
65 protected:
66 virtual ~BufferRejecter() {}
67 };
68
Chia-I Wufd257f82017-11-27 14:51:06 -080069 struct ContentsChangedListener : public FrameAvailableListener {
70 virtual void onSidebandStreamChanged() = 0;
71 };
Chia-I Wuf1405182017-11-27 11:29:21 -080072
Chia-I Wu221b5922017-12-14 13:59:16 -080073 // BufferLayerConsumer constructs a new BufferLayerConsumer object. The
74 // tex parameter indicates the name of the RenderEngine texture to which
75 // images are to be streamed.
Peiyong Lin833074a2018-08-28 11:53:54 -070076 BufferLayerConsumer(const sp<IGraphicBufferConsumer>& bq, renderengine::RenderEngine& engine,
Lloyd Pique144e1162017-12-20 16:44:52 -080077 uint32_t tex, Layer* layer);
Chia-I Wuf1405182017-11-27 11:29:21 -080078
Chia-I Wufd257f82017-11-27 14:51:06 -080079 // Sets the contents changed listener. This should be used instead of
80 // ConsumerBase::setFrameAvailableListener().
81 void setContentsChangedListener(const wp<ContentsChangedListener>& listener);
82
Chia-I Wuf1405182017-11-27 11:29:21 -080083 // updateTexImage acquires the most recently queued buffer, and sets the
84 // image contents of the target texture to it.
85 //
Chia-I Wu221b5922017-12-14 13:59:16 -080086 // This call may only be made while RenderEngine is current.
Chia-I Wuf1405182017-11-27 11:29:21 -080087 //
Chia-I Wu221b5922017-12-14 13:59:16 -080088 // This calls doFenceWait to ensure proper synchronization unless native
89 // fence is supported.
Chia-I Wuda5c7302017-11-27 14:51:06 -080090 //
Chia-I Wu221b5922017-12-14 13:59:16 -080091 // Unlike the GLConsumer version, this version takes a functor that may be
92 // used to reject the newly acquired buffer. It also does not bind the
93 // RenderEngine texture until bindTextureImage is called.
Ana Krulec010d2192018-10-08 06:29:54 -070094 status_t updateTexImage(BufferRejecter* rejecter, nsecs_t expectedPresentTime,
Alec Mouri56e538f2019-01-14 15:22:01 -080095 bool* autoRefresh, bool* queuedBuffer, uint64_t maxFrameNumber);
Chia-I Wuf1405182017-11-27 11:29:21 -080096
Chia-I Wuf1405182017-11-27 11:29:21 -080097 // setReleaseFence stores a fence that will signal when the current buffer
98 // is no longer being read. This fence will be returned to the producer
99 // when the current buffer is released by updateTexImage(). Multiple
100 // fences can be set for a given buffer; they will be merged into a single
101 // union fence.
Chia-I Wuda5c7302017-11-27 14:51:06 -0800102 void setReleaseFence(const sp<Fence>& fence);
103
104 bool releasePendingBuffer();
Chia-I Wuf1405182017-11-27 11:29:21 -0800105
Chia-I Wu0cb75ac2017-11-27 15:56:04 -0800106 sp<Fence> getPrevFinalReleaseFence() const;
107
Chia-I Wu221b5922017-12-14 13:59:16 -0800108 // See GLConsumer::getTransformMatrix.
Chia-I Wuf1405182017-11-27 11:29:21 -0800109 void getTransformMatrix(float mtx[16]);
110
Chia-I Wuf1405182017-11-27 11:29:21 -0800111 // getTimestamp retrieves the timestamp associated with the texture image
112 // set by the most recent call to updateTexImage.
113 //
114 // The timestamp is in nanoseconds, and is monotonically increasing. Its
115 // other semantics (zero point, etc) are source-dependent and should be
116 // documented by the source.
117 int64_t getTimestamp();
118
119 // getDataSpace retrieves the DataSpace associated with the texture image
120 // set by the most recent call to updateTexImage.
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700121 ui::Dataspace getCurrentDataSpace();
Chia-I Wuf1405182017-11-27 11:29:21 -0800122
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700123 // getCurrentHdrMetadata retrieves the HDR metadata associated with the
124 // texture image set by the most recent call to updateTexImage.
125 const HdrMetadata& getCurrentHdrMetadata() const;
126
Chia-I Wuf1405182017-11-27 11:29:21 -0800127 // getFrameNumber retrieves the frame number associated with the texture
128 // image set by the most recent call to updateTexImage.
129 //
130 // The frame number is an incrementing counter set to 0 at the creation of
131 // the BufferQueue associated with this consumer.
132 uint64_t getFrameNumber();
133
Chia-I Wu67dcc692017-11-27 14:51:06 -0800134 bool getTransformToDisplayInverse() const;
135
136 // must be called from SF main thread
137 const Region& getSurfaceDamage() const;
138
Steven Thomas44685cb2019-07-23 16:19:31 -0700139 // Merge the given damage region into the current damage region value.
140 void mergeSurfaceDamage(const Region& damage);
141
Chia-I Wu5c6e4632018-01-11 08:54:38 -0800142 // getCurrentApi retrieves the API which queues the current buffer.
143 int getCurrentApi() const;
144
Chia-I Wu221b5922017-12-14 13:59:16 -0800145 // See GLConsumer::setDefaultBufferSize.
Chia-I Wuf1405182017-11-27 11:29:21 -0800146 status_t setDefaultBufferSize(uint32_t width, uint32_t height);
147
148 // setFilteringEnabled sets whether the transform matrix should be computed
149 // for use with bilinear filtering.
150 void setFilteringEnabled(bool enabled);
151
152 // getCurrentBuffer returns the buffer associated with the current image.
153 // When outSlot is not nullptr, the current buffer slot index is also
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000154 // returned. Simiarly, when outFence is not nullptr, the current output
155 // fence is returned.
Alec Mouri617752f2021-04-15 16:27:01 +0000156 sp<GraphicBuffer> getCurrentBuffer(int* outSlot = nullptr, sp<Fence>* outFence = nullptr) const;
Chia-I Wuf1405182017-11-27 11:29:21 -0800157
Chia-I Wuf1405182017-11-27 11:29:21 -0800158 // getCurrentCrop returns the cropping rectangle of the current buffer.
159 Rect getCurrentCrop() const;
160
161 // getCurrentTransform returns the transform of the current buffer.
162 uint32_t getCurrentTransform() const;
163
164 // getCurrentScalingMode returns the scaling mode of the current buffer.
165 uint32_t getCurrentScalingMode() const;
166
167 // getCurrentFence returns the fence indicating when the current buffer is
168 // ready to be read from.
169 sp<Fence> getCurrentFence() const;
170
171 // getCurrentFence returns the FenceTime indicating when the current
172 // buffer is ready to be read from.
173 std::shared_ptr<FenceTime> getCurrentFenceTime() const;
174
175 // setConsumerUsageBits overrides the ConsumerBase method to OR
176 // DEFAULT_USAGE_FLAGS to usage.
177 status_t setConsumerUsageBits(uint64_t usage);
Alec Mouri485e4c32019-04-30 18:24:05 -0700178 void onBufferAvailable(const BufferItem& item) EXCLUDES(mImagesMutex);
Chia-I Wuf1405182017-11-27 11:29:21 -0800179
Chia-I Wuf1405182017-11-27 11:29:21 -0800180protected:
181 // abandonLocked overrides the ConsumerBase method to clear
182 // mCurrentTextureImage in addition to the ConsumerBase behavior.
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700183 virtual void abandonLocked() EXCLUDES(mImagesMutex);
Chia-I Wuf1405182017-11-27 11:29:21 -0800184
185 // dumpLocked overrides the ConsumerBase method to dump BufferLayerConsumer-
186 // specific info in addition to the ConsumerBase behavior.
187 virtual void dumpLocked(String8& result, const char* prefix) const;
188
Alec Mouri39801c02018-10-10 10:44:47 -0700189 // See ConsumerBase::acquireBufferLocked
Chia-I Wuf1405182017-11-27 11:29:21 -0800190 virtual status_t acquireBufferLocked(BufferItem* item, nsecs_t presentWhen,
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700191 uint64_t maxFrameNumber = 0) override
192 EXCLUDES(mImagesMutex);
Chia-I Wuf1405182017-11-27 11:29:21 -0800193
Chia-I Wu6748db42017-12-01 10:53:53 -0800194 bool canUseImageCrop(const Rect& crop) const;
195
Chia-I Wuf1405182017-11-27 11:29:21 -0800196 struct PendingRelease {
Chia-I Wu6aff69b2017-11-27 14:08:48 -0800197 PendingRelease() : isPending(false), currentTexture(-1), graphicBuffer() {}
Chia-I Wuf1405182017-11-27 11:29:21 -0800198
199 bool isPending;
200 int currentTexture;
201 sp<GraphicBuffer> graphicBuffer;
Chia-I Wuf1405182017-11-27 11:29:21 -0800202 };
203
204 // This releases the buffer in the slot referenced by mCurrentTexture,
205 // then updates state to refer to the BufferItem, which must be a
206 // newly-acquired buffer. If pendingRelease is not null, the parameters
207 // which would have been passed to releaseBufferLocked upon the successful
208 // completion of the method will instead be returned to the caller, so that
209 // it may call releaseBufferLocked itself later.
210 status_t updateAndReleaseLocked(const BufferItem& item,
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700211 PendingRelease* pendingRelease = nullptr)
212 EXCLUDES(mImagesMutex);
Chia-I Wuf1405182017-11-27 11:29:21 -0800213
Chia-I Wuf1405182017-11-27 11:29:21 -0800214private:
Alec Mourib5c4f352019-02-19 19:46:38 -0800215 // Utility class for managing GraphicBuffer references into renderengine
216 class Image {
217 public:
Alec Mouri16a99402019-07-29 16:37:30 -0700218 Image(const sp<GraphicBuffer>& graphicBuffer, renderengine::RenderEngine& engine);
Alec Mourib5c4f352019-02-19 19:46:38 -0800219 virtual ~Image();
220 const sp<GraphicBuffer>& graphicBuffer() { return mGraphicBuffer; }
221
222 private:
223 // mGraphicBuffer is the buffer that was used to create this image.
224 sp<GraphicBuffer> mGraphicBuffer;
225 // Back-reference into renderengine to initiate cleanup.
226 renderengine::RenderEngine& mRE;
227 DISALLOW_COPY_AND_ASSIGN(Image);
228 };
229
Chia-I Wuf1405182017-11-27 11:29:21 -0800230 // freeBufferLocked frees up the given buffer slot. If the slot has been
Chia-I Wu221b5922017-12-14 13:59:16 -0800231 // initialized this will release the reference to the GraphicBuffer in
Alec Mouri39801c02018-10-10 10:44:47 -0700232 // that slot. Otherwise it has no effect.
Chia-I Wuf1405182017-11-27 11:29:21 -0800233 //
234 // This method must be called with mMutex locked.
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700235 virtual void freeBufferLocked(int slotIndex) EXCLUDES(mImagesMutex);
Chia-I Wuf1405182017-11-27 11:29:21 -0800236
Chia-I Wuc75c44d2017-11-27 14:32:57 -0800237 // IConsumerListener interface
238 void onDisconnect() override;
Chia-I Wufd257f82017-11-27 14:51:06 -0800239 void onSidebandStreamChanged() override;
Chia-I Wuc75c44d2017-11-27 14:32:57 -0800240 void addAndGetFrameTimestamps(const NewFrameEventsEntry* newTimestamps,
241 FrameEventHistoryDelta* outDelta) override;
242
Chia-I Wuf1405182017-11-27 11:29:21 -0800243 // computeCurrentTransformMatrixLocked computes the transform matrix for the
244 // current texture. It uses mCurrentTransform and the current GraphicBuffer
245 // to compute this matrix and stores it in mCurrentTransformMatrix.
Peiyong Lin566a3b42018-01-09 18:22:43 -0800246 // mCurrentTextureImage must not be nullptr.
Chia-I Wuf1405182017-11-27 11:29:21 -0800247 void computeCurrentTransformMatrixLocked();
248
Alec Mouri2ee0dda2019-01-30 16:44:43 -0800249 // getCurrentCropLocked returns the cropping rectangle of the current buffer.
250 Rect getCurrentCropLocked() const;
251
Chia-I Wuf1405182017-11-27 11:29:21 -0800252 // The default consumer usage flags that BufferLayerConsumer always sets on its
253 // BufferQueue instance; these will be OR:d with any additional flags passed
254 // from the BufferLayerConsumer user. In particular, BufferLayerConsumer will always
255 // consume buffers as hardware textures.
256 static const uint64_t DEFAULT_USAGE_FLAGS = GraphicBuffer::USAGE_HW_TEXTURE;
257
Alec Mourib5c4f352019-02-19 19:46:38 -0800258 // mCurrentTextureBuffer is the buffer containing the current texture. It's
Chia-I Wuf1405182017-11-27 11:29:21 -0800259 // possible that this buffer is not associated with any buffer slot, so we
260 // must track it separately in order to support the getCurrentBuffer method.
Alec Mouri617752f2021-04-15 16:27:01 +0000261 std::shared_ptr<Image> mCurrentTextureBuffer;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000262
Chia-I Wuf1405182017-11-27 11:29:21 -0800263 // mCurrentCrop is the crop rectangle that applies to the current texture.
264 // It gets set each time updateTexImage is called.
265 Rect mCurrentCrop;
266
267 // mCurrentTransform is the transform identifier for the current texture. It
268 // gets set each time updateTexImage is called.
269 uint32_t mCurrentTransform;
270
271 // mCurrentScalingMode is the scaling mode for the current texture. It gets
272 // set each time updateTexImage is called.
273 uint32_t mCurrentScalingMode;
274
275 // mCurrentFence is the fence received from BufferQueue in updateTexImage.
276 sp<Fence> mCurrentFence;
277
278 // The FenceTime wrapper around mCurrentFence.
279 std::shared_ptr<FenceTime> mCurrentFenceTime{FenceTime::NO_FENCE};
280
281 // mCurrentTransformMatrix is the transform matrix for the current texture.
282 // It gets computed by computeTransformMatrix each time updateTexImage is
283 // called.
284 float mCurrentTransformMatrix[16];
285
286 // mCurrentTimestamp is the timestamp for the current texture. It
287 // gets set each time updateTexImage is called.
288 int64_t mCurrentTimestamp;
289
290 // mCurrentDataSpace is the dataspace for the current texture. It
291 // gets set each time updateTexImage is called.
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700292 ui::Dataspace mCurrentDataSpace;
Chia-I Wuf1405182017-11-27 11:29:21 -0800293
Courtney Goeltzenleuchter9bad0d72017-12-19 12:34:34 -0700294 // mCurrentHdrMetadata is the HDR metadata for the current texture. It
295 // gets set each time updateTexImage is called.
296 HdrMetadata mCurrentHdrMetadata;
297
Chia-I Wuf1405182017-11-27 11:29:21 -0800298 // mCurrentFrameNumber is the frame counter for the current texture.
299 // It gets set each time updateTexImage is called.
300 uint64_t mCurrentFrameNumber;
301
Chia-I Wu67dcc692017-11-27 14:51:06 -0800302 // Indicates this buffer must be transformed by the inverse transform of the screen
303 // it is displayed onto. This is applied after BufferLayerConsumer::mCurrentTransform.
304 // This must be set/read from SurfaceFlinger's main thread.
305 bool mCurrentTransformToDisplayInverse;
306
307 // The portion of this surface that has changed since the previous frame
308 Region mCurrentSurfaceDamage;
309
Chia-I Wu5c6e4632018-01-11 08:54:38 -0800310 int mCurrentApi;
311
Chia-I Wuf1405182017-11-27 11:29:21 -0800312 uint32_t mDefaultWidth, mDefaultHeight;
313
314 // mFilteringEnabled indicates whether the transform matrix is computed for
315 // use with bilinear filtering. It defaults to true and is changed by
316 // setFilteringEnabled().
317 bool mFilteringEnabled;
318
Peiyong Lin833074a2018-08-28 11:53:54 -0700319 renderengine::RenderEngine& mRE;
Chia-I Wu9f2db772017-11-30 21:06:50 -0800320
Chia-I Wu221b5922017-12-14 13:59:16 -0800321 // mTexName is the name of the RenderEngine texture to which streamed
322 // images will be bound when bindTexImage is called. It is set at
323 // construction time.
Chia-I Wuc91077c2017-11-27 13:32:04 -0800324 const uint32_t mTexName;
Chia-I Wuf1405182017-11-27 11:29:21 -0800325
chaviw1a4dba42020-05-27 15:16:15 -0700326 // The layer for this BufferLayerConsumer. Always check mAbandoned before accessing.
327 Layer* mLayer GUARDED_BY(mMutex);
Chia-I Wuc75c44d2017-11-27 14:32:57 -0800328
Chia-I Wufd257f82017-11-27 14:51:06 -0800329 wp<ContentsChangedListener> mContentsChangedListener;
330
Chia-I Wuf1405182017-11-27 11:29:21 -0800331 // mCurrentTexture is the buffer slot index of the buffer that is currently
Chia-I Wu221b5922017-12-14 13:59:16 -0800332 // bound to the RenderEngine texture. It is initialized to INVALID_BUFFER_SLOT,
Chia-I Wuf1405182017-11-27 11:29:21 -0800333 // indicating that no buffer slot is currently bound to the texture. Note,
334 // however, that a value of INVALID_BUFFER_SLOT does not necessarily mean
335 // that no buffer is bound to the texture. A call to setBufferCount will
336 // reset mCurrentTexture to INVALID_BUFFER_SLOT.
337 int mCurrentTexture;
Chia-I Wuda5c7302017-11-27 14:51:06 -0800338
Alec Mourib5c4f352019-02-19 19:46:38 -0800339 // Shadow buffer cache for cleaning up renderengine references.
Alec Mouri617752f2021-04-15 16:27:01 +0000340 std::shared_ptr<Image> mImages[BufferQueueDefs::NUM_BUFFER_SLOTS] GUARDED_BY(mImagesMutex);
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700341
342 // Separate mutex guarding the shadow buffer cache.
343 // mImagesMutex can be manipulated with binder threads (e.g. onBuffersAllocated)
344 // which is contentious enough that we can't just use mMutex.
345 mutable std::mutex mImagesMutex;
Alec Mouri39801c02018-10-10 10:44:47 -0700346
Chia-I Wuda5c7302017-11-27 14:51:06 -0800347 // A release that is pending on the receipt of a new release fence from
348 // presentDisplay
349 PendingRelease mPendingRelease;
Chia-I Wuf1405182017-11-27 11:29:21 -0800350};
351
352// ----------------------------------------------------------------------------
353}; // namespace android
354
355#endif // ANDROID_BUFFERLAYERCONSUMER_H