1 /*
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 // TODO(b/129481165): remove the #pragma below and fix conversion issues
18 #pragma clang diagnostic push
19 #pragma clang diagnostic ignored "-Wconversion"
20
21 #undef LOG_TAG
22 #define LOG_TAG "BufferLayerConsumer"
23 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
24 //#define LOG_NDEBUG 0
25
26 #include "BufferLayerConsumer.h"
27 #include "Layer.h"
28 #include "Scheduler/VsyncController.h"
29
30 #include <inttypes.h>
31
32 #include <cutils/compiler.h>
33
34 #include <hardware/hardware.h>
35
36 #include <math/mat4.h>
37
38 #include <gui/BufferItem.h>
39 #include <gui/GLConsumer.h>
40 #include <gui/ISurfaceComposer.h>
41 #include <gui/SurfaceComposerClient.h>
42 #include <private/gui/ComposerService.h>
43 #include <renderengine/RenderEngine.h>
44 #include <renderengine/impl/ExternalTexture.h>
45 #include <utils/Log.h>
46 #include <utils/String8.h>
47 #include <utils/Trace.h>
48
49 namespace android {
50
51 // Macros for including the BufferLayerConsumer name in log messages
52 #define BLC_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)
53 #define BLC_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__)
54 //#define BLC_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__)
55 #define BLC_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__)
56 #define BLC_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__)
57
58 static const mat4 mtxIdentity;
59
BufferLayerConsumer(const sp<IGraphicBufferConsumer> & bq,renderengine::RenderEngine & engine,uint32_t tex,Layer * layer)60 BufferLayerConsumer::BufferLayerConsumer(const sp<IGraphicBufferConsumer>& bq,
61 renderengine::RenderEngine& engine, uint32_t tex,
62 Layer* layer)
63 : ConsumerBase(bq, false),
64 mCurrentCrop(Rect::EMPTY_RECT),
65 mCurrentTransform(0),
66 mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
67 mCurrentFence(Fence::NO_FENCE),
68 mCurrentTimestamp(0),
69 mCurrentDataSpace(ui::Dataspace::UNKNOWN),
70 mCurrentFrameNumber(0),
71 mCurrentTransformToDisplayInverse(false),
72 mCurrentSurfaceDamage(),
73 mCurrentApi(0),
74 mDefaultWidth(1),
75 mDefaultHeight(1),
76 mFilteringEnabled(true),
77 mRE(engine),
78 mTexName(tex),
79 mLayer(layer),
80 mCurrentTexture(BufferQueue::INVALID_BUFFER_SLOT) {
81 BLC_LOGV("BufferLayerConsumer");
82
83 memcpy(mCurrentTransformMatrix, mtxIdentity.asArray(), sizeof(mCurrentTransformMatrix));
84
85 mConsumer->setConsumerUsageBits(DEFAULT_USAGE_FLAGS);
86 }
87
setDefaultBufferSize(uint32_t w,uint32_t h)88 status_t BufferLayerConsumer::setDefaultBufferSize(uint32_t w, uint32_t h) {
89 Mutex::Autolock lock(mMutex);
90 if (mAbandoned) {
91 BLC_LOGE("setDefaultBufferSize: BufferLayerConsumer is abandoned!");
92 return NO_INIT;
93 }
94 mDefaultWidth = w;
95 mDefaultHeight = h;
96 return mConsumer->setDefaultBufferSize(w, h);
97 }
98
setContentsChangedListener(const wp<ContentsChangedListener> & listener)99 void BufferLayerConsumer::setContentsChangedListener(const wp<ContentsChangedListener>& listener) {
100 setFrameAvailableListener(listener);
101 Mutex::Autolock lock(mMutex);
102 mContentsChangedListener = listener;
103 }
104
updateTexImage(BufferRejecter * rejecter,nsecs_t expectedPresentTime,bool * autoRefresh,bool * queuedBuffer,uint64_t maxFrameNumber)105 status_t BufferLayerConsumer::updateTexImage(BufferRejecter* rejecter, nsecs_t expectedPresentTime,
106 bool* autoRefresh, bool* queuedBuffer,
107 uint64_t maxFrameNumber) {
108 ATRACE_CALL();
109 BLC_LOGV("updateTexImage");
110 Mutex::Autolock lock(mMutex);
111
112 if (mAbandoned) {
113 BLC_LOGE("updateTexImage: BufferLayerConsumer is abandoned!");
114 return NO_INIT;
115 }
116
117 BufferItem item;
118
119 // Acquire the next buffer.
120 // In asynchronous mode the list is guaranteed to be one buffer
121 // deep, while in synchronous mode we use the oldest buffer.
122 status_t err = acquireBufferLocked(&item, expectedPresentTime, maxFrameNumber);
123 if (err != NO_ERROR) {
124 if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
125 err = NO_ERROR;
126 } else if (err == BufferQueue::PRESENT_LATER) {
127 // return the error, without logging
128 } else {
129 BLC_LOGE("updateTexImage: acquire failed: %s (%d)", strerror(-err), err);
130 }
131 return err;
132 }
133
134 if (autoRefresh) {
135 *autoRefresh = item.mAutoRefresh;
136 }
137
138 if (queuedBuffer) {
139 *queuedBuffer = item.mQueuedBuffer;
140 }
141
142 // We call the rejecter here, in case the caller has a reason to
143 // not accept this buffer. This is used by SurfaceFlinger to
144 // reject buffers which have the wrong size
145 int slot = item.mSlot;
146 if (rejecter && rejecter->reject(mSlots[slot].mGraphicBuffer, item)) {
147 releaseBufferLocked(slot, mSlots[slot].mGraphicBuffer);
148 return BUFFER_REJECTED;
149 }
150
151 // Release the previous buffer.
152 err = updateAndReleaseLocked(item, &mPendingRelease);
153 if (err != NO_ERROR) {
154 return err;
155 }
156 return err;
157 }
158
setReleaseFence(const sp<Fence> & fence)159 void BufferLayerConsumer::setReleaseFence(const sp<Fence>& fence) {
160 if (!fence->isValid()) {
161 return;
162 }
163
164 auto slot = mPendingRelease.isPending ? mPendingRelease.currentTexture : mCurrentTexture;
165 if (slot == BufferQueue::INVALID_BUFFER_SLOT) {
166 return;
167 }
168
169 auto buffer = mPendingRelease.isPending ? mPendingRelease.graphicBuffer
170 : mCurrentTextureBuffer->getBuffer();
171 auto err = addReleaseFence(slot, buffer, fence);
172 if (err != OK) {
173 BLC_LOGE("setReleaseFence: failed to add the fence: %s (%d)", strerror(-err), err);
174 }
175 }
176
releasePendingBuffer()177 bool BufferLayerConsumer::releasePendingBuffer() {
178 if (!mPendingRelease.isPending) {
179 BLC_LOGV("Pending buffer already released");
180 return false;
181 }
182 BLC_LOGV("Releasing pending buffer");
183 Mutex::Autolock lock(mMutex);
184 status_t result =
185 releaseBufferLocked(mPendingRelease.currentTexture, mPendingRelease.graphicBuffer);
186 if (result < NO_ERROR) {
187 BLC_LOGE("releasePendingBuffer failed: %s (%d)", strerror(-result), result);
188 }
189 mPendingRelease = PendingRelease();
190 return true;
191 }
192
getPrevFinalReleaseFence() const193 sp<Fence> BufferLayerConsumer::getPrevFinalReleaseFence() const {
194 Mutex::Autolock lock(mMutex);
195 return ConsumerBase::mPrevFinalReleaseFence;
196 }
197
acquireBufferLocked(BufferItem * item,nsecs_t presentWhen,uint64_t maxFrameNumber)198 status_t BufferLayerConsumer::acquireBufferLocked(BufferItem* item, nsecs_t presentWhen,
199 uint64_t maxFrameNumber) {
200 status_t err = ConsumerBase::acquireBufferLocked(item, presentWhen, maxFrameNumber);
201 if (err != NO_ERROR) {
202 return err;
203 }
204
205 // If item->mGraphicBuffer is not null, this buffer has not been acquired
206 // before, so we need to clean up old references.
207 if (item->mGraphicBuffer != nullptr) {
208 std::lock_guard<std::mutex> lock(mImagesMutex);
209 if (mImages[item->mSlot] == nullptr || mImages[item->mSlot]->getBuffer() == nullptr ||
210 mImages[item->mSlot]->getBuffer()->getId() != item->mGraphicBuffer->getId()) {
211 mImages[item->mSlot] = std::make_shared<
212 renderengine::impl::ExternalTexture>(item->mGraphicBuffer, mRE,
213 renderengine::impl::ExternalTexture::
214 Usage::READABLE);
215 }
216 }
217
218 return NO_ERROR;
219 }
220
updateAndReleaseLocked(const BufferItem & item,PendingRelease * pendingRelease)221 status_t BufferLayerConsumer::updateAndReleaseLocked(const BufferItem& item,
222 PendingRelease* pendingRelease) {
223 status_t err = NO_ERROR;
224
225 int slot = item.mSlot;
226
227 BLC_LOGV("updateAndRelease: (slot=%d buf=%p) -> (slot=%d buf=%p)", mCurrentTexture,
228 (mCurrentTextureBuffer != nullptr && mCurrentTextureBuffer->getBuffer() != nullptr)
229 ? mCurrentTextureBuffer->getBuffer()->handle
230 : 0,
231 slot, mSlots[slot].mGraphicBuffer->handle);
232
233 // Hang onto the pointer so that it isn't freed in the call to
234 // releaseBufferLocked() if we're in shared buffer mode and both buffers are
235 // the same.
236
237 std::shared_ptr<renderengine::ExternalTexture> nextTextureBuffer;
238 {
239 std::lock_guard<std::mutex> lock(mImagesMutex);
240 nextTextureBuffer = mImages[slot];
241 }
242
243 // release old buffer
244 if (mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) {
245 if (pendingRelease == nullptr) {
246 status_t status =
247 releaseBufferLocked(mCurrentTexture, mCurrentTextureBuffer->getBuffer());
248 if (status < NO_ERROR) {
249 BLC_LOGE("updateAndRelease: failed to release buffer: %s (%d)", strerror(-status),
250 status);
251 err = status;
252 // keep going, with error raised [?]
253 }
254 } else {
255 pendingRelease->currentTexture = mCurrentTexture;
256 pendingRelease->graphicBuffer = mCurrentTextureBuffer->getBuffer();
257 pendingRelease->isPending = true;
258 }
259 }
260
261 // Update the BufferLayerConsumer state.
262 mCurrentTexture = slot;
263 mCurrentTextureBuffer = nextTextureBuffer;
264 mCurrentCrop = item.mCrop;
265 mCurrentTransform = item.mTransform;
266 mCurrentScalingMode = item.mScalingMode;
267 mCurrentTimestamp = item.mTimestamp;
268 mCurrentDataSpace = static_cast<ui::Dataspace>(item.mDataSpace);
269 mCurrentHdrMetadata = item.mHdrMetadata;
270 mCurrentFence = item.mFence;
271 mCurrentFenceTime = item.mFenceTime;
272 mCurrentFrameNumber = item.mFrameNumber;
273 mCurrentTransformToDisplayInverse = item.mTransformToDisplayInverse;
274 mCurrentSurfaceDamage = item.mSurfaceDamage;
275 mCurrentApi = item.mApi;
276
277 computeCurrentTransformMatrixLocked();
278
279 return err;
280 }
281
getTransformMatrix(float mtx[16])282 void BufferLayerConsumer::getTransformMatrix(float mtx[16]) {
283 Mutex::Autolock lock(mMutex);
284 memcpy(mtx, mCurrentTransformMatrix, sizeof(mCurrentTransformMatrix));
285 }
286
setFilteringEnabled(bool enabled)287 void BufferLayerConsumer::setFilteringEnabled(bool enabled) {
288 Mutex::Autolock lock(mMutex);
289 if (mAbandoned) {
290 BLC_LOGE("setFilteringEnabled: BufferLayerConsumer is abandoned!");
291 return;
292 }
293 bool needsRecompute = mFilteringEnabled != enabled;
294 mFilteringEnabled = enabled;
295
296 if (needsRecompute && mCurrentTextureBuffer == nullptr) {
297 BLC_LOGD("setFilteringEnabled called with mCurrentTextureBuffer == nullptr");
298 }
299
300 if (needsRecompute && mCurrentTextureBuffer != nullptr) {
301 computeCurrentTransformMatrixLocked();
302 }
303 }
304
computeCurrentTransformMatrixLocked()305 void BufferLayerConsumer::computeCurrentTransformMatrixLocked() {
306 BLC_LOGV("computeCurrentTransformMatrixLocked");
307 if (mCurrentTextureBuffer == nullptr || mCurrentTextureBuffer->getBuffer() == nullptr) {
308 BLC_LOGD("computeCurrentTransformMatrixLocked: "
309 "mCurrentTextureBuffer is nullptr");
310 }
311 GLConsumer::computeTransformMatrix(mCurrentTransformMatrix,
312 mCurrentTextureBuffer == nullptr
313 ? nullptr
314 : mCurrentTextureBuffer->getBuffer(),
315 getCurrentCropLocked(), mCurrentTransform,
316 mFilteringEnabled);
317 }
318
getTimestamp()319 nsecs_t BufferLayerConsumer::getTimestamp() {
320 BLC_LOGV("getTimestamp");
321 Mutex::Autolock lock(mMutex);
322 return mCurrentTimestamp;
323 }
324
getCurrentDataSpace()325 ui::Dataspace BufferLayerConsumer::getCurrentDataSpace() {
326 BLC_LOGV("getCurrentDataSpace");
327 Mutex::Autolock lock(mMutex);
328 return mCurrentDataSpace;
329 }
330
getCurrentHdrMetadata() const331 const HdrMetadata& BufferLayerConsumer::getCurrentHdrMetadata() const {
332 BLC_LOGV("getCurrentHdrMetadata");
333 Mutex::Autolock lock(mMutex);
334 return mCurrentHdrMetadata;
335 }
336
getFrameNumber()337 uint64_t BufferLayerConsumer::getFrameNumber() {
338 BLC_LOGV("getFrameNumber");
339 Mutex::Autolock lock(mMutex);
340 return mCurrentFrameNumber;
341 }
342
getTransformToDisplayInverse() const343 bool BufferLayerConsumer::getTransformToDisplayInverse() const {
344 Mutex::Autolock lock(mMutex);
345 return mCurrentTransformToDisplayInverse;
346 }
347
getSurfaceDamage() const348 const Region& BufferLayerConsumer::getSurfaceDamage() const {
349 return mCurrentSurfaceDamage;
350 }
351
mergeSurfaceDamage(const Region & damage)352 void BufferLayerConsumer::mergeSurfaceDamage(const Region& damage) {
353 if (damage.bounds() == Rect::INVALID_RECT ||
354 mCurrentSurfaceDamage.bounds() == Rect::INVALID_RECT) {
355 mCurrentSurfaceDamage = Region::INVALID_REGION;
356 } else {
357 mCurrentSurfaceDamage |= damage;
358 }
359 }
360
getCurrentApi() const361 int BufferLayerConsumer::getCurrentApi() const {
362 Mutex::Autolock lock(mMutex);
363 return mCurrentApi;
364 }
365
getCurrentBuffer(int * outSlot,sp<Fence> * outFence) const366 std::shared_ptr<renderengine::ExternalTexture> BufferLayerConsumer::getCurrentBuffer(
367 int* outSlot, sp<Fence>* outFence) const {
368 Mutex::Autolock lock(mMutex);
369
370 if (outSlot != nullptr) {
371 *outSlot = mCurrentTexture;
372 }
373
374 if (outFence != nullptr) {
375 *outFence = mCurrentFence;
376 }
377
378 return mCurrentTextureBuffer == nullptr ? nullptr : mCurrentTextureBuffer;
379 }
380
getCurrentCrop() const381 Rect BufferLayerConsumer::getCurrentCrop() const {
382 Mutex::Autolock lock(mMutex);
383 return getCurrentCropLocked();
384 }
385
getCurrentCropLocked() const386 Rect BufferLayerConsumer::getCurrentCropLocked() const {
387 uint32_t width = mDefaultWidth;
388 uint32_t height = mDefaultHeight;
389 // If the buffer comes with a rotated bit for 90 (or 270) degrees, switch width/height in order
390 // to scale and crop correctly.
391 if (mCurrentTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
392 width = mDefaultHeight;
393 height = mDefaultWidth;
394 }
395
396 return (mCurrentScalingMode == NATIVE_WINDOW_SCALING_MODE_SCALE_CROP)
397 ? GLConsumer::scaleDownCrop(mCurrentCrop, width, height)
398 : mCurrentCrop;
399 }
400
getCurrentTransform() const401 uint32_t BufferLayerConsumer::getCurrentTransform() const {
402 Mutex::Autolock lock(mMutex);
403 return mCurrentTransform;
404 }
405
getCurrentScalingMode() const406 uint32_t BufferLayerConsumer::getCurrentScalingMode() const {
407 Mutex::Autolock lock(mMutex);
408 return mCurrentScalingMode;
409 }
410
getCurrentFence() const411 sp<Fence> BufferLayerConsumer::getCurrentFence() const {
412 Mutex::Autolock lock(mMutex);
413 return mCurrentFence;
414 }
415
getCurrentFenceTime() const416 std::shared_ptr<FenceTime> BufferLayerConsumer::getCurrentFenceTime() const {
417 Mutex::Autolock lock(mMutex);
418 return mCurrentFenceTime;
419 }
420
freeBufferLocked(int slotIndex)421 void BufferLayerConsumer::freeBufferLocked(int slotIndex) {
422 BLC_LOGV("freeBufferLocked: slotIndex=%d", slotIndex);
423 std::lock_guard<std::mutex> lock(mImagesMutex);
424 if (slotIndex == mCurrentTexture) {
425 mCurrentTexture = BufferQueue::INVALID_BUFFER_SLOT;
426 }
427 mImages[slotIndex] = nullptr;
428 ConsumerBase::freeBufferLocked(slotIndex);
429 }
430
onDisconnect()431 void BufferLayerConsumer::onDisconnect() {
432 Mutex::Autolock lock(mMutex);
433
434 if (mAbandoned) {
435 // Nothing to do if we're already abandoned.
436 return;
437 }
438
439 mLayer->onDisconnect();
440 }
441
onSidebandStreamChanged()442 void BufferLayerConsumer::onSidebandStreamChanged() {
443 [[maybe_unused]] FrameAvailableListener* unsafeFrameAvailableListener = nullptr;
444 {
445 Mutex::Autolock lock(mFrameAvailableMutex);
446 unsafeFrameAvailableListener = mFrameAvailableListener.unsafe_get();
447 }
448 sp<ContentsChangedListener> listener;
449 { // scope for the lock
450 Mutex::Autolock lock(mMutex);
451 ALOG_ASSERT(unsafeFrameAvailableListener == mContentsChangedListener.unsafe_get());
452 listener = mContentsChangedListener.promote();
453 }
454
455 if (listener != nullptr) {
456 listener->onSidebandStreamChanged();
457 }
458 }
459
onBufferAvailable(const BufferItem & item)460 void BufferLayerConsumer::onBufferAvailable(const BufferItem& item) {
461 if (item.mGraphicBuffer != nullptr && item.mSlot != BufferQueue::INVALID_BUFFER_SLOT) {
462 std::lock_guard<std::mutex> lock(mImagesMutex);
463 const std::shared_ptr<renderengine::ExternalTexture>& oldImage = mImages[item.mSlot];
464 if (oldImage == nullptr || oldImage->getBuffer() == nullptr ||
465 oldImage->getBuffer()->getId() != item.mGraphicBuffer->getId()) {
466 mImages[item.mSlot] = std::make_shared<
467 renderengine::impl::ExternalTexture>(item.mGraphicBuffer, mRE,
468 renderengine::impl::ExternalTexture::
469 Usage::READABLE);
470 }
471 }
472 }
473
abandonLocked()474 void BufferLayerConsumer::abandonLocked() {
475 BLC_LOGV("abandonLocked");
476 mCurrentTextureBuffer = nullptr;
477 for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
478 std::lock_guard<std::mutex> lock(mImagesMutex);
479 mImages[i] = nullptr;
480 }
481 ConsumerBase::abandonLocked();
482 }
483
setConsumerUsageBits(uint64_t usage)484 status_t BufferLayerConsumer::setConsumerUsageBits(uint64_t usage) {
485 return ConsumerBase::setConsumerUsageBits(usage | DEFAULT_USAGE_FLAGS);
486 }
487
dumpLocked(String8 & result,const char * prefix) const488 void BufferLayerConsumer::dumpLocked(String8& result, const char* prefix) const {
489 result.appendFormat("%smTexName=%d mCurrentTexture=%d\n"
490 "%smCurrentCrop=[%d,%d,%d,%d] mCurrentTransform=%#x\n",
491 prefix, mTexName, mCurrentTexture, prefix, mCurrentCrop.left,
492 mCurrentCrop.top, mCurrentCrop.right, mCurrentCrop.bottom,
493 mCurrentTransform);
494
495 ConsumerBase::dumpLocked(result, prefix);
496 }
497 }; // namespace android
498
499 // TODO(b/129481165): remove the #pragma below and fix conversion issues
500 #pragma clang diagnostic pop // ignored "-Wconversion"
501