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