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 | |
Lloyd Pique | 42ab75e | 2018-09-12 20:46:03 -0700 | [diff] [blame] | 24 | BufferQueueLayer::BufferQueueLayer(const LayerCreationArgs& args) : BufferLayer(args) {} |
| 25 | |
| 26 | BufferQueueLayer::~BufferQueueLayer() = default; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 27 | |
| 28 | // ----------------------------------------------------------------------- |
| 29 | // Interface implementation for Layer |
| 30 | // ----------------------------------------------------------------------- |
| 31 | |
| 32 | void BufferQueueLayer::onLayerDisplayed(const sp<Fence>& releaseFence) { |
| 33 | mConsumer->setReleaseFence(releaseFence); |
| 34 | } |
| 35 | |
| 36 | void BufferQueueLayer::abandon() { |
| 37 | mConsumer->abandon(); |
| 38 | } |
| 39 | |
| 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 | |
| 87 | if (!hasDrawingBuffer()) { |
| 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 | |
| 115 | if (!hasDrawingBuffer()) { |
| 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 | |
| 211 | bool BufferQueueLayer::hasDrawingBuffer() const { |
| 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 | |
| 219 | status_t BufferQueueLayer::bindTextureImage() const { |
| 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; |
| 230 | LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions, |
| 231 | getProducerStickyTransform() != 0, mName.string(), mOverrideScalingMode, |
| 232 | getTransformToDisplayInverse(), mFreezeGeometryUpdates); |
Lloyd Pique | 41be5d2 | 2018-06-21 13:11:48 -0700 | [diff] [blame] | 233 | status_t updateResult = |
Ana Krulec | 010d219 | 2018-10-08 06:29:54 -0700 | [diff] [blame^] | 234 | mConsumer->updateTexImage(&r, mFlinger->mPrimaryDispSync->expectedPresentTime(), |
| 235 | &mAutoRefresh, &queuedBuffer, mLastFrameNumberReceived, |
| 236 | releaseFence); |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 237 | if (updateResult == BufferQueue::PRESENT_LATER) { |
| 238 | // Producer doesn't want buffer to be displayed yet. Signal a |
| 239 | // layer update so we check again at the next opportunity. |
| 240 | mFlinger->signalLayerUpdate(); |
| 241 | return BAD_VALUE; |
| 242 | } else if (updateResult == BufferLayerConsumer::BUFFER_REJECTED) { |
| 243 | // If the buffer has been rejected, remove it from the shadow queue |
| 244 | // and return early |
| 245 | if (queuedBuffer) { |
| 246 | Mutex::Autolock lock(mQueueItemLock); |
| 247 | mTimeStats.removeTimeRecord(getName().c_str(), mQueueItems[0].mFrameNumber); |
| 248 | mQueueItems.removeAt(0); |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 249 | mQueuedFrames--; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 250 | } |
| 251 | return BAD_VALUE; |
| 252 | } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { |
| 253 | // This can occur if something goes wrong when trying to create the |
| 254 | // EGLImage for this buffer. If this happens, the buffer has already |
| 255 | // been released, so we need to clean up the queue and bug out |
| 256 | // early. |
| 257 | if (queuedBuffer) { |
| 258 | Mutex::Autolock lock(mQueueItemLock); |
| 259 | mQueueItems.clear(); |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 260 | mQueuedFrames = 0; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 261 | mTimeStats.clearLayerRecord(getName().c_str()); |
| 262 | } |
| 263 | |
| 264 | // Once we have hit this state, the shadow queue may no longer |
| 265 | // correctly reflect the incoming BufferQueue's contents, so even if |
| 266 | // updateTexImage starts working, the only safe course of action is |
| 267 | // to continue to ignore updates. |
| 268 | mUpdateTexImageFailed = true; |
| 269 | |
| 270 | return BAD_VALUE; |
| 271 | } |
| 272 | |
| 273 | if (queuedBuffer) { |
| 274 | // Autolock scope |
| 275 | auto currentFrameNumber = mConsumer->getFrameNumber(); |
| 276 | |
| 277 | Mutex::Autolock lock(mQueueItemLock); |
| 278 | |
| 279 | // Remove any stale buffers that have been dropped during |
| 280 | // updateTexImage |
| 281 | while (mQueueItems[0].mFrameNumber != currentFrameNumber) { |
| 282 | mTimeStats.removeTimeRecord(getName().c_str(), mQueueItems[0].mFrameNumber); |
| 283 | mQueueItems.removeAt(0); |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 284 | mQueuedFrames--; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 285 | } |
| 286 | |
| 287 | const std::string layerName(getName().c_str()); |
| 288 | mTimeStats.setAcquireFence(layerName, currentFrameNumber, mQueueItems[0].mFenceTime); |
| 289 | mTimeStats.setLatchTime(layerName, currentFrameNumber, latchTime); |
| 290 | |
| 291 | mQueueItems.removeAt(0); |
| 292 | } |
| 293 | |
| 294 | // Decrement the queued-frames count. Signal another event if we |
| 295 | // have more frames pending. |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 296 | if ((queuedBuffer && mQueuedFrames.fetch_sub(1) > 1) || mAutoRefresh) { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 297 | mFlinger->signalLayerUpdate(); |
| 298 | } |
| 299 | |
| 300 | return NO_ERROR; |
| 301 | } |
| 302 | |
| 303 | status_t BufferQueueLayer::updateActiveBuffer() { |
| 304 | // update the active buffer |
| 305 | mActiveBuffer = mConsumer->getCurrentBuffer(&mActiveBufferSlot); |
| 306 | getBE().compositionInfo.mBuffer = mActiveBuffer; |
| 307 | getBE().compositionInfo.mBufferSlot = mActiveBufferSlot; |
| 308 | |
| 309 | if (mActiveBuffer == nullptr) { |
| 310 | // this can only happen if the very first buffer was rejected. |
| 311 | return BAD_VALUE; |
| 312 | } |
| 313 | return NO_ERROR; |
| 314 | } |
| 315 | |
| 316 | status_t BufferQueueLayer::updateFrameNumber(nsecs_t latchTime) { |
| 317 | mPreviousFrameNumber = mCurrentFrameNumber; |
| 318 | mCurrentFrameNumber = mConsumer->getFrameNumber(); |
| 319 | |
| 320 | { |
| 321 | Mutex::Autolock lock(mFrameEventHistoryMutex); |
| 322 | mFrameEventHistory.addLatch(mCurrentFrameNumber, latchTime); |
| 323 | } |
| 324 | return NO_ERROR; |
| 325 | } |
| 326 | |
David Sodman | 10a41ff | 2018-08-05 12:14:17 -0700 | [diff] [blame] | 327 | void BufferQueueLayer::setHwcLayerBuffer(const sp<const DisplayDevice>&) { |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 328 | auto acquireFence = mConsumer->getCurrentFence(); |
David Sodman | ba34049 | 2018-08-05 21:51:33 -0700 | [diff] [blame] | 329 | getBE().compositionInfo.mBufferSlot = mActiveBufferSlot; |
| 330 | getBE().compositionInfo.mBuffer = mActiveBuffer; |
| 331 | getBE().compositionInfo.hwc.fence = acquireFence; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 332 | } |
| 333 | |
| 334 | // ----------------------------------------------------------------------- |
| 335 | // Interface implementation for BufferLayerConsumer::ContentsChangedListener |
| 336 | // ----------------------------------------------------------------------- |
| 337 | |
| 338 | void BufferQueueLayer::onFrameAvailable(const BufferItem& item) { |
| 339 | // Add this buffer from our internal queue tracker |
| 340 | { // Autolock scope |
| 341 | Mutex::Autolock lock(mQueueItemLock); |
| 342 | // Reset the frame number tracker when we receive the first buffer after |
| 343 | // a frame number reset |
| 344 | if (item.mFrameNumber == 1) { |
| 345 | mLastFrameNumberReceived = 0; |
| 346 | } |
| 347 | |
| 348 | // Ensure that callbacks are handled in order |
| 349 | while (item.mFrameNumber != mLastFrameNumberReceived + 1) { |
| 350 | status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500)); |
| 351 | if (result != NO_ERROR) { |
| 352 | ALOGE("[%s] Timed out waiting on callback", mName.string()); |
| 353 | } |
| 354 | } |
| 355 | |
| 356 | mQueueItems.push_back(item); |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 357 | mQueuedFrames++; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 358 | |
| 359 | // Wake up any pending callbacks |
| 360 | mLastFrameNumberReceived = item.mFrameNumber; |
| 361 | mQueueItemCondition.broadcast(); |
| 362 | } |
| 363 | |
| 364 | mFlinger->mInterceptor->saveBufferUpdate(this, item.mGraphicBuffer->getWidth(), |
| 365 | item.mGraphicBuffer->getHeight(), item.mFrameNumber); |
| 366 | mFlinger->signalLayerUpdate(); |
| 367 | } |
| 368 | |
| 369 | void BufferQueueLayer::onFrameReplaced(const BufferItem& item) { |
| 370 | { // Autolock scope |
| 371 | Mutex::Autolock lock(mQueueItemLock); |
| 372 | |
| 373 | // Ensure that callbacks are handled in order |
| 374 | while (item.mFrameNumber != mLastFrameNumberReceived + 1) { |
| 375 | status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500)); |
| 376 | if (result != NO_ERROR) { |
| 377 | ALOGE("[%s] Timed out waiting on callback", mName.string()); |
| 378 | } |
| 379 | } |
| 380 | |
| 381 | if (!hasDrawingBuffer()) { |
| 382 | ALOGE("Can't replace a frame on an empty queue"); |
| 383 | return; |
| 384 | } |
| 385 | mQueueItems.editItemAt(mQueueItems.size() - 1) = item; |
| 386 | |
| 387 | // Wake up any pending callbacks |
| 388 | mLastFrameNumberReceived = item.mFrameNumber; |
| 389 | mQueueItemCondition.broadcast(); |
| 390 | } |
| 391 | } |
| 392 | |
| 393 | void BufferQueueLayer::onSidebandStreamChanged() { |
Lloyd Pique | f1c675b | 2018-09-12 20:45:39 -0700 | [diff] [blame] | 394 | bool sidebandStreamChanged = false; |
| 395 | if (mSidebandStreamChanged.compare_exchange_strong(sidebandStreamChanged, true)) { |
| 396 | // mSidebandStreamChanged was changed to true |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 397 | mFlinger->signalLayerUpdate(); |
| 398 | } |
| 399 | } |
| 400 | |
| 401 | // ----------------------------------------------------------------------- |
| 402 | |
| 403 | void BufferQueueLayer::onFirstRef() { |
Dan Stoza | 7b1b5a8 | 2018-07-31 16:00:21 -0700 | [diff] [blame] | 404 | BufferLayer::onFirstRef(); |
| 405 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 406 | // Creates a custom BufferQueue for SurfaceFlingerConsumer to use |
| 407 | sp<IGraphicBufferProducer> producer; |
| 408 | sp<IGraphicBufferConsumer> consumer; |
| 409 | BufferQueue::createBufferQueue(&producer, &consumer, true); |
| 410 | mProducer = new MonitoredProducer(producer, mFlinger, this); |
| 411 | { |
| 412 | // Grab the SF state lock during this since it's the only safe way to access RenderEngine |
| 413 | Mutex::Autolock lock(mFlinger->mStateLock); |
| 414 | mConsumer = |
| 415 | new BufferLayerConsumer(consumer, mFlinger->getRenderEngine(), mTextureName, this); |
| 416 | } |
| 417 | mConsumer->setConsumerUsageBits(getEffectiveUsage(0)); |
| 418 | mConsumer->setContentsChangedListener(this); |
| 419 | mConsumer->setName(mName); |
| 420 | |
| 421 | if (mFlinger->isLayerTripleBufferingDisabled()) { |
| 422 | mProducer->setMaxDequeuedBufferCount(2); |
| 423 | } |
Marissa Wall | 6b9225a | 2018-09-11 14:19:32 -0700 | [diff] [blame] | 424 | |
| 425 | if (const auto display = mFlinger->getDefaultDisplayDevice()) { |
| 426 | updateTransformHint(display); |
| 427 | } |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 428 | } |
| 429 | |
| 430 | status_t BufferQueueLayer::setDefaultBufferProperties(uint32_t w, uint32_t h, PixelFormat format) { |
| 431 | uint32_t const maxSurfaceDims = |
Peiyong Lin | 3db4234 | 2018-08-16 09:15:59 -0700 | [diff] [blame] | 432 | std::min(mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 433 | |
| 434 | // never allow a surface larger than what our underlying GL implementation |
| 435 | // can handle. |
| 436 | if ((uint32_t(w) > maxSurfaceDims) || (uint32_t(h) > maxSurfaceDims)) { |
| 437 | ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); |
| 438 | return BAD_VALUE; |
| 439 | } |
| 440 | |
| 441 | mFormat = format; |
| 442 | |
| 443 | setDefaultBufferSize(w, h); |
| 444 | mConsumer->setDefaultBufferFormat(format); |
| 445 | mConsumer->setConsumerUsageBits(getEffectiveUsage(0)); |
| 446 | |
| 447 | return NO_ERROR; |
| 448 | } |
| 449 | |
| 450 | sp<IGraphicBufferProducer> BufferQueueLayer::getProducer() const { |
| 451 | return mProducer; |
| 452 | } |
| 453 | |
| 454 | uint32_t BufferQueueLayer::getProducerStickyTransform() const { |
| 455 | int producerStickyTransform = 0; |
| 456 | int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform); |
| 457 | if (ret != OK) { |
| 458 | ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__, |
| 459 | strerror(-ret), ret); |
| 460 | return 0; |
| 461 | } |
| 462 | return static_cast<uint32_t>(producerStickyTransform); |
| 463 | } |
| 464 | |
| 465 | } // namespace android |