Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 1 | /* |
| 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 | #include "BufferQueueLayer.h" |
| 18 | #include "LayerRejecter.h" |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 19 | |
Yiwei Zhang | 7e666a5 | 2018-11-15 13:33:42 -0800 | [diff] [blame] | 20 | #include "TimeStats/TimeStats.h" |
| 21 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 22 | #include <system/window.h> |
| 23 | |
| 24 | namespace android { |
| 25 | |
Lloyd Pique | 42ab75e | 2018-09-12 20:46:03 -0700 | [diff] [blame] | 26 | BufferQueueLayer::BufferQueueLayer(const LayerCreationArgs& args) : BufferLayer(args) {} |
| 27 | |
Robert Carr | 2e102c9 | 2018-10-23 12:11:15 -0700 | [diff] [blame] | 28 | BufferQueueLayer::~BufferQueueLayer() { |
| 29 | mConsumer->abandon(); |
| 30 | } |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 31 | |
| 32 | // ----------------------------------------------------------------------- |
| 33 | // Interface implementation for Layer |
| 34 | // ----------------------------------------------------------------------- |
| 35 | |
| 36 | void BufferQueueLayer::onLayerDisplayed(const sp<Fence>& releaseFence) { |
| 37 | mConsumer->setReleaseFence(releaseFence); |
| 38 | } |
| 39 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 40 | void BufferQueueLayer::setTransformHint(uint32_t orientation) const { |
| 41 | mConsumer->setTransformHint(orientation); |
| 42 | } |
| 43 | |
| 44 | std::vector<OccupancyTracker::Segment> BufferQueueLayer::getOccupancyHistory(bool forceFlush) { |
| 45 | std::vector<OccupancyTracker::Segment> history; |
| 46 | status_t result = mConsumer->getOccupancyHistory(forceFlush, &history); |
| 47 | if (result != NO_ERROR) { |
| 48 | ALOGW("[%s] Failed to obtain occupancy history (%d)", mName.string(), result); |
| 49 | return {}; |
| 50 | } |
| 51 | return history; |
| 52 | } |
| 53 | |
| 54 | bool BufferQueueLayer::getTransformToDisplayInverse() const { |
| 55 | return mConsumer->getTransformToDisplayInverse(); |
| 56 | } |
| 57 | |
| 58 | void BufferQueueLayer::releasePendingBuffer(nsecs_t dequeueReadyTime) { |
| 59 | if (!mConsumer->releasePendingBuffer()) { |
| 60 | return; |
| 61 | } |
| 62 | |
| 63 | auto releaseFenceTime = std::make_shared<FenceTime>(mConsumer->getPrevFinalReleaseFence()); |
| 64 | mReleaseTimeline.updateSignalTimes(); |
| 65 | mReleaseTimeline.push(releaseFenceTime); |
| 66 | |
| 67 | Mutex::Autolock lock(mFrameEventHistoryMutex); |
| 68 | if (mPreviousFrameNumber != 0) { |
| 69 | mFrameEventHistory.addRelease(mPreviousFrameNumber, dequeueReadyTime, |
| 70 | std::move(releaseFenceTime)); |
| 71 | } |
| 72 | } |
| 73 | |
| 74 | void BufferQueueLayer::setDefaultBufferSize(uint32_t w, uint32_t h) { |
| 75 | mConsumer->setDefaultBufferSize(w, h); |
| 76 | } |
| 77 | |
| 78 | int32_t BufferQueueLayer::getQueuedFrameCount() const { |
| 79 | return mQueuedFrames; |
| 80 | } |
| 81 | |
Ana Krulec | 010d219 | 2018-10-08 06:29:54 -0700 | [diff] [blame] | 82 | bool BufferQueueLayer::shouldPresentNow(nsecs_t expectedPresentTime) const { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 83 | if (getSidebandStreamChanged() || getAutoRefresh()) { |
| 84 | return true; |
| 85 | } |
| 86 | |
Marissa Wall | 024a191 | 2018-08-13 13:55:35 -0700 | [diff] [blame] | 87 | if (!hasFrameUpdate()) { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 88 | return false; |
| 89 | } |
| 90 | |
| 91 | Mutex::Autolock lock(mQueueItemLock); |
| 92 | |
| 93 | const int64_t addedTime = mQueueItems[0].mTimestamp; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 94 | |
| 95 | // Ignore timestamps more than a second in the future |
| 96 | const bool isPlausible = addedTime < (expectedPresentTime + s2ns(1)); |
| 97 | ALOGW_IF(!isPlausible, |
| 98 | "[%s] Timestamp %" PRId64 " seems implausible " |
| 99 | "relative to expectedPresent %" PRId64, |
| 100 | mName.string(), addedTime, expectedPresentTime); |
| 101 | |
| 102 | const bool isDue = addedTime < expectedPresentTime; |
| 103 | return isDue || !isPlausible; |
| 104 | } |
| 105 | |
| 106 | // ----------------------------------------------------------------------- |
| 107 | // Interface implementation for BufferLayer |
| 108 | // ----------------------------------------------------------------------- |
| 109 | |
| 110 | bool BufferQueueLayer::fenceHasSignaled() const { |
| 111 | if (latchUnsignaledBuffers()) { |
| 112 | return true; |
| 113 | } |
| 114 | |
Marissa Wall | 024a191 | 2018-08-13 13:55:35 -0700 | [diff] [blame] | 115 | if (!hasFrameUpdate()) { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 116 | return true; |
| 117 | } |
| 118 | |
| 119 | Mutex::Autolock lock(mQueueItemLock); |
| 120 | if (mQueueItems[0].mIsDroppable) { |
| 121 | // Even though this buffer's fence may not have signaled yet, it could |
| 122 | // be replaced by another buffer before it has a chance to, which means |
| 123 | // that it's possible to get into a situation where a buffer is never |
| 124 | // able to be latched. To avoid this, grab this buffer anyway. |
| 125 | return true; |
| 126 | } |
| 127 | return mQueueItems[0].mFenceTime->getSignalTime() != Fence::SIGNAL_TIME_PENDING; |
| 128 | } |
| 129 | |
| 130 | nsecs_t BufferQueueLayer::getDesiredPresentTime() { |
| 131 | return mConsumer->getTimestamp(); |
| 132 | } |
| 133 | |
| 134 | std::shared_ptr<FenceTime> BufferQueueLayer::getCurrentFenceTime() const { |
| 135 | return mConsumer->getCurrentFenceTime(); |
| 136 | } |
| 137 | |
Marissa Wall | 61c5862 | 2018-07-18 10:12:20 -0700 | [diff] [blame] | 138 | void BufferQueueLayer::getDrawingTransformMatrix(float *matrix) { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 139 | return mConsumer->getTransformMatrix(matrix); |
| 140 | } |
| 141 | |
| 142 | // NOTE: SurfaceFlinger's definitions of "Current" and "Drawing" do not neatly map to BufferQueue's |
| 143 | // These functions get the fields for the frame that is currently in SurfaceFlinger's Drawing state |
| 144 | // so the functions start with "getDrawing". The data is retrieved from the BufferQueueConsumer's |
| 145 | // current buffer so the consumer functions start with "getCurrent". |
| 146 | // |
| 147 | // This results in the rather confusing functions below. |
| 148 | uint32_t BufferQueueLayer::getDrawingTransform() const { |
| 149 | return mConsumer->getCurrentTransform(); |
| 150 | } |
| 151 | |
| 152 | ui::Dataspace BufferQueueLayer::getDrawingDataSpace() const { |
| 153 | return mConsumer->getCurrentDataSpace(); |
| 154 | } |
| 155 | |
| 156 | Rect BufferQueueLayer::getDrawingCrop() const { |
| 157 | return mConsumer->getCurrentCrop(); |
| 158 | } |
| 159 | |
| 160 | uint32_t BufferQueueLayer::getDrawingScalingMode() const { |
| 161 | return mConsumer->getCurrentScalingMode(); |
| 162 | } |
| 163 | |
| 164 | Region BufferQueueLayer::getDrawingSurfaceDamage() const { |
| 165 | return mConsumer->getSurfaceDamage(); |
| 166 | } |
| 167 | |
| 168 | const HdrMetadata& BufferQueueLayer::getDrawingHdrMetadata() const { |
| 169 | return mConsumer->getCurrentHdrMetadata(); |
| 170 | } |
| 171 | |
| 172 | int BufferQueueLayer::getDrawingApi() const { |
| 173 | return mConsumer->getCurrentApi(); |
| 174 | } |
| 175 | |
| 176 | PixelFormat BufferQueueLayer::getPixelFormat() const { |
| 177 | return mFormat; |
| 178 | } |
| 179 | |
| 180 | uint64_t BufferQueueLayer::getFrameNumber() const { |
| 181 | Mutex::Autolock lock(mQueueItemLock); |
| 182 | return mQueueItems[0].mFrameNumber; |
| 183 | } |
| 184 | |
| 185 | bool BufferQueueLayer::getAutoRefresh() const { |
| 186 | return mAutoRefresh; |
| 187 | } |
| 188 | |
| 189 | bool BufferQueueLayer::getSidebandStreamChanged() const { |
| 190 | return mSidebandStreamChanged; |
| 191 | } |
| 192 | |
| 193 | std::optional<Region> BufferQueueLayer::latchSidebandStream(bool& recomputeVisibleRegions) { |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 194 | bool sidebandStreamChanged = true; |
| 195 | if (mSidebandStreamChanged.compare_exchange_strong(sidebandStreamChanged, false)) { |
| 196 | // mSidebandStreamChanged was changed to false |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 197 | // replicated in LayerBE until FE/BE is ready to be synchronized |
| 198 | getBE().compositionInfo.hwc.sidebandStream = mConsumer->getSidebandStream(); |
| 199 | if (getBE().compositionInfo.hwc.sidebandStream != nullptr) { |
| 200 | setTransactionFlags(eTransactionNeeded); |
| 201 | mFlinger->setTransactionFlags(eTraversalNeeded); |
| 202 | } |
| 203 | recomputeVisibleRegions = true; |
| 204 | |
| 205 | const State& s(getDrawingState()); |
Marissa Wall | f58c14b | 2018-07-24 10:50:43 -0700 | [diff] [blame] | 206 | return getTransform().transform(Region(Rect(s.active_legacy.w, s.active_legacy.h))); |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 207 | } |
| 208 | return {}; |
| 209 | } |
| 210 | |
Marissa Wall | 024a191 | 2018-08-13 13:55:35 -0700 | [diff] [blame] | 211 | bool BufferQueueLayer::hasFrameUpdate() const { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 212 | return mQueuedFrames > 0; |
| 213 | } |
| 214 | |
Marissa Wall | 61c5862 | 2018-07-18 10:12:20 -0700 | [diff] [blame] | 215 | void BufferQueueLayer::setFilteringEnabled(bool enabled) { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 216 | return mConsumer->setFilteringEnabled(enabled); |
| 217 | } |
| 218 | |
Alec Mouri | 39801c0 | 2018-10-10 10:44:47 -0700 | [diff] [blame] | 219 | status_t BufferQueueLayer::bindTextureImage() { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 220 | return mConsumer->bindTextureImage(); |
| 221 | } |
| 222 | |
Alec Mouri | 86770e5 | 2018-09-24 22:40:58 +0000 | [diff] [blame] | 223 | status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime, |
| 224 | const sp<Fence>& releaseFence) { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 225 | // This boolean is used to make sure that SurfaceFlinger's shadow copy |
| 226 | // of the buffer queue isn't modified when the buffer queue is returning |
| 227 | // BufferItem's that weren't actually queued. This can happen in shared |
| 228 | // buffer mode. |
| 229 | bool queuedBuffer = false; |
Yiwei Zhang | 9689e2f | 2018-05-11 12:33:23 -0700 | [diff] [blame] | 230 | const int32_t layerID = getSequence(); |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 231 | LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions, |
| 232 | getProducerStickyTransform() != 0, mName.string(), mOverrideScalingMode, |
| 233 | getTransformToDisplayInverse(), mFreezeGeometryUpdates); |
Ana Krulec | e588e31 | 2018-09-18 12:32:24 -0700 | [diff] [blame] | 234 | |
| 235 | const nsecs_t expectedPresentTime = mFlinger->mUseScheduler |
| 236 | ? mFlinger->mScheduler->mPrimaryDispSync->expectedPresentTime() |
| 237 | : mFlinger->mPrimaryDispSync->expectedPresentTime(); |
Lloyd Pique | 41be5d2 | 2018-06-21 13:11:48 -0700 | [diff] [blame] | 238 | status_t updateResult = |
Ana Krulec | e588e31 | 2018-09-18 12:32:24 -0700 | [diff] [blame] | 239 | mConsumer->updateTexImage(&r, expectedPresentTime, &mAutoRefresh, &queuedBuffer, |
| 240 | mLastFrameNumberReceived, releaseFence); |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 241 | if (updateResult == BufferQueue::PRESENT_LATER) { |
| 242 | // Producer doesn't want buffer to be displayed yet. Signal a |
| 243 | // layer update so we check again at the next opportunity. |
| 244 | mFlinger->signalLayerUpdate(); |
| 245 | return BAD_VALUE; |
| 246 | } else if (updateResult == BufferLayerConsumer::BUFFER_REJECTED) { |
| 247 | // If the buffer has been rejected, remove it from the shadow queue |
| 248 | // and return early |
| 249 | if (queuedBuffer) { |
| 250 | Mutex::Autolock lock(mQueueItemLock); |
Yiwei Zhang | 7e666a5 | 2018-11-15 13:33:42 -0800 | [diff] [blame] | 251 | mFlinger->mTimeStats->removeTimeRecord(layerID, mQueueItems[0].mFrameNumber); |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 252 | mQueueItems.removeAt(0); |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 253 | mQueuedFrames--; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 254 | } |
| 255 | return BAD_VALUE; |
| 256 | } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { |
| 257 | // This can occur if something goes wrong when trying to create the |
| 258 | // EGLImage for this buffer. If this happens, the buffer has already |
| 259 | // been released, so we need to clean up the queue and bug out |
| 260 | // early. |
| 261 | if (queuedBuffer) { |
| 262 | Mutex::Autolock lock(mQueueItemLock); |
| 263 | mQueueItems.clear(); |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 264 | mQueuedFrames = 0; |
Yiwei Zhang | af8ee94 | 2018-11-22 00:15:23 -0800 | [diff] [blame^] | 265 | mFlinger->mTimeStats->onDestroy(layerID); |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 266 | } |
| 267 | |
| 268 | // Once we have hit this state, the shadow queue may no longer |
| 269 | // correctly reflect the incoming BufferQueue's contents, so even if |
| 270 | // updateTexImage starts working, the only safe course of action is |
| 271 | // to continue to ignore updates. |
| 272 | mUpdateTexImageFailed = true; |
| 273 | |
| 274 | return BAD_VALUE; |
| 275 | } |
| 276 | |
| 277 | if (queuedBuffer) { |
| 278 | // Autolock scope |
| 279 | auto currentFrameNumber = mConsumer->getFrameNumber(); |
| 280 | |
| 281 | Mutex::Autolock lock(mQueueItemLock); |
| 282 | |
| 283 | // Remove any stale buffers that have been dropped during |
| 284 | // updateTexImage |
| 285 | while (mQueueItems[0].mFrameNumber != currentFrameNumber) { |
Yiwei Zhang | 7e666a5 | 2018-11-15 13:33:42 -0800 | [diff] [blame] | 286 | mFlinger->mTimeStats->removeTimeRecord(layerID, mQueueItems[0].mFrameNumber); |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 287 | mQueueItems.removeAt(0); |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 288 | mQueuedFrames--; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 289 | } |
| 290 | |
Yiwei Zhang | 7e666a5 | 2018-11-15 13:33:42 -0800 | [diff] [blame] | 291 | mFlinger->mTimeStats->setAcquireFence(layerID, currentFrameNumber, |
| 292 | mQueueItems[0].mFenceTime); |
| 293 | mFlinger->mTimeStats->setLatchTime(layerID, currentFrameNumber, latchTime); |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 294 | |
| 295 | mQueueItems.removeAt(0); |
| 296 | } |
| 297 | |
| 298 | // Decrement the queued-frames count. Signal another event if we |
| 299 | // have more frames pending. |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 300 | if ((queuedBuffer && mQueuedFrames.fetch_sub(1) > 1) || mAutoRefresh) { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 301 | mFlinger->signalLayerUpdate(); |
| 302 | } |
| 303 | |
| 304 | return NO_ERROR; |
| 305 | } |
| 306 | |
| 307 | status_t BufferQueueLayer::updateActiveBuffer() { |
| 308 | // update the active buffer |
| 309 | mActiveBuffer = mConsumer->getCurrentBuffer(&mActiveBufferSlot); |
| 310 | getBE().compositionInfo.mBuffer = mActiveBuffer; |
| 311 | getBE().compositionInfo.mBufferSlot = mActiveBufferSlot; |
| 312 | |
| 313 | if (mActiveBuffer == nullptr) { |
| 314 | // this can only happen if the very first buffer was rejected. |
| 315 | return BAD_VALUE; |
| 316 | } |
| 317 | return NO_ERROR; |
| 318 | } |
| 319 | |
| 320 | status_t BufferQueueLayer::updateFrameNumber(nsecs_t latchTime) { |
| 321 | mPreviousFrameNumber = mCurrentFrameNumber; |
| 322 | mCurrentFrameNumber = mConsumer->getFrameNumber(); |
| 323 | |
| 324 | { |
| 325 | Mutex::Autolock lock(mFrameEventHistoryMutex); |
| 326 | mFrameEventHistory.addLatch(mCurrentFrameNumber, latchTime); |
| 327 | } |
| 328 | return NO_ERROR; |
| 329 | } |
| 330 | |
Dominik Laskowski | 075d317 | 2018-05-24 15:50:06 -0700 | [diff] [blame] | 331 | void BufferQueueLayer::setHwcLayerBuffer(DisplayId displayId) { |
David Sodman | 1509411 | 2018-10-11 09:39:37 -0700 | [diff] [blame] | 332 | auto& hwcInfo = getBE().mHwcLayers[displayId]; |
| 333 | auto& hwcLayer = hwcInfo.layer; |
| 334 | |
| 335 | uint32_t hwcSlot = 0; |
| 336 | sp<GraphicBuffer> hwcBuffer; |
| 337 | hwcInfo.bufferCache.getHwcBuffer(mActiveBufferSlot, mActiveBuffer, &hwcSlot, &hwcBuffer); |
| 338 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 339 | auto acquireFence = mConsumer->getCurrentFence(); |
David Sodman | 1509411 | 2018-10-11 09:39:37 -0700 | [diff] [blame] | 340 | auto error = hwcLayer->setBuffer(hwcSlot, hwcBuffer, acquireFence); |
| 341 | if (error != HWC2::Error::None) { |
| 342 | ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(), |
| 343 | getBE().compositionInfo.mBuffer->handle, to_string(error).c_str(), |
| 344 | static_cast<int32_t>(error)); |
| 345 | } |
David Sodman | ba34049 | 2018-08-05 21:51:33 -0700 | [diff] [blame] | 346 | getBE().compositionInfo.mBufferSlot = mActiveBufferSlot; |
| 347 | getBE().compositionInfo.mBuffer = mActiveBuffer; |
| 348 | getBE().compositionInfo.hwc.fence = acquireFence; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 349 | } |
| 350 | |
| 351 | // ----------------------------------------------------------------------- |
| 352 | // Interface implementation for BufferLayerConsumer::ContentsChangedListener |
| 353 | // ----------------------------------------------------------------------- |
| 354 | |
| 355 | void BufferQueueLayer::onFrameAvailable(const BufferItem& item) { |
| 356 | // Add this buffer from our internal queue tracker |
| 357 | { // Autolock scope |
Ana Krulec | 3084c05 | 2018-11-21 20:27:17 +0100 | [diff] [blame] | 358 | // Report the requested present time to the Scheduler. |
Ana Krulec | 7ab5603 | 2018-11-02 20:51:06 +0100 | [diff] [blame] | 359 | if (mFlinger->mUseScheduler) { |
Ana Krulec | 3084c05 | 2018-11-21 20:27:17 +0100 | [diff] [blame] | 360 | mFlinger->mScheduler->addFramePresentTimeForLayer(item.mTimestamp, |
| 361 | item.mIsAutoTimestamp, mName.c_str()); |
Ana Krulec | 7ab5603 | 2018-11-02 20:51:06 +0100 | [diff] [blame] | 362 | } |
| 363 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 364 | Mutex::Autolock lock(mQueueItemLock); |
| 365 | // Reset the frame number tracker when we receive the first buffer after |
| 366 | // a frame number reset |
| 367 | if (item.mFrameNumber == 1) { |
| 368 | mLastFrameNumberReceived = 0; |
| 369 | } |
| 370 | |
| 371 | // Ensure that callbacks are handled in order |
| 372 | while (item.mFrameNumber != mLastFrameNumberReceived + 1) { |
| 373 | status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500)); |
| 374 | if (result != NO_ERROR) { |
| 375 | ALOGE("[%s] Timed out waiting on callback", mName.string()); |
| 376 | } |
| 377 | } |
| 378 | |
| 379 | mQueueItems.push_back(item); |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 380 | mQueuedFrames++; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 381 | |
| 382 | // Wake up any pending callbacks |
| 383 | mLastFrameNumberReceived = item.mFrameNumber; |
| 384 | mQueueItemCondition.broadcast(); |
| 385 | } |
| 386 | |
| 387 | mFlinger->mInterceptor->saveBufferUpdate(this, item.mGraphicBuffer->getWidth(), |
| 388 | item.mGraphicBuffer->getHeight(), item.mFrameNumber); |
Ana Krulec | 3084c05 | 2018-11-21 20:27:17 +0100 | [diff] [blame] | 389 | |
Robert Carr | 2e102c9 | 2018-10-23 12:11:15 -0700 | [diff] [blame] | 390 | // If this layer is orphaned, then we run a fake vsync pulse so that |
| 391 | // dequeueBuffer doesn't block indefinitely. |
| 392 | if (isRemovedFromCurrentState()) { |
| 393 | bool ignored = false; |
| 394 | latchBuffer(ignored, systemTime(), Fence::NO_FENCE); |
| 395 | usleep(16000); |
| 396 | releasePendingBuffer(systemTime()); |
| 397 | } else { |
| 398 | mFlinger->signalLayerUpdate(); |
| 399 | } |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 400 | } |
| 401 | |
| 402 | void BufferQueueLayer::onFrameReplaced(const BufferItem& item) { |
| 403 | { // Autolock scope |
| 404 | Mutex::Autolock lock(mQueueItemLock); |
| 405 | |
| 406 | // Ensure that callbacks are handled in order |
| 407 | while (item.mFrameNumber != mLastFrameNumberReceived + 1) { |
| 408 | status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500)); |
| 409 | if (result != NO_ERROR) { |
| 410 | ALOGE("[%s] Timed out waiting on callback", mName.string()); |
| 411 | } |
| 412 | } |
| 413 | |
Marissa Wall | 024a191 | 2018-08-13 13:55:35 -0700 | [diff] [blame] | 414 | if (!hasFrameUpdate()) { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 415 | ALOGE("Can't replace a frame on an empty queue"); |
| 416 | return; |
| 417 | } |
| 418 | mQueueItems.editItemAt(mQueueItems.size() - 1) = item; |
| 419 | |
| 420 | // Wake up any pending callbacks |
| 421 | mLastFrameNumberReceived = item.mFrameNumber; |
| 422 | mQueueItemCondition.broadcast(); |
| 423 | } |
| 424 | } |
| 425 | |
| 426 | void BufferQueueLayer::onSidebandStreamChanged() { |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 427 | bool sidebandStreamChanged = false; |
| 428 | if (mSidebandStreamChanged.compare_exchange_strong(sidebandStreamChanged, true)) { |
| 429 | // mSidebandStreamChanged was changed to true |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 430 | mFlinger->signalLayerUpdate(); |
| 431 | } |
| 432 | } |
| 433 | |
| 434 | // ----------------------------------------------------------------------- |
| 435 | |
| 436 | void BufferQueueLayer::onFirstRef() { |
Dan Stoza | 7b1b5a8 | 2018-07-31 16:00:21 -0700 | [diff] [blame] | 437 | BufferLayer::onFirstRef(); |
| 438 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 439 | // Creates a custom BufferQueue for SurfaceFlingerConsumer to use |
| 440 | sp<IGraphicBufferProducer> producer; |
| 441 | sp<IGraphicBufferConsumer> consumer; |
| 442 | BufferQueue::createBufferQueue(&producer, &consumer, true); |
| 443 | mProducer = new MonitoredProducer(producer, mFlinger, this); |
| 444 | { |
| 445 | // Grab the SF state lock during this since it's the only safe way to access RenderEngine |
| 446 | Mutex::Autolock lock(mFlinger->mStateLock); |
| 447 | mConsumer = |
| 448 | new BufferLayerConsumer(consumer, mFlinger->getRenderEngine(), mTextureName, this); |
| 449 | } |
| 450 | mConsumer->setConsumerUsageBits(getEffectiveUsage(0)); |
| 451 | mConsumer->setContentsChangedListener(this); |
| 452 | mConsumer->setName(mName); |
| 453 | |
| 454 | if (mFlinger->isLayerTripleBufferingDisabled()) { |
| 455 | mProducer->setMaxDequeuedBufferCount(2); |
| 456 | } |
Marissa Wall | 6b9225a | 2018-09-11 14:19:32 -0700 | [diff] [blame] | 457 | |
| 458 | if (const auto display = mFlinger->getDefaultDisplayDevice()) { |
| 459 | updateTransformHint(display); |
| 460 | } |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 461 | } |
| 462 | |
| 463 | status_t BufferQueueLayer::setDefaultBufferProperties(uint32_t w, uint32_t h, PixelFormat format) { |
| 464 | uint32_t const maxSurfaceDims = |
Peiyong Lin | 3db4234 | 2018-08-16 09:15:59 -0700 | [diff] [blame] | 465 | std::min(mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 466 | |
| 467 | // never allow a surface larger than what our underlying GL implementation |
| 468 | // can handle. |
| 469 | if ((uint32_t(w) > maxSurfaceDims) || (uint32_t(h) > maxSurfaceDims)) { |
| 470 | ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); |
| 471 | return BAD_VALUE; |
| 472 | } |
| 473 | |
| 474 | mFormat = format; |
| 475 | |
| 476 | setDefaultBufferSize(w, h); |
| 477 | mConsumer->setDefaultBufferFormat(format); |
| 478 | mConsumer->setConsumerUsageBits(getEffectiveUsage(0)); |
| 479 | |
| 480 | return NO_ERROR; |
| 481 | } |
| 482 | |
| 483 | sp<IGraphicBufferProducer> BufferQueueLayer::getProducer() const { |
| 484 | return mProducer; |
| 485 | } |
| 486 | |
| 487 | uint32_t BufferQueueLayer::getProducerStickyTransform() const { |
| 488 | int producerStickyTransform = 0; |
| 489 | int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform); |
| 490 | if (ret != OK) { |
| 491 | ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__, |
| 492 | strerror(-ret), ret); |
| 493 | return 0; |
| 494 | } |
| 495 | return static_cast<uint32_t>(producerStickyTransform); |
| 496 | } |
| 497 | |
| 498 | } // namespace android |