1/* 2 * Copyright (C) 2017 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//#define LOG_NDEBUG 0 18#undef LOG_TAG 19#define LOG_TAG "BufferLayer" 20#define ATRACE_TAG ATRACE_TAG_GRAPHICS 21 22#include "BufferLayer.h" 23#include "Colorizer.h" 24#include "DisplayDevice.h" 25#include "LayerRejecter.h" 26#include "clz.h" 27 28#include "RenderEngine/RenderEngine.h" 29 30#include <gui/BufferItem.h> 31#include <gui/BufferQueue.h> 32#include <gui/LayerDebugInfo.h> 33#include <gui/Surface.h> 34 35#include <ui/DebugUtils.h> 36 37#include <utils/Errors.h> 38#include <utils/Log.h> 39#include <utils/NativeHandle.h> 40#include <utils/StopWatch.h> 41#include <utils/Trace.h> 42 43#include <cutils/compiler.h> 44#include <cutils/native_handle.h> 45#include <cutils/properties.h> 46 47#include <math.h> 48#include <stdlib.h> 49#include <mutex> 50 51namespace android { 52 53BufferLayer::BufferLayer(SurfaceFlinger* flinger, const sp<Client>& client, const String8& name, 54 uint32_t w, uint32_t h, uint32_t flags) 55 : Layer(flinger, client, name, w, h, flags), 56 mConsumer(nullptr), 57 mTextureName(UINT32_MAX), 58 mFormat(PIXEL_FORMAT_NONE), 59 mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), 60 mBufferLatched(false), 61 mPreviousFrameNumber(0), 62 mUpdateTexImageFailed(false), 63 mRefreshPending(false) { 64 ALOGV("Creating Layer %s", name.string()); 65 66 mFlinger->getRenderEngine().genTextures(1, &mTextureName); 67 mTexture.init(Texture::TEXTURE_EXTERNAL, mTextureName); 68 69 if (flags & ISurfaceComposerClient::eNonPremultiplied) mPremultipliedAlpha = false; 70 71 mCurrentState.requested = mCurrentState.active; 72 73 // drawing state & current state are identical 74 mDrawingState = mCurrentState; 75} 76 77BufferLayer::~BufferLayer() { 78 mFlinger->deleteTextureAsync(mTextureName); 79 80 if (!getBE().mHwcLayers.empty()) { 81 ALOGE("Found stale hardware composer layers when destroying " 82 "surface flinger layer %s", 83 mName.string()); 84 destroyAllHwcLayers(); 85 } 86} 87 88void BufferLayer::useSurfaceDamage() { 89 if (mFlinger->mForceFullDamage) { 90 surfaceDamageRegion = Region::INVALID_REGION; 91 } else { 92 surfaceDamageRegion = mConsumer->getSurfaceDamage(); 93 } 94} 95 96void BufferLayer::useEmptyDamage() { 97 surfaceDamageRegion.clear(); 98} 99 100bool BufferLayer::isProtected() const { 101 const sp<GraphicBuffer>& buffer(getBE().compositionInfo.mBuffer); 102 return (buffer != 0) && 103 (buffer->getUsage() & GRALLOC_USAGE_PROTECTED); 104} 105 106bool BufferLayer::isVisible() const { 107 return !(isHiddenByPolicy()) && getAlpha() > 0.0f && 108 (getBE().compositionInfo.mBuffer != nullptr || 109 getBE().compositionInfo.hwc.sidebandStream != nullptr); 110} 111 112bool BufferLayer::isFixedSize() const { 113 return getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE; 114} 115 116status_t BufferLayer::setBuffers(uint32_t w, uint32_t h, PixelFormat format, uint32_t flags) { 117 uint32_t const maxSurfaceDims = 118 min(mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); 119 120 // never allow a surface larger than what our underlying GL implementation 121 // can handle. 122 if ((uint32_t(w) > maxSurfaceDims) || (uint32_t(h) > maxSurfaceDims)) { 123 ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); 124 return BAD_VALUE; 125 } 126 127 mFormat = format; 128 129 mPotentialCursor = (flags & ISurfaceComposerClient::eCursorWindow) ? true : false; 130 mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; 131 mCurrentOpacity = getOpacityForFormat(format); 132 133 mConsumer->setDefaultBufferSize(w, h); 134 mConsumer->setDefaultBufferFormat(format); 135 mConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 136 137 return NO_ERROR; 138} 139 140static constexpr mat4 inverseOrientation(uint32_t transform) { 141 const mat4 flipH(-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1); 142 const mat4 flipV(1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1); 143 const mat4 rot90(0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1); 144 mat4 tr; 145 146 if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 147 tr = tr * rot90; 148 } 149 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H) { 150 tr = tr * flipH; 151 } 152 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V) { 153 tr = tr * flipV; 154 } 155 return inverse(tr); 156} 157 158/* 159 * onDraw will draw the current layer onto the presentable buffer 160 */ 161void BufferLayer::onDraw(const RenderArea& renderArea, const Region& clip, 162 bool useIdentityTransform) const { 163 ATRACE_CALL(); 164 165 if (CC_UNLIKELY(getBE().compositionInfo.mBuffer == 0)) { 166 // the texture has not been created yet, this Layer has 167 // in fact never been drawn into. This happens frequently with 168 // SurfaceView because the WindowManager can't know when the client 169 // has drawn the first time. 170 171 // If there is nothing under us, we paint the screen in black, otherwise 172 // we just skip this update. 173 174 // figure out if there is something below us 175 Region under; 176 bool finished = false; 177 mFlinger->mDrawingState.traverseInZOrder([&](Layer* layer) { 178 if (finished || layer == static_cast<BufferLayer const*>(this)) { 179 finished = true; 180 return; 181 } 182 under.orSelf(renderArea.getTransform().transform(layer->visibleRegion)); 183 }); 184 // if not everything below us is covered, we plug the holes! 185 Region holes(clip.subtract(under)); 186 if (!holes.isEmpty()) { 187 clearWithOpenGL(renderArea, 0, 0, 0, 1); 188 } 189 return; 190 } 191 192 // Bind the current buffer to the GL texture, and wait for it to be 193 // ready for us to draw into. 194 status_t err = mConsumer->bindTextureImage(); 195 if (err != NO_ERROR) { 196 ALOGW("onDraw: bindTextureImage failed (err=%d)", err); 197 // Go ahead and draw the buffer anyway; no matter what we do the screen 198 // is probably going to have something visibly wrong. 199 } 200 201 bool blackOutLayer = isProtected() || (isSecure() && !renderArea.isSecure()); 202 203 auto& engine(mFlinger->getRenderEngine()); 204 205 if (!blackOutLayer) { 206 // TODO: we could be more subtle with isFixedSize() 207 const bool useFiltering = getFiltering() || needsFiltering(renderArea) || isFixedSize(); 208 209 // Query the texture matrix given our current filtering mode. 210 float textureMatrix[16]; 211 mConsumer->setFilteringEnabled(useFiltering); 212 mConsumer->getTransformMatrix(textureMatrix); 213 214 if (getTransformToDisplayInverse()) { 215 /* 216 * the code below applies the primary display's inverse transform to 217 * the texture transform 218 */ 219 uint32_t transform = DisplayDevice::getPrimaryDisplayOrientationTransform(); 220 mat4 tr = inverseOrientation(transform); 221 222 /** 223 * TODO(b/36727915): This is basically a hack. 224 * 225 * Ensure that regardless of the parent transformation, 226 * this buffer is always transformed from native display 227 * orientation to display orientation. For example, in the case 228 * of a camera where the buffer remains in native orientation, 229 * we want the pixels to always be upright. 230 */ 231 sp<Layer> p = mDrawingParent.promote(); 232 if (p != nullptr) { 233 const auto parentTransform = p->getTransform(); 234 tr = tr * inverseOrientation(parentTransform.getOrientation()); 235 } 236 237 // and finally apply it to the original texture matrix 238 const mat4 texTransform(mat4(static_cast<const float*>(textureMatrix)) * tr); 239 memcpy(textureMatrix, texTransform.asArray(), sizeof(textureMatrix)); 240 } 241 242 // Set things up for texturing. 243 mTexture.setDimensions(getBE().compositionInfo.mBuffer->getWidth(), 244 getBE().compositionInfo.mBuffer->getHeight()); 245 mTexture.setFiltering(useFiltering); 246 mTexture.setMatrix(textureMatrix); 247 248 engine.setupLayerTexturing(mTexture); 249 } else { 250 engine.setupLayerBlackedOut(); 251 } 252 drawWithOpenGL(renderArea, useIdentityTransform); 253 engine.disableTexturing(); 254} 255 256void BufferLayer::onLayerDisplayed(const sp<Fence>& releaseFence) { 257 mConsumer->setReleaseFence(releaseFence); 258} 259 260void BufferLayer::abandon() { 261 mConsumer->abandon(); 262} 263 264bool BufferLayer::shouldPresentNow(const DispSync& dispSync) const { 265 if (mSidebandStreamChanged || mAutoRefresh) { 266 return true; 267 } 268 269 Mutex::Autolock lock(mQueueItemLock); 270 if (mQueueItems.empty()) { 271 return false; 272 } 273 auto timestamp = mQueueItems[0].mTimestamp; 274 nsecs_t expectedPresent = mConsumer->computeExpectedPresent(dispSync); 275 276 // Ignore timestamps more than a second in the future 277 bool isPlausible = timestamp < (expectedPresent + s2ns(1)); 278 ALOGW_IF(!isPlausible, 279 "[%s] Timestamp %" PRId64 " seems implausible " 280 "relative to expectedPresent %" PRId64, 281 mName.string(), timestamp, expectedPresent); 282 283 bool isDue = timestamp < expectedPresent; 284 return isDue || !isPlausible; 285} 286 287void BufferLayer::setTransformHint(uint32_t orientation) const { 288 mConsumer->setTransformHint(orientation); 289} 290 291bool BufferLayer::onPreComposition(nsecs_t refreshStartTime) { 292 if (mBufferLatched) { 293 Mutex::Autolock lock(mFrameEventHistoryMutex); 294 mFrameEventHistory.addPreComposition(mCurrentFrameNumber, 295 refreshStartTime); 296 } 297 mRefreshPending = false; 298 return mQueuedFrames > 0 || mSidebandStreamChanged || 299 mAutoRefresh; 300} 301bool BufferLayer::onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence, 302 const std::shared_ptr<FenceTime>& presentFence, 303 const CompositorTiming& compositorTiming) { 304 // mFrameLatencyNeeded is true when a new frame was latched for the 305 // composition. 306 if (!mFrameLatencyNeeded) return false; 307 308 // Update mFrameEventHistory. 309 { 310 Mutex::Autolock lock(mFrameEventHistoryMutex); 311 mFrameEventHistory.addPostComposition(mCurrentFrameNumber, glDoneFence, 312 presentFence, compositorTiming); 313 } 314 315 // Update mFrameTracker. 316 nsecs_t desiredPresentTime = mConsumer->getTimestamp(); 317 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 318 319 const std::string layerName(getName().c_str()); 320 mTimeStats.setDesiredTime(layerName, mCurrentFrameNumber, desiredPresentTime); 321 322 std::shared_ptr<FenceTime> frameReadyFence = mConsumer->getCurrentFenceTime(); 323 if (frameReadyFence->isValid()) { 324 mFrameTracker.setFrameReadyFence(std::move(frameReadyFence)); 325 } else { 326 // There was no fence for this frame, so assume that it was ready 327 // to be presented at the desired present time. 328 mFrameTracker.setFrameReadyTime(desiredPresentTime); 329 } 330 331 if (presentFence->isValid()) { 332 mTimeStats.setPresentFence(layerName, mCurrentFrameNumber, presentFence); 333 mFrameTracker.setActualPresentFence(std::shared_ptr<FenceTime>(presentFence)); 334 } else { 335 // The HWC doesn't support present fences, so use the refresh 336 // timestamp instead. 337 const nsecs_t actualPresentTime = 338 mFlinger->getHwComposer().getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 339 mTimeStats.setPresentTime(layerName, mCurrentFrameNumber, actualPresentTime); 340 mFrameTracker.setActualPresentTime(actualPresentTime); 341 } 342 343 mFrameTracker.advanceFrame(); 344 mFrameLatencyNeeded = false; 345 return true; 346} 347 348std::vector<OccupancyTracker::Segment> BufferLayer::getOccupancyHistory(bool forceFlush) { 349 std::vector<OccupancyTracker::Segment> history; 350 status_t result = mConsumer->getOccupancyHistory(forceFlush, &history); 351 if (result != NO_ERROR) { 352 ALOGW("[%s] Failed to obtain occupancy history (%d)", mName.string(), result); 353 return {}; 354 } 355 return history; 356} 357 358bool BufferLayer::getTransformToDisplayInverse() const { 359 return mConsumer->getTransformToDisplayInverse(); 360} 361 362void BufferLayer::releasePendingBuffer(nsecs_t dequeueReadyTime) { 363 if (!mConsumer->releasePendingBuffer()) { 364 return; 365 } 366 367 auto releaseFenceTime = 368 std::make_shared<FenceTime>(mConsumer->getPrevFinalReleaseFence()); 369 mReleaseTimeline.updateSignalTimes(); 370 mReleaseTimeline.push(releaseFenceTime); 371 372 Mutex::Autolock lock(mFrameEventHistoryMutex); 373 if (mPreviousFrameNumber != 0) { 374 mFrameEventHistory.addRelease(mPreviousFrameNumber, dequeueReadyTime, 375 std::move(releaseFenceTime)); 376 } 377} 378 379Region BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime) { 380 ATRACE_CALL(); 381 382 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { 383 // mSidebandStreamChanged was true 384 mSidebandStream = mConsumer->getSidebandStream(); 385 // replicated in LayerBE until FE/BE is ready to be synchronized 386 getBE().compositionInfo.hwc.sidebandStream = mSidebandStream; 387 if (getBE().compositionInfo.hwc.sidebandStream != nullptr) { 388 setTransactionFlags(eTransactionNeeded); 389 mFlinger->setTransactionFlags(eTraversalNeeded); 390 } 391 recomputeVisibleRegions = true; 392 393 const State& s(getDrawingState()); 394 return getTransform().transform(Region(Rect(s.active.w, s.active.h))); 395 } 396 397 Region outDirtyRegion; 398 if (mQueuedFrames <= 0 && !mAutoRefresh) { 399 return outDirtyRegion; 400 } 401 402 // if we've already called updateTexImage() without going through 403 // a composition step, we have to skip this layer at this point 404 // because we cannot call updateTeximage() without a corresponding 405 // compositionComplete() call. 406 // we'll trigger an update in onPreComposition(). 407 if (mRefreshPending) { 408 return outDirtyRegion; 409 } 410 411 // If the head buffer's acquire fence hasn't signaled yet, return and 412 // try again later 413 if (!headFenceHasSignaled()) { 414 mFlinger->signalLayerUpdate(); 415 return outDirtyRegion; 416 } 417 418 // Capture the old state of the layer for comparisons later 419 const State& s(getDrawingState()); 420 const bool oldOpacity = isOpaque(s); 421 sp<GraphicBuffer> oldBuffer = getBE().compositionInfo.mBuffer; 422 423 if (!allTransactionsSignaled()) { 424 mFlinger->signalLayerUpdate(); 425 return outDirtyRegion; 426 } 427 428 // This boolean is used to make sure that SurfaceFlinger's shadow copy 429 // of the buffer queue isn't modified when the buffer queue is returning 430 // BufferItem's that weren't actually queued. This can happen in shared 431 // buffer mode. 432 bool queuedBuffer = false; 433 LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 434 getProducerStickyTransform() != 0, mName.string(), 435 mOverrideScalingMode, mFreezeGeometryUpdates); 436 status_t updateResult = 437 mConsumer->updateTexImage(&r, mFlinger->mPrimaryDispSync, 438 &mAutoRefresh, &queuedBuffer, 439 mLastFrameNumberReceived); 440 if (updateResult == BufferQueue::PRESENT_LATER) { 441 // Producer doesn't want buffer to be displayed yet. Signal a 442 // layer update so we check again at the next opportunity. 443 mFlinger->signalLayerUpdate(); 444 return outDirtyRegion; 445 } else if (updateResult == BufferLayerConsumer::BUFFER_REJECTED) { 446 // If the buffer has been rejected, remove it from the shadow queue 447 // and return early 448 if (queuedBuffer) { 449 Mutex::Autolock lock(mQueueItemLock); 450 mTimeStats.removeTimeRecord(getName().c_str(), mQueueItems[0].mFrameNumber); 451 mQueueItems.removeAt(0); 452 android_atomic_dec(&mQueuedFrames); 453 } 454 return outDirtyRegion; 455 } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { 456 // This can occur if something goes wrong when trying to create the 457 // EGLImage for this buffer. If this happens, the buffer has already 458 // been released, so we need to clean up the queue and bug out 459 // early. 460 if (queuedBuffer) { 461 Mutex::Autolock lock(mQueueItemLock); 462 mQueueItems.clear(); 463 android_atomic_and(0, &mQueuedFrames); 464 mTimeStats.clearLayerRecord(getName().c_str()); 465 } 466 467 // Once we have hit this state, the shadow queue may no longer 468 // correctly reflect the incoming BufferQueue's contents, so even if 469 // updateTexImage starts working, the only safe course of action is 470 // to continue to ignore updates. 471 mUpdateTexImageFailed = true; 472 473 return outDirtyRegion; 474 } 475 476 if (queuedBuffer) { 477 // Autolock scope 478 auto currentFrameNumber = mConsumer->getFrameNumber(); 479 480 Mutex::Autolock lock(mQueueItemLock); 481 482 // Remove any stale buffers that have been dropped during 483 // updateTexImage 484 while (mQueueItems[0].mFrameNumber != currentFrameNumber) { 485 mTimeStats.removeTimeRecord(getName().c_str(), mQueueItems[0].mFrameNumber); 486 mQueueItems.removeAt(0); 487 android_atomic_dec(&mQueuedFrames); 488 } 489 490 const std::string layerName(getName().c_str()); 491 mTimeStats.setAcquireFence(layerName, currentFrameNumber, mQueueItems[0].mFenceTime); 492 mTimeStats.setLatchTime(layerName, currentFrameNumber, latchTime); 493 494 mQueueItems.removeAt(0); 495 } 496 497 // Decrement the queued-frames count. Signal another event if we 498 // have more frames pending. 499 if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) || 500 mAutoRefresh) { 501 mFlinger->signalLayerUpdate(); 502 } 503 504 // update the active buffer 505 getBE().compositionInfo.mBuffer = 506 mConsumer->getCurrentBuffer(&getBE().compositionInfo.mBufferSlot); 507 // replicated in LayerBE until FE/BE is ready to be synchronized 508 mActiveBuffer = getBE().compositionInfo.mBuffer; 509 if (getBE().compositionInfo.mBuffer == nullptr) { 510 // this can only happen if the very first buffer was rejected. 511 return outDirtyRegion; 512 } 513 514 mBufferLatched = true; 515 mPreviousFrameNumber = mCurrentFrameNumber; 516 mCurrentFrameNumber = mConsumer->getFrameNumber(); 517 518 { 519 Mutex::Autolock lock(mFrameEventHistoryMutex); 520 mFrameEventHistory.addLatch(mCurrentFrameNumber, latchTime); 521 } 522 523 mRefreshPending = true; 524 mFrameLatencyNeeded = true; 525 if (oldBuffer == nullptr) { 526 // the first time we receive a buffer, we need to trigger a 527 // geometry invalidation. 528 recomputeVisibleRegions = true; 529 } 530 531 ui::Dataspace dataSpace = mConsumer->getCurrentDataSpace(); 532 // treat modern dataspaces as legacy dataspaces whenever possible, until 533 // we can trust the buffer producers 534 switch (dataSpace) { 535 case ui::Dataspace::V0_SRGB: 536 dataSpace = ui::Dataspace::SRGB; 537 break; 538 case ui::Dataspace::V0_SRGB_LINEAR: 539 dataSpace = ui::Dataspace::SRGB_LINEAR; 540 break; 541 case ui::Dataspace::V0_JFIF: 542 dataSpace = ui::Dataspace::JFIF; 543 break; 544 case ui::Dataspace::V0_BT601_625: 545 dataSpace = ui::Dataspace::BT601_625; 546 break; 547 case ui::Dataspace::V0_BT601_525: 548 dataSpace = ui::Dataspace::BT601_525; 549 break; 550 case ui::Dataspace::V0_BT709: 551 dataSpace = ui::Dataspace::BT709; 552 break; 553 default: 554 break; 555 } 556 mCurrentDataSpace = dataSpace; 557 558 Rect crop(mConsumer->getCurrentCrop()); 559 const uint32_t transform(mConsumer->getCurrentTransform()); 560 const uint32_t scalingMode(mConsumer->getCurrentScalingMode()); 561 if ((crop != mCurrentCrop) || 562 (transform != mCurrentTransform) || 563 (scalingMode != mCurrentScalingMode)) { 564 mCurrentCrop = crop; 565 mCurrentTransform = transform; 566 mCurrentScalingMode = scalingMode; 567 recomputeVisibleRegions = true; 568 } 569 570 if (oldBuffer != nullptr) { 571 uint32_t bufWidth = getBE().compositionInfo.mBuffer->getWidth(); 572 uint32_t bufHeight = getBE().compositionInfo.mBuffer->getHeight(); 573 if (bufWidth != uint32_t(oldBuffer->width) || 574 bufHeight != uint32_t(oldBuffer->height)) { 575 recomputeVisibleRegions = true; 576 } 577 } 578 579 mCurrentOpacity = getOpacityForFormat(getBE().compositionInfo.mBuffer->format); 580 if (oldOpacity != isOpaque(s)) { 581 recomputeVisibleRegions = true; 582 } 583 584 // Remove any sync points corresponding to the buffer which was just 585 // latched 586 { 587 Mutex::Autolock lock(mLocalSyncPointMutex); 588 auto point = mLocalSyncPoints.begin(); 589 while (point != mLocalSyncPoints.end()) { 590 if (!(*point)->frameIsAvailable() || !(*point)->transactionIsApplied()) { 591 // This sync point must have been added since we started 592 // latching. Don't drop it yet. 593 ++point; 594 continue; 595 } 596 597 if ((*point)->getFrameNumber() <= mCurrentFrameNumber) { 598 point = mLocalSyncPoints.erase(point); 599 } else { 600 ++point; 601 } 602 } 603 } 604 605 // FIXME: postedRegion should be dirty & bounds 606 Region dirtyRegion(Rect(s.active.w, s.active.h)); 607 608 // transform the dirty region to window-manager space 609 outDirtyRegion = (getTransform().transform(dirtyRegion)); 610 611 return outDirtyRegion; 612} 613 614void BufferLayer::setDefaultBufferSize(uint32_t w, uint32_t h) { 615 mConsumer->setDefaultBufferSize(w, h); 616} 617 618void BufferLayer::setPerFrameData(const sp<const DisplayDevice>& displayDevice) { 619 // Apply this display's projection's viewport to the visible region 620 // before giving it to the HWC HAL. 621 const Transform& tr = displayDevice->getTransform(); 622 const auto& viewport = displayDevice->getViewport(); 623 Region visible = tr.transform(visibleRegion.intersect(viewport)); 624 auto hwcId = displayDevice->getHwcDisplayId(); 625 auto& hwcInfo = getBE().mHwcLayers[hwcId]; 626 auto& hwcLayer = hwcInfo.layer; 627 auto error = hwcLayer->setVisibleRegion(visible); 628 if (error != HWC2::Error::None) { 629 ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(), 630 to_string(error).c_str(), static_cast<int32_t>(error)); 631 visible.dump(LOG_TAG); 632 } 633 634 error = hwcLayer->setSurfaceDamage(surfaceDamageRegion); 635 if (error != HWC2::Error::None) { 636 ALOGE("[%s] Failed to set surface damage: %s (%d)", mName.string(), 637 to_string(error).c_str(), static_cast<int32_t>(error)); 638 surfaceDamageRegion.dump(LOG_TAG); 639 } 640 641 // Sideband layers 642 if (getBE().compositionInfo.hwc.sidebandStream.get()) { 643 setCompositionType(hwcId, HWC2::Composition::Sideband); 644 ALOGV("[%s] Requesting Sideband composition", mName.string()); 645 error = hwcLayer->setSidebandStream(getBE().compositionInfo.hwc.sidebandStream->handle()); 646 if (error != HWC2::Error::None) { 647 ALOGE("[%s] Failed to set sideband stream %p: %s (%d)", mName.string(), 648 getBE().compositionInfo.hwc.sidebandStream->handle(), to_string(error).c_str(), 649 static_cast<int32_t>(error)); 650 } 651 return; 652 } 653 654 // Device or Cursor layers 655 if (mPotentialCursor) { 656 ALOGV("[%s] Requesting Cursor composition", mName.string()); 657 setCompositionType(hwcId, HWC2::Composition::Cursor); 658 } else { 659 ALOGV("[%s] Requesting Device composition", mName.string()); 660 setCompositionType(hwcId, HWC2::Composition::Device); 661 } 662 663 ALOGV("setPerFrameData: dataspace = %d", mCurrentDataSpace); 664 error = hwcLayer->setDataspace(mCurrentDataSpace); 665 if (error != HWC2::Error::None) { 666 ALOGE("[%s] Failed to set dataspace %d: %s (%d)", mName.string(), mCurrentDataSpace, 667 to_string(error).c_str(), static_cast<int32_t>(error)); 668 } 669 670 const HdrMetadata& metadata = mConsumer->getCurrentHdrMetadata(); 671 error = hwcLayer->setPerFrameMetadata(displayDevice->getSupportedPerFrameMetadata(), metadata); 672 if (error != HWC2::Error::None && error != HWC2::Error::Unsupported) { 673 ALOGE("[%s] Failed to set hdrMetadata: %s (%d)", mName.string(), 674 to_string(error).c_str(), static_cast<int32_t>(error)); 675 } 676 677 uint32_t hwcSlot = 0; 678 sp<GraphicBuffer> hwcBuffer; 679 hwcInfo.bufferCache.getHwcBuffer(getBE().compositionInfo.mBufferSlot, 680 getBE().compositionInfo.mBuffer, &hwcSlot, &hwcBuffer); 681 682 auto acquireFence = mConsumer->getCurrentFence(); 683 error = hwcLayer->setBuffer(hwcSlot, hwcBuffer, acquireFence); 684 if (error != HWC2::Error::None) { 685 ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(), 686 getBE().compositionInfo.mBuffer->handle, to_string(error).c_str(), 687 static_cast<int32_t>(error)); 688 } 689} 690 691bool BufferLayer::isOpaque(const Layer::State& s) const { 692 // if we don't have a buffer or sidebandStream yet, we're translucent regardless of the 693 // layer's opaque flag. 694 if ((getBE().compositionInfo.hwc.sidebandStream == nullptr) && (getBE().compositionInfo.mBuffer == nullptr)) { 695 return false; 696 } 697 698 // if the layer has the opaque flag, then we're always opaque, 699 // otherwise we use the current buffer's format. 700 return ((s.flags & layer_state_t::eLayerOpaque) != 0) || mCurrentOpacity; 701} 702 703void BufferLayer::onFirstRef() { 704 // Creates a custom BufferQueue for SurfaceFlingerConsumer to use 705 sp<IGraphicBufferProducer> producer; 706 sp<IGraphicBufferConsumer> consumer; 707 BufferQueue::createBufferQueue(&producer, &consumer, true); 708 mProducer = new MonitoredProducer(producer, mFlinger, this); 709 mConsumer = new BufferLayerConsumer(consumer, 710 mFlinger->getRenderEngine(), mTextureName, this); 711 mConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 712 mConsumer->setContentsChangedListener(this); 713 mConsumer->setName(mName); 714 715 if (mFlinger->isLayerTripleBufferingDisabled()) { 716 mProducer->setMaxDequeuedBufferCount(2); 717 } 718 719 const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); 720 updateTransformHint(hw); 721} 722 723// --------------------------------------------------------------------------- 724// Interface implementation for SurfaceFlingerConsumer::ContentsChangedListener 725// --------------------------------------------------------------------------- 726 727void BufferLayer::onFrameAvailable(const BufferItem& item) { 728 // Add this buffer from our internal queue tracker 729 { // Autolock scope 730 Mutex::Autolock lock(mQueueItemLock); 731 mFlinger->mInterceptor->saveBufferUpdate(this, item.mGraphicBuffer->getWidth(), 732 item.mGraphicBuffer->getHeight(), 733 item.mFrameNumber); 734 // Reset the frame number tracker when we receive the first buffer after 735 // a frame number reset 736 if (item.mFrameNumber == 1) { 737 mLastFrameNumberReceived = 0; 738 } 739 740 // Ensure that callbacks are handled in order 741 while (item.mFrameNumber != mLastFrameNumberReceived + 1) { 742 status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, 743 ms2ns(500)); 744 if (result != NO_ERROR) { 745 ALOGE("[%s] Timed out waiting on callback", mName.string()); 746 } 747 } 748 749 mQueueItems.push_back(item); 750 android_atomic_inc(&mQueuedFrames); 751 752 // Wake up any pending callbacks 753 mLastFrameNumberReceived = item.mFrameNumber; 754 mQueueItemCondition.broadcast(); 755 } 756 757 mFlinger->signalLayerUpdate(); 758} 759 760void BufferLayer::onFrameReplaced(const BufferItem& item) { 761 { // Autolock scope 762 Mutex::Autolock lock(mQueueItemLock); 763 764 // Ensure that callbacks are handled in order 765 while (item.mFrameNumber != mLastFrameNumberReceived + 1) { 766 status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, 767 ms2ns(500)); 768 if (result != NO_ERROR) { 769 ALOGE("[%s] Timed out waiting on callback", mName.string()); 770 } 771 } 772 773 if (mQueueItems.empty()) { 774 ALOGE("Can't replace a frame on an empty queue"); 775 return; 776 } 777 mQueueItems.editItemAt(mQueueItems.size() - 1) = item; 778 779 // Wake up any pending callbacks 780 mLastFrameNumberReceived = item.mFrameNumber; 781 mQueueItemCondition.broadcast(); 782 } 783} 784 785void BufferLayer::onSidebandStreamChanged() { 786 if (android_atomic_release_cas(false, true, &mSidebandStreamChanged) == 0) { 787 // mSidebandStreamChanged was false 788 mFlinger->signalLayerUpdate(); 789 } 790} 791 792bool BufferLayer::needsFiltering(const RenderArea& renderArea) const { 793 return mNeedsFiltering || renderArea.needsFiltering(); 794} 795 796// As documented in libhardware header, formats in the range 797// 0x100 - 0x1FF are specific to the HAL implementation, and 798// are known to have no alpha channel 799// TODO: move definition for device-specific range into 800// hardware.h, instead of using hard-coded values here. 801#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) 802 803bool BufferLayer::getOpacityForFormat(uint32_t format) { 804 if (HARDWARE_IS_DEVICE_FORMAT(format)) { 805 return true; 806 } 807 switch (format) { 808 case HAL_PIXEL_FORMAT_RGBA_8888: 809 case HAL_PIXEL_FORMAT_BGRA_8888: 810 case HAL_PIXEL_FORMAT_RGBA_FP16: 811 case HAL_PIXEL_FORMAT_RGBA_1010102: 812 return false; 813 } 814 // in all other case, we have no blending (also for unknown formats) 815 return true; 816} 817 818bool BufferLayer::isHdrY410() const { 819 // pixel format is HDR Y410 masquerading as RGBA_1010102 820 return (mCurrentDataSpace == ui::Dataspace::BT2020_ITU_PQ && 821 mConsumer->getCurrentApi() == NATIVE_WINDOW_API_MEDIA && 822 getBE().compositionInfo.mBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102); 823} 824 825void BufferLayer::drawWithOpenGL(const RenderArea& renderArea, bool useIdentityTransform) const { 826 ATRACE_CALL(); 827 const State& s(getDrawingState()); 828 829 computeGeometry(renderArea, getBE().mMesh, useIdentityTransform); 830 831 /* 832 * NOTE: the way we compute the texture coordinates here produces 833 * different results than when we take the HWC path -- in the later case 834 * the "source crop" is rounded to texel boundaries. 835 * This can produce significantly different results when the texture 836 * is scaled by a large amount. 837 * 838 * The GL code below is more logical (imho), and the difference with 839 * HWC is due to a limitation of the HWC API to integers -- a question 840 * is suspend is whether we should ignore this problem or revert to 841 * GL composition when a buffer scaling is applied (maybe with some 842 * minimal value)? Or, we could make GL behave like HWC -- but this feel 843 * like more of a hack. 844 */ 845 const Rect bounds{computeBounds()}; // Rounds from FloatRect 846 847 Transform t = getTransform(); 848 Rect win = bounds; 849 if (!s.finalCrop.isEmpty()) { 850 win = t.transform(win); 851 if (!win.intersect(s.finalCrop, &win)) { 852 win.clear(); 853 } 854 win = t.inverse().transform(win); 855 if (!win.intersect(bounds, &win)) { 856 win.clear(); 857 } 858 } 859 860 float left = float(win.left) / float(s.active.w); 861 float top = float(win.top) / float(s.active.h); 862 float right = float(win.right) / float(s.active.w); 863 float bottom = float(win.bottom) / float(s.active.h); 864 865 // TODO: we probably want to generate the texture coords with the mesh 866 // here we assume that we only have 4 vertices 867 Mesh::VertexArray<vec2> texCoords(getBE().mMesh.getTexCoordArray<vec2>()); 868 texCoords[0] = vec2(left, 1.0f - top); 869 texCoords[1] = vec2(left, 1.0f - bottom); 870 texCoords[2] = vec2(right, 1.0f - bottom); 871 texCoords[3] = vec2(right, 1.0f - top); 872 873 auto& engine(mFlinger->getRenderEngine()); 874 engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), false /* disableTexture */, 875 getColor()); 876 engine.setSourceDataSpace(mCurrentDataSpace); 877 878 if (isHdrY410()) { 879 engine.setSourceY410BT2020(true); 880 } 881 882 engine.drawMesh(getBE().mMesh); 883 engine.disableBlending(); 884 885 engine.setSourceY410BT2020(false); 886} 887 888uint32_t BufferLayer::getProducerStickyTransform() const { 889 int producerStickyTransform = 0; 890 int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform); 891 if (ret != OK) { 892 ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__, 893 strerror(-ret), ret); 894 return 0; 895 } 896 return static_cast<uint32_t>(producerStickyTransform); 897} 898 899bool BufferLayer::latchUnsignaledBuffers() { 900 static bool propertyLoaded = false; 901 static bool latch = false; 902 static std::mutex mutex; 903 std::lock_guard<std::mutex> lock(mutex); 904 if (!propertyLoaded) { 905 char value[PROPERTY_VALUE_MAX] = {}; 906 property_get("debug.sf.latch_unsignaled", value, "0"); 907 latch = atoi(value); 908 propertyLoaded = true; 909 } 910 return latch; 911} 912 913uint64_t BufferLayer::getHeadFrameNumber() const { 914 Mutex::Autolock lock(mQueueItemLock); 915 if (!mQueueItems.empty()) { 916 return mQueueItems[0].mFrameNumber; 917 } else { 918 return mCurrentFrameNumber; 919 } 920} 921 922bool BufferLayer::headFenceHasSignaled() const { 923 if (latchUnsignaledBuffers()) { 924 return true; 925 } 926 927 Mutex::Autolock lock(mQueueItemLock); 928 if (mQueueItems.empty()) { 929 return true; 930 } 931 if (mQueueItems[0].mIsDroppable) { 932 // Even though this buffer's fence may not have signaled yet, it could 933 // be replaced by another buffer before it has a chance to, which means 934 // that it's possible to get into a situation where a buffer is never 935 // able to be latched. To avoid this, grab this buffer anyway. 936 return true; 937 } 938 return mQueueItems[0].mFenceTime->getSignalTime() != 939 Fence::SIGNAL_TIME_PENDING; 940} 941 942uint32_t BufferLayer::getEffectiveScalingMode() const { 943 if (mOverrideScalingMode >= 0) { 944 return mOverrideScalingMode; 945 } 946 return mCurrentScalingMode; 947} 948 949// ---------------------------------------------------------------------------- 950// transaction 951// ---------------------------------------------------------------------------- 952 953void BufferLayer::notifyAvailableFrames() { 954 auto headFrameNumber = getHeadFrameNumber(); 955 bool headFenceSignaled = headFenceHasSignaled(); 956 Mutex::Autolock lock(mLocalSyncPointMutex); 957 for (auto& point : mLocalSyncPoints) { 958 if (headFrameNumber >= point->getFrameNumber() && headFenceSignaled) { 959 point->setFrameAvailable(); 960 } 961 } 962} 963 964sp<IGraphicBufferProducer> BufferLayer::getProducer() const { 965 return mProducer; 966} 967 968// --------------------------------------------------------------------------- 969// h/w composer set-up 970// --------------------------------------------------------------------------- 971 972bool BufferLayer::allTransactionsSignaled() { 973 auto headFrameNumber = getHeadFrameNumber(); 974 bool matchingFramesFound = false; 975 bool allTransactionsApplied = true; 976 Mutex::Autolock lock(mLocalSyncPointMutex); 977 978 for (auto& point : mLocalSyncPoints) { 979 if (point->getFrameNumber() > headFrameNumber) { 980 break; 981 } 982 matchingFramesFound = true; 983 984 if (!point->frameIsAvailable()) { 985 // We haven't notified the remote layer that the frame for 986 // this point is available yet. Notify it now, and then 987 // abort this attempt to latch. 988 point->setFrameAvailable(); 989 allTransactionsApplied = false; 990 break; 991 } 992 993 allTransactionsApplied = allTransactionsApplied && point->transactionIsApplied(); 994 } 995 return !matchingFramesFound || allTransactionsApplied; 996} 997 998} // namespace android 999 1000#if defined(__gl_h_) 1001#error "don't include gl/gl.h in this file" 1002#endif 1003 1004#if defined(__gl2_h_) 1005#error "don't include gl2/gl2.h in this file" 1006#endif 1007